Ruby este un limbaj de programare frumos.

Conform Rubinpagina web oficială, Ruby este un:

limbaj de programare dinamic, open source, cu accent pe simplitate și productivitate. Are o sintaxă elegantă, naturală de citit și ușor de scris. ”

Ruby a fost creat de Yukihiro Matsumoto, un inginer software japonez. Din 2011, a fost proiectant șef și inginer software pentru Ruby la Heroku.

Matsumoto a spus adesea că încearcă pentru a face Ruby natural, nu simplu, într-un mod care oglindește viața.

„Rubinul are un aspect simplu, dar este foarte complex în interior, la fel ca și corpul nostru uman” – Yukihiro Matsumoto

Simt la fel la Ruby. Este un limbaj de programare complex, dar foarte natural, cu o sintaxă frumoasă și intuitivă.

Cu un cod mai intuitiv și mai rapid, suntem capabili să construim software mai bun. În această postare, vă voi arăta cum îmi exprim gândurile (aka cod) cu Ruby, folosind fragmente de cod.

Exprimându-mi gândurile cu metode matrice

Hartă

Folosește Hartă metodă pentru a vă simplifica codul și a obține ceea ce doriți.

Metoda Hartă returnează o nouă matrice cu rezultatele executării unui bloc o dată pentru fiecare element din enum.

Hai sa incercam:

an_array.map { |element| element * element }

Simplu.

Dar când începeți codarea cu Ruby, este ușor să utilizați întotdeauna fiecare iterator.

fiecare iterator așa cum se arată mai jos

user_ids = []
users.each { |user| user_ids << user.id }

Poate fi simplificat cu Hartă într-o singură linie frumoasă de cod:

user_ids = users.map { |user| user.id }

Sau chiar mai bine (și mai rapid):

user_ids = users.map(&:id)

Selectați

Și când ești obișnuit să codezi cu Hartă, uneori codul dvs. poate fi astfel:

even_numbers = [1, 2, 3, 4, 5].map { |element| element if element.even? } # [ni, 2, nil, 4, nil]
even_numbers = even_numbers.compact # [2, 4]

Folosind Hartă pentru a selecta numai numerele pare va reveni la zero obiect de asemenea. Folosește compact metoda de eliminare a tuturor zero obiecte.

Și da, ai selectat toate numerele pare.

Misiune indeplinita.

Haide, putem face mai bine decât asta! Ai auzit de Selectați metoda din modul enumerabil?

[1, 2, 3, 4, 5].select { |element| element.even? }

Doar o linie. Cod simplu. Ușor de înțeles.

Primă

[1, 2, 3, 4, 5].select(&:even?)

Probă

Imaginați-vă că trebuie să obțineți un element aleatoriu dintr-o matrice. Tocmai ai început să înveți Ruby, așa că primul tău gând va fi „Să folosim Aleatoriu metodă ”, și asta se întâmplă:

[1, 2, 3][rand(3)]

Ei bine, putem înțelege codul, dar nu sunt sigur dacă este suficient de bun. Și ce se întâmplă dacă folosim amesteca metodă?

[1, 2, 3].shuffle.first

Hmm. De fapt prefer să folosesc amesteca peste rand. Dar când am descoperit probă metoda, avea mult mai mult sens:

[1, 2, 3].sample

Într-adevăr, foarte simplu.

Destul de natural și intuitiv. Întrebăm o probă dintr-o matrice și metoda o returnează. Acum sunt fericit.

Și tu?

Exprimându-mi gândurile cu sintaxa Ruby

Așa cum am menționat anterior, îmi place felul în care Ruby îmi permite să codez. Este cu adevărat natural pentru mine. Voi arăta părți din frumoasa sintaxă Ruby.

Întoarcere implicită

Orice declarație din Ruby returnează valoarea ultimei expresii evaluate. Un exemplu simplu este getter metodă. Numim o metodă și ne așteptăm la o anumită valoare în schimb.

Să vedem:

def get_user_ids(users)
  return users.map(&:id)
end

Dar, după cum știm, Ruby returnează întotdeauna ultima expresie evaluată. De ce să folosiți întoarcere afirmație?

După ce am folosit Ruby timp de 3 ani, mă simt minunat folosind aproape toate metodele fără întoarcere afirmație.

def get_user_ids(users)
  users.map(&:id)
end

Sarcini multiple

Ruby îmi permite să atribuie mai multe variabile în același timp. Când începeți, este posibil să codificați astfel:

def values
  [1, 2, 3]
end

one   = values[0]
two   = values[1]
three = values[2]

Dar de ce să nu atribuiți mai multe variabile în același timp?

def values
  [1, 2, 3]
end

one, two, three = values

Destul de tare.

Metode care pun întrebări (numite și predicate)

O caracteristică care mi-a atras atenția când învățam Ruby a fost semnul întrebării (?) metoda, numită și predicate metode. A fost ciudat să vedem la început, dar acum are atât de mult sens. Puteți scrie cod astfel:

movie.awesome # => true

Ok … nimic în neregulă cu asta. Dar să folosim semnul întrebării:

movie.awesome? # => true

Acest cod este mult mai expresiv și mă aștept ca răspunsul metodei să returneze fie a Adevărat sau fals valoare.

