W jaki sposób metody używają argumentów mieszania w Ruby?

Question

Widziałem argumenty mieszania używane w niektórych metodach bibliotecznych, jak uczyłem się.

np

list.search(:titles, genre: 'jazz', duration_less_than: 270) 

Czy ktoś może wyjaśnić, w jaki sposób używa argumentów tak, i jak można stworzyć metodę, która sprawia, że ​​korzystanie z argumentów Hash?

Answer 1

Przykład:

def foo(regular, hash={}) 
    puts "regular: #{regular}" 
    puts "hash: #{hash}" 
    puts "a: #{hash[:a]}" 
    puts "b: #{hash[:b]}" 
end 

foo("regular argument", a: 12, :b => 13) 

używam hash={} aby określić, że ostatni argument jest hash, z domyślnej wartości pustej hash. Teraz, gdy piszę:

foo("regular argument", a: 12, :b => 13) 

To rzeczywiście cukier syntaktyczny dla:

foo("regular argument", {a: 12, :b => 13}) 

Również {a: 12} jest cukier syntaktyczny dla {:a => 12}.

Po połączeniu wszystkich elementów uzyskuje się składnię podobną do nazwanych argumentów w innych językach.

Answer 2

chciałbym zrobić jedną z dwóch opcji:

1- jeśli mam wiele argumentów przekazać do metody chciałbym użyć hash tak:

some_method({titles => 'titulo', genre => 'jazz', duration_less_than => 270}) 

lub

my_hash = {titles => 'titulo', genre => 'jazz', duration_less_than => 270} 
some_method(my_hash) 

i

def some_method(hash_options) 
    #important code 
end 

2- opcja będzie bardziej „tradycyjne”

some_method('titulo', 'jazz', 270) 

def some_method(titles, genre, duration_less_than) 
#important code 
end 

Answer 3

Kiedy lista metodę Ruby wywołania za argumentem kończy się w jednej lub więcej par klucz-wartość, jak foo: 'bar' lub 'foo' => 1, Ruby zbiera je wszystkie w jeden hash i przekazuje, że hash jako ostatni parametr. Widać, że się w irb:

irb(main):002:0> puts foo: 'bar', baz: 'quux' 
{:foo=>"bar", :baz=>"quux"} 
=> nil 

Zatem można dodać końcowy, opcjonalny parametr do metody piszesz do otrzymania tego skrótu. Zazwyczaj będziesz chciał ustawić domyślny pusty hasz. można wywołać parametr, który ma niczego, ale options to nazwa zwyczajowa:

def my_method(a, b, c, options = {}) 
    ... 
end 

Jeden przydatna sztuczka jeśli używasz Rails: To jest często przydatna w leczeniu zwykłe ciągi i symboli za równoważne. Szyny dodaje metodę symbolize_keys! do Hash konwertować wszystkie klucze ciąg symboli:

def my_method(a, b, c, options = {}) 
    options.symbolize_keys! 
    ... 
end 

Answer 4

W Ruby 2.x, można użyć ** hash ikona:

def foo(ordered_argument, **named_arguments) 
    puts "Ordered argument: #{ordered_argument}" 
    puts "Named arguments: #{named_arguments}" 
end 

foo(:titles, genre: 'jazz', duration_less_than: 270) 
#=> Ordered argument: titles 
#=> Named arguments: {:genre=>"jazz", :duration_less_than=>270} 

Answer 5

Od Ruby 2.0 możesz użyć argumentów słów kluczowych: ^{[1] [2]} w przeciwieństwie do pojedynczego parametru Hash.

def foo(keyword_arg: 'bar') 
    keyword_arg 
end 

A oto jak się zachowuje.

> foo 
=> "bar" 
> foo(keyword_arg: 'baz') 
=> "baz" 

1. http://robots.thoughtbot.com/ruby-2-keyword-arguments
2. http://brainspec.com/blog/2012/10/08/keyword-arguments-ruby-2-0/

Answer 6

To jak to zrobić:

def my_method(title, args) 
    puts title 
    puts args 

przekazywania parametrów:

my_method('test title', a: 'foo', b: 'bar') 
    # => test title 
    # => '{:a => 'foo', :b => 'bar'}