Typowe Idiomy Ruby

Ten pokaz slajdów jest całkiem kompletny na temat głównych idiomów Ruby, jak w:

• Zamień dwie wartości:

  x, y = y, x

• Parametry, które, jeśli nie są określone, przyjmują jakąś wartość domyślną

  def somemethod(x, y=nil)

• Szereguje zewnętrzne parametry do tablicy

  def substitute(re, str, *rest)

I tak dalej...

Jeszcze kilka idiomów:

Użycie %w, %r i %( ograniczniki

%w{ An array of strings %}
%r{ ^http:// }
%{ I don't care if the string has 'single' or "double" strings }

Porównanie typu w przypadku wypowiedzi

def something(x)
  case x
    when Array
      # Do something with array
    when String
      # Do something with string
    else
      # You should really teach your objects how to 'quack', don't you?
  end
end

... i ogólne nadużywanie metody === W przypadku wypowiedzi

case x
  when 'something concrete' then ...
  when SomeClass then ...
  when /matches this/ then ...
  when (10...20) then ...
  when some_condition >= some_value then ...
  else ...
end

Coś, co powinno wyglądać naturalnie dla Rubyistów, ale może nie tak dla osób pochodzących z innych języków: użycie each na rzecz for .. in

some_iterable_object.each{|item| ... }

W Ruby 1.9+, Rails, lub poprzez łatanie metody symbolu#To_proc, to staje się coraz bardziej popularny idiom:

strings.map(&:upcase)

Metoda warunkowa / definicja stałej

SOME_CONSTANT = "value" unless defined?(SOME_CONSTANT)

Metody zapytań i metody destrukcyjne (bang)

def is_awesome?
  # Return some state of the object, usually a boolean
end

def make_awesome!
  # Modify the state of the object
end

Implicit splat parameters

[[1, 2], [3, 4], [5, 6]].each{ |first, second| puts "(#{first}, #{second})" }

Podoba mi się:

str = "Something evil this way comes!"
regexp = /(\w[aeiou])/

str[regexp, 1] # <- This

Co jest (mniej więcej) równoważne:

str_match = str.match(regexp)
str_match[1] unless str_match.nil?

A przynajmniej tego użyłem do zastąpienia takich klocków.

Sugerowałbym przeczytanie kodu popularnych i dobrze zaprojektowanych wtyczek lub perełek od ludzi, których podziwiasz i szanujesz.

Kilka przykładów, na które wpadłem:

if params[:controller] == 'discussions' or params[:controller] == 'account'
  # do something here
end

Odpowiadające

if ['account', 'discussions'].include? params[:controller]
  # do something here
end

, które później zmieniłyby się na

if ALLOWED_CONTROLLERS.include? params[:controller]
  # do something here
end

Oto kilka, pobranych z różnych źródeł:

Użyj "until " I" until "zamiast" if not " I "while not". Staraj się jednak nie używać "chyba", gdy istnieje warunek "else".

Pamiętaj, że możesz przypisać wiele zmiennych jednocześnie:

a,b,c = 1,2,3

I nawet zamiana zmiennej bez temp:

a,b = b,a

W razie potrzeby stosuj warunki końcowe, np.

do_something_interesting unless want_to_be_bored?

Bądź świadomy powszechnie używanego, ale nie od razu oczywistego (przynajmniej dla mnie) sposobu definiowania klasy metody:

class Animal
  class<<self
    def class_method
      puts "call me using Animal.class_method"
    end
  end
end

Niektóre odniesienia:

• http://cbcg.net/talks/rubyidioms/index.html
• http://www.therailsway.com/2006/12/8/idiomatic-ruby
• http://www.therailsway.com/2007/1/21/more-idiomatic-ruby
• http://www.caliban.org/ruby/rubyguide.shtml

Przy okazji, z odwołanego pytanie

a ||= b 

Jest równoważne

if a == nil   
  a = b 
end

Jest to subtelnie niepoprawne i jest źródłem błędów w aplikacjach Ruby dla nowych użytkowników.

Ponieważ zarówno (i tylko) nil i false oceniają na wartość logiczną false, a ||= b jest w rzeczywistości (prawie*) równoważne:

if a == nil || a == false
  a = b
end

Lub, aby przepisać go innym idiomem Ruby:

a = b unless a

(*ponieważ każde polecenie ma wartość, nie są one technicznie równoważne a ||= b. Ale jeśli nie polegasz na wartości oświadczenia, nie zobaczysz różnicy.)

Prowadzę stronę wiki, która zawiera niektóre idiomy Ruby i formatowanie:

Https://github.com/tokland/tokland/wiki/RubyIdioms

Możesz łatwo wykonać głęboką kopię za pomocą obiektu Marshaling. - zaczerpnięte z języka programowania Ruby

def deepcopy(o)
  Marshal.load(Marshal.dump(o))
end

Zauważ, że pliki i strumienie We/Wy, jako oraz metody i Obiekty wiążące, są zbyt dynamiczne, aby można było je rozbudowywać; tam to nie będzie niezawodny sposób na przywrócenie ich stan.

a = (b && b.attribute) || "default"

Jest mniej więcej:

if ( ! b.nil? && ! b == false) && ( ! b.attribute.nil? && ! b.attribute.false) a = b
else a = "default"

Używam tego, gdy B jest rekordem, który został znaleziony lub nie, i muszę zdobyć jeden z jego atrybutów.

Zawsze zapominam dokładną składnię tego skrótu if else (I nazwę operatora. komentuje ktoś?) Myślę, że jest on powszechnie używany poza Rubim, ale na wypadek, gdyby ktoś inny chciał mieć tutaj składnię:

refactor < 3 ? puts("No need to refactor YET") : puts("You need to refactor this into a  method")

Rozszerza się do

if refactor < 3
  puts("No need to refactor YET")
else
  puts("You need to refactor this into a  method")
end

update

Nazywany operatorem trójdzielnym:

Lubię jak If-then-elses lub case-when mogą być skrócone, ponieważ zwracają wartość:

if test>0
  result = "positive"
elsif test==0
  result = "zero"
else
  result = "negative"
end

Można przepisać

result = if test>0
  "positive"
elsif test==0
  "zero"
else
  "negative"
end

To samo można zastosować do case-when:

result = case test
when test>0 ; "positive"
when test==0 ; "zero"
else "negative"
end

Array.opakowanie i sznurek.rozpakuj do pracy z plikami binarnymi:

# extracts four binary sint32s to four Integers in an Array
data.unpack("iiii") 

Method missing magick

class Dummy  
  def method_missing(m, *args, &block)  
    "You just called method with name #{m} and arguments- #{args}"  
  end  
end

Dummy.new.anything(10, 20)
=> "You just called method with name anything and arguments- [10, 20]"

Jeśli wywołasz metody, które nie istnieją w obiektach ruby, interpreter ruby wywoła metodę o nazwie 'method_missing', jeśli jest zdefiniowana, możesz użyć jej do pewnych sztuczek, takich jak pisanie owijarek api lub dsl, gdzie nie znasz wszystkich metod i nazw parametrów

Ładne pytanie!

Ponieważ myślę, że im bardziej intuicyjny i szybszy jest kod, budujemy lepsze oprogramowanie. Pokażę Ci, jak wyrażam swoje myśli używając Rubiego w małych fragmentach kodu. Czytaj więcej tutaj

Mapa

Możemy używać metody map na różne sposoby:

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

Lub:

user_ids = users.map(&:id)

Próbka

Możemy użyć metody rand:

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

Shuffle:

[1, 2, 3].shuffle.first

I idiomatyczne, proste i najłatwiejsze sposób... próbka!

[1, 2, 3].sample

Podwójna Rura Równa Się / Memoizacja

Jak powiedziałeś w opisie, możemy użyć memoizacji:

some_variable ||= 10
puts some_variable # => 10

some_variable ||= 99
puts some_variable # => 10

Metoda Statyczna / Metoda Klasy

Lubię używać metod klasowych, uważam, że jest to naprawdę idiomatyczny sposób tworzenia i używania klas:

GetSearchResult.call(params)

Proste. Pięknie. Intuicyjne. Co dzieje się w tle?

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

  def initialize(params)
    @params = params
  end

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

Aby uzyskać więcej informacji do napisania idiomatycznego kodu Ruby, przeczytaj Proszę.