Quali sono gli hash delle opzioni?

Question

Qualcuno può spiegare gli hash delle opzioni? Sto lavorando attraverso il corso rubino da testfirst.org. L'esercizio 10 (termometro) richiede la conoscenza degli hash delle opzioni.

Answer 1

L'hash delle opzioni è un bel concetto abilitato da una funzionalità del parser rubino. Di ', hai un metodo con alcuni argomenti richiesti. Inoltre puoi passare alcuni argomenti opzionali. Nel tempo potresti aggiungere altri argomenti facoltativi o rimuovere quelli vecchi. Per mantenere la dichiarazione del metodo pulita e stabile, è possibile passare tutti gli argomenti opzionali in un hash. Tale metodo sarebbe simile a questo:

def foo(arg1, arg2, opts = {}) 
    opts.to_s # just return a string value of opts 
end 

Quindi ha due valori richiesti e l'ultimo argomento con valore predefinito di hash. Se non si dispone di alcun argomento opzionale per passare, si chiama così:

foo(1, 2) # => "{}" 

Se avete qualcosa di opzionale, è chiamare in questo modo:

foo(1, 2, {truncate: true, redirect_to: '/'}) # => "{:truncate=>true, :redirect_to=>\"/\"}" 

Questo codice è così idiomatica al rubino che il suo parser permette in realtà di omettere le parentesi graffe quando passa hash come un ultimo argomento a un metodo:

foo(1, 2, truncate: true, redirect_to: '/') # => "{:truncate=>true, :redirect_to=>\"/\"}" 

Se si utilizza rotaie, ad esempio, verranno visualizzate le opzioni hash ovunque. Qui, ho aperto appena un controller a caso nella mia app:

class ProductsController < ApplicationController 
    before_filter :prepare_search_params, only: :index 
            # ^^^^^^^^^^ options hash here 

Così, in breve: hash opzioni è argomento di un metodo che si trova scorsa e ha valore di default di {}. E normalmente passate hash (da qui il nome).

Answer 2

Un opzioni hash riferisce alla convenzione di opzioni di passaggio per i metodi usando un hash ({}) come modo

my_func(arg1, arg2, {:opt1 => 'foo', :opt2 => 'bar'}) 

La convenzione è per le opzioni di hash per essere l'ultimo argomento in modo che possa essere reso facoltativo . Per esempio.

def my_func(argument1, argument2, options = {}) 
    ... 
end 

Quindi un hash di opzioni non è niente di speciale. È solo un argomento finale opzionale che è un hash. Opzioni di hash sono così a portata di mano e comune che l'interprete permette anche di lasciare fuori le parentesi (questa è una parte "speciale" su di loro)

my_func(arg1, arg2, :opt1 => 'foo', :opt2 => 'bar') 

In combinazione con cancelletto tasto di scelta rapida di Ruby e le parentesi opzionali, questo può finire cerca veramente pulito:

my_func arg1, arg2, opt1: 'foo', opt2: 'bar' 

Answer 3

Merge Reverse è il modo migliore per attuare le opzioni hash in ruby ​​/ rails:

def set_state_application(options_hash) 
    options_hash.reverse_merge!(send_email: true, other_default_val: 'a') #will set defaults 
    self.update_column(:status_id, VendorEnums::VendorStatus::APPLICATION) 
    VendorMailer.email_application(self) if options_hash[:send_email] 
    save_state 
end 

Answer 4

opzioni hash vengono utilizzate molto quando n eed per passare argomenti opzionali al metodo.

Ad esempio, se il metodo ha uno-due args opzionali, è possibile scrivere

def method(arg1, arg2 = nil, arg3 = nil) 
    ... 
end 

Ma se avete arg più opzionale Sta diventando brutto per assegnarli a zero ogni volta. Arriva l'hash opzioni che consente di scrivere

def method(arg1, options={}) 
    @arg1 = arg1 
    @arg2 = options[:arg2] 
    .... 
    @arg15 = options[:arg15] 
end 

Answer 5

Dal momento che tutte queste risposte sono corrette, rubino 2 ha migliorato il supporto per parole chiave argomenti.

È possibile definire il metodo con i parametri hash predefiniti come *args e liberare lo options = {}.

def foo(bar: 'initial') 
    puts bar 
end 

foo # => 'initial' 
foo(bar: 'final') # => 'final' 

argomenti obbligatori: avete bisogno di due punti dopo che la chiave (hai bisogno anche di rubino 2.1)

def foo(bar:) 
    puts bar 
end 

foo # => ArgumentError: missing keyword: bar 
foo(bar: 'baz') # => 'baz' 

argomenti opzionali, è possibile impostare il valore predefinito per nil

def foo(bar: nil, baz: 'aaa') 
    puts "#{bar}:#{baz}" 
end 

foo # => ':aaa' 
foo(baz: 'zab') # => ':zab' 
foo(bar: 'rab', baz: 'zab') # => 'rab:zab' 
foo(bin: 'bin') # => ArgumentError: unknown keyword: bin 

Inoltre è può usare gli argomenti posizionali standard con questa nuova notazione dei parametri hash. Ulteriori informazioni sono disponibili in questo blog e nella documentazione oficial.

Bonus: Il refactoring è semplice perché puoi eliminare l'hash delle opzioni del tuo metodo senza cambiarne le chiamate. Ma ... questo non è completamente vero, se hai una chiamata con un'opzione inaspettata riceverai un ArgumentError: unknown keyword: invalid_arg.