O metodă pe care o folosesc în mod obișnuit este orice? Este ca și cum ai întreba o matrice dacă are oricelucru din interiorul ei.

[].any? # => false
[1, 2, 3].any? # => true

Interpolare

Pentru mine interpolarea șirurilor este mai intuitivă decât concatenarea șirurilor. Perioadă. Să o vedem în acțiune.

Un exemplu de concatenare șir:

programming_language = "Ruby"
programming_language + " is a beautiful programming_language" # => "Ruby is a beautiful programming_language"

Un exemplu de interpolare de șiruri:

programming_language = "Ruby"
"#{programming_language} is a beautiful programming_language" # => "Ruby is a beautiful programming_language"

Prefer interpolarea șirurilor.

Ce crezi?

Afirmația if

Îmi place să folosesc dacă afirmație:

def hey_ho?
  true
end

puts "let’s go" if hey_ho?

Destul de drăguț să codezi așa.

Se simte cu adevărat natural.

Metoda try (cu modul Rails activat)

încerca metoda invocă metoda identificată de simbol, trecându-i orice argumente și / sau blocul specificat. Acest lucru este similar cu Ruby Obiect # trimitere. Spre deosebire de această metodă, zero va fi returnat dacă obiectul receptor este un zero obiect sau NilClass.

Folosind dacă și dacă declarație de stare:

user.id unless user.nil?

Folosind încerca metodă:

user.try(:id)

De la Ruby 2.3, putem folosi operatorul de navigație sigură Ruby (&.) în loc de șine încerca metodă.

user&.id

Dubla țeavă este egală cu (|| =) / memoizare

Această caracteristică este atât de COOL. Este ca și cum se păstrează în cache o valoare într-o variabilă.

some_variable ||= 10
puts some_variable # => 10

some_variable ||= 99
puts some_variable # => 10

Nu trebuie să utilizați dacă declarație vreodată. Folosiți pur și simplu dublu egal (|| =) și s-a făcut.

Simplu și ușor.

Metoda statică de clasă

Un mod în care îmi place să scriu clase Ruby este să definesc un static metoda (metoda clasei).

GetSearchResult.call(params)

Simplu. Frumos. Intuitiv.

Ce se întâmplă în fundal?

class GetSearchResult
  def self.call(params)
    new(params).call
  end

  def initialize(params)
    @params = params
  end

  def call
    # ... your code here ...
  end
end

self.call metoda inițializează o instanță, iar acest obiect apelează apel metodă. Model de interacțiune îl folosește.

Getters și seters

Pentru același GetSearchResult clasă, dacă vrem să folosim params, putem folosi @params

class GetSearchResult
  def self.call(params)
    new(params).call
  end

  def initialize(params)
    @params = params
  end

  def call
    # ... your code here ...
    @params # do something with @params
  end
end

Definim a setter și getter:

class GetSearchResult
  def self.call(params)
    new(params).call
  end

  def initialize(params)
    @params = params
  end

  def call
    # ... your code here ...
    params # do something with params method here
  end

  private

  def params
    @params
  end

  def params=(parameters)
    @params = parameters
  end
end

Sau putem defini attr_reader, attr_writer, sau attr_accessor

class GetSearchResult
  attr_reader :param

  def self.call(params)
    new(params).call
  end

  def initialize(params)
    @params = params
  end

  def call
    # ... your code here ...
    params # do something with params method here
  end
end

Grozav.

Nu trebuie să definim getter și setter metode. Codul tocmai a devenit mai simplu, exact ceea ce ne dorim.

Atingeți

Imaginați-vă că doriți să definiți un creaza utilizator metodă. Această metodă va crea instanțe, va seta parametrii și va salva și returna utilizatorul.

S-o facem.

def create_user(params)
  user       = User.new
  user.id    = params[:id]
  user.name  = params[:name]
  user.email = params[:email]
  # ...
  user.save
  user
end

Simplu. Nimic în neregulă aici.

Deci, acum să-l implementăm cu Atingeți metodă

def create_user(params)
  User.new.tap do |user|
    user.id    = params[:id]
    user.name  = params[:name]
    user.email = params[:email]
    # ...
    user.save
  end
end

Trebuie doar să vă faceți griji cu privire la parametrii utilizatorului și la Atingeți metoda va returna obiectul utilizatorului pentru dvs.

Asta este

Am învățat că scriu Ruby idiomatic codând cu

  • metode matrice
  • sintaxă

De asemenea, am aflat cum Ruby este frumos și intuitiv și rulează și mai repede.

Și atât, băieți! Voi actualiza și include mai multe detalii la adresa mea blog. Ideea este să împărtășești conținut excelent, iar comunitatea ajută la îmbunătățirea acestei postări! ☺

Sper că voi apreciați conținutul și ați învățat cum să programați un cod frumos (și un software mai bun).

Dacă doriți un curs complet Ruby, învățați abilități de codare din lumea reală și construiți proiecte, încercați O lună Ruby Bootcamp. Ne vedem acolo ☺

Această postare a apărut prima Aici pe mine Publicația Renaissance Developer.

Distrează-te, continuă să înveți și continuă să codezi mereu!

Ale mele Stare de nervozitate & Github. ☺