Quali sono le diverse possibilità di passare i parametri nei metodi ruby? param/hashlist/array/aproc?

Question

mi sto cercando di capire Ruby in modo più approfondito e stava leggendo:

http://www.zenspider.com/Languages/Ruby/QuickRef.html#25

Comunque, io non capisco che cosa i seguenti mezzi in questa definizione:

parameters := ([param]* [, hashlist] [*array] [&aProc]) 

so "param" è qualsiasi numero di parametri specificato, e quindi mi perdo ciò che significa il resto?

Ad esempio, ho:

def doIt(param1, param2, param3) 
end 

e in questo caso [param] * è uguale a param1, param2, param3 ... quindi da dove hashlist entrare? e * array e & aProc?

Qualcuno potrebbe chiarire questo per me

Answer 1

Se l'ultimo argomento di un metodo è un hash non vuota letterale, è possibile passare in questo modo

def foo(x, y, the_hash) 
    p the_hash['key2'] 
end 

foo(0, 0, :key1 => 'val1', 'key2' => 42)  # 42 

invece del modo normale:

foo(0, 0, { :key1 => 'val1', 'key2' => 42 }) # 42 

Solitamente, l'hash viene default per {} (def foo(x, y, the_hash = {})) in modo passante un hash vuoto adatta a questo schema.

Inoltre, è possibile specificare uno (splat) argomento "catch-all" che diventerà un array di tutti gli argomenti non già assegnati ad argomenti normali:

def foo(p1, *rest) 
    p rest 
end 

foo(0)   # "[]" 
foo(0, 23, 42) # "[23, 42]" 

Oppure, per esempio

def foo(p1, *rest, p2) 
    p rest 
end 

foo(0, 100)   # "[]" 
foo(0, 100, 23, 42) # "[100, 23]" 

Non è possibile avere argomenti splat prima degli argomenti con valore predefinito. Pertanto, la sintassi dell'hash dell'argomento e l'argomento splat vengono usati raramente in combinazione.

Infine, nella definizione del metodo è possibile avere come ultimo argomento un identificatore con prefisso & che punta al blocco alla chiamata di metodo (il suo Proc oggetto) o essere nil se non c'è nessuno. Normalmente non è necessario se vuoi semplicemente richiamare il blocco - per questo puoi usare yield.

def foo(&p) 
    p.call 
end 

foo { puts "hello" } # hello 

vs.

def foo 
    yield 
end 

foo { puts "hello" } # hello