Envío de elementos de una matriz como argumentos para una llamada al método

Question

Tengo un método que acepta el operador splat:

def hello(foo, *bar) 
    #... do some stuff 
end 

tengo una matriz con una longitud variable que me gustaría para enviar en este método hola :

arr1 = ['baz', 'stuff'] 
arr2 = ['ding', 'dong', 'dang'] 

me gustaría llamar al método con arr1 y arr2 como argumentos a ese método, pero sigo quedarse atascado en ese bar * se interpreta como una matriz en lugar de argumentos individuales. Para hacer las cosas más divertidas, no puedo cambiar el método de saludo en absoluto.

Estoy buscando algo similar a this SO question pero en ruby.

Answer 1

intente llamar como este

hello(arr1, *arr2) 

aquí hay una carrera a través de IRB

irb(main):002:0> def hello(foo, *bar) 
irb(main):003:1> puts foo.inspect 
irb(main):004:1> puts bar.inspect 
irb(main):005:1> end 
=> nil 
irb(main):006:0> arr1 = ['baz', 'stuff'] 
=> ["baz", "stuff"] 
irb(main):007:0> arr2 = ['ding', 'dong', 'dang'] 
=> ["ding", "dong", "dang"] 
irb(main):008:0> hello(arr1, arr2) 
["baz", "stuff"] 
[["ding", "dong", "dang"]] 
=> nil 
irb(main):009:0> hello(arr1, *arr2) 
["baz", "stuff"] 
["ding", "dong", "dang"] 
=> nil 

añadiendo el * a la segunda matriz, que los trata como un gama en lugar de un matriz de una matriz, que es lo que está buscando creo

Answer 2

Aquí tienes:

hello('Something', *(arr1 + arr2)) 

Esto combinar los arr1 y arr2 arrays y colectivamente pasar desde el segundo argumento en el método.

Ejemplo:

>> def hello(str, *args) 
>> puts str 
>> args.each do |arg| 
?> puts 'Splat: ' + arg 
>> end 
>> end 
=> nil 
>> hello('Hello', *(['programming'] + ['is', 'fun'])) 
Hello 
Splat: programming 
Splat: is 
Splat: fun 
=> ["programming", "is", "fun"] 

El último parámetro de un método puede ser precedida por un asterisco (*), esto indica que más parámetros pueden ser pasados ​​a la función. Esos parámetros se recopilan y se crea una matriz.

Dado que los últimos parámetros se recopilan en una matriz, debe utilizar el operador * para indicar que efectivamente está enviando una matriz al método y que no debe envolver los argumentos en otra matriz.