¿Cuáles son las diferentes posibilidades de pasar parámetros en métodos ruby? param/hashlist/array/aproc?

Question

estoy tratando de comprender de Ruby en más profundidad y estaba leyendo:

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

Sin embargo, no entiendo lo que los medios siguientes en esa definición:

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

sé "parámetro" se cualquier número de parámetros especificados, y luego me pierdo lo que significa el resto?

Por ejemplo, tengo:

def doIt(param1, param2, param3) 
end 

y en este caso [parám] * es igual a param1, param2, param3 ... Entonces, ¿dónde lista ordenada entrar? y * array y & aProc?

Podría alguien aclarar esto para mí

Answer 1

Si el último argumento de un método es un hash no vacío literal, puede pasar como este

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

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

en lugar de la forma habitual:

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

Por lo general, el hash es por defecto a {} (def foo(x, y, the_hash = {})) para pasar un hash vacío se ajusta a este esquema.

Además, puede especificar un argumento "catch-all" (splat) que se convertirá en una matriz de todos los argumentos todavía no están asignados a los argumentos normales:

def foo(p1, *rest) 
    p rest 
end 

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

O, por ejemplo,

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

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

No puede haber splat argumentos antes argumentos con valor predeterminado. Por lo tanto, la sintaxis del argumento hash y el argumento splat rara vez se usan en combinación.

Por último, en la definición del método que puede tener como último argumento un identificador con el prefijo & que apunte al bloque en la invocación de método (Proc su objeto) o ser nil si no hay ninguno. Esto normalmente no es necesario si solo quiere invocar el bloque; puede usar yield para eso.

def foo(&p) 
    p.call 
end 

foo { puts "hello" } # hello 

vs.

def foo 
    yield 
end 

foo { puts "hello" } # hello