In che modo i metodi utilizzano gli argomenti hash in Ruby?

Question

Ho visto gli argomenti di hash utilizzati in alcuni metodi di libreria come ho imparato.

esempio

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

Qualcuno può spiegare come un metodo utilizza argomenti come questo, e in che modo si potrebbe creare un metodo che fa uso di argomenti Hash?

Answer 1

Esempio:

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) 

Io uso hash={} per specificare che l'ultimo argomento è un hash, con valore predefinito di hash vuoto. Ora, quando scrivo:

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

In realtà è uno zucchero sintattico per:

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

Inoltre, {a: 12} è zucchero sintattico per {:a => 12}.

Quando tutto questo viene combinato insieme, si ottiene una sintassi simile agli argomenti denominati in altre lingue.

Answer 2

Vorrei fare una delle due opzioni:

1- se un ottenuto un gran numero di argomenti da passare in un metodo vorrei usare un hash come questo:

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

o

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

e

def some_method(hash_options) 
    #important code 
end 

2- opzione sarà più 'tradizionale'

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

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

Answer 3

Quando lista degli argomenti di una chiamata al metodo di Ruby finisce in una o più coppie chiave-valore, come foo: 'bar' o 'foo' => 1, Ruby li raccoglie in un unico hash e passa che hash come ultimo parametro. Si può vedere che se stessi in irb:

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

Così, è possibile aggiungere un parametro finale, opzionale per un metodo che si sta scrivendo a ricevere questo hash. Normalmente vorrai impostarlo su un hash vuoto. È possibile chiamare il parametro tutto quello che vuoi, ma options è un nome comune:

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

Un trucco utile se si sta utilizzando Rails: E 'spesso utile per il trattamento di stringhe e simboli semplici come equivalenti. Rails aggiunge un metodo symbolize_keys!-Hash per convertire tutte le chiavi di stringa per simboli:

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

Answer 4

In Ruby 2.x, è possibile utilizzare ** hash splat:

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

Da Ruby 2.0 è possibile utilizzare gli argomenti della parola chiave ^{[1] [2]} in contrasto con il singolo parametro Hash.

def foo(keyword_arg: 'bar') 
    keyword_arg 
end 

Ed ecco come si comporta.

> 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

Questo è come lo faccio:

def my_method(title, args) 
    puts title 
    puts args 

passaggio di parametri:

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