C'è un modo per accedere agli argomenti del metodo in Ruby?

Question

Nuovo per Ruby e ROR e amarla ogni giorno, ecco la mia domanda visto che non ho idea di come google (e ho provato :))

abbiamo metodo

def foo(first_name, last_name, age, sex, is_plumber) 
    # some code 
    # error happens here 
    logger.error "Method has failed, here are all method arguments #{SOMETHING}"  
end 

Così quello che sto cercando per modo di ottenere tutti gli argomenti passati al metodo, senza elencare ciascuno. Poiché si tratta di Rubino suppongo ci sia un modo :) se fosse java vorrei solo elencare loro :)

uscita sarebbe:

Method has failed, here are all method arguments {"Mario", "Super", 40, true, true} 

Answer 1

In Ruby 1.9.2 e versioni successive è possibile utilizzare il metodo parameters su un metodo per ottenere l'elenco dei parametri per tale metodo. Ciò restituirà un elenco di coppie che indicano il nome del parametro e se è richiesto.

ad es.

Se fai

def foo(x, y) 
end 

poi

method(:foo).parameters # => [[:req, :x], [:req, :y]] 

È possibile utilizzare la variabile speciale __method__ per ottenere il nome del metodo corrente.Quindi, all'interno di un metodo i nomi dei suoi parametri possono essere ottenuti tramite

args = method(__method__).parameters.map { |arg| arg[1].to_s } 

È quindi possibile visualizzare il nome e il valore di ogni parametro con

logger.error "Method failed with " + args.map { |arg| "#{arg} = #{eval arg}" }.join(', ') 

---

Nota: dato che questa risposta è stata originariamente scritto, nelle attuali versioni di Ruby eval non può più essere chiamato con un simbolo. Per far fronte a questo, un esplicito to_s è stato aggiunto quando si costruisce la lista dei nomi dei parametri cioè parameters.map { |arg| arg[1].to_s }

Answer 2

Un modo per gestire questa situazione è:

def foo(*args) 
    first_name, last_name, age, sex, is_plumber = *args 
    # some code 
    # error happens here 
    logger.error "Method has failed, here are all method arguments #{args.inspect}"  
end 

Answer 3

Questa è una domanda interessante. Forse usando local_variables? Ma deve esserci un modo diverso dall'usare la valutazione. Sto cercando in Kernel doc

class Test 
    def method(first, last) 
    local_variables.each do |var| 
     puts eval var.to_s 
    end 
    end 
end 

Test.new().method("aaa", 1) # outputs "aaa", 1 

Answer 4

Prima di andare oltre, si sta passando troppi argomenti in foo. Sembra che tutti questi argomenti siano attributi su un modello, corretto? Dovresti davvero passare l'oggetto stesso. Fine del discorso

È possibile utilizzare un argomento "splat". Mette tutto in un array. Si sarebbe simile:

def foo(*bar) 
    ... 
    log.error "Error with arguments #{bar.joins(', ')}" 
end 

Answer 5

Se si desidera cambiare la firma del metodo, si può fare qualcosa di simile:

def foo(*args) 
    # some code 
    # error happens here 
    logger.error "Method has failed, here are all method arguments #{args}"  
end 

Oppure:

def foo(opts={}) 
    # some code 
    # error happens here 
    logger.error "Method has failed, here are all method arguments #{opts.values}"  
end 

In questo caso, interpolato args o opts.values sarà una matrice, ma è possibile join se sulla virgola. Cheers

Answer 6

Sembra che ciò che a questa domanda sta cercando di realizzare potrebbe essere fatto con una gemma Ho appena rilasciato, https://github.com/ericbeland/exception_details. Elencherà le variabili locali e le vlaue (e le variabili di istanza) dalle eccezioni salvate. Potrebbe valere la pena dare un'occhiata ...

Answer 7

È possibile definire una costante come:

ARGS_TO_HASH = "method(__method__).parameters.map { |arg| arg[1].to_s }.map { |arg| { arg.to_sym => eval(arg) } }.reduce Hash.new, :merge" 

e utilizzarlo nel codice come:

args = eval(ARGS_TO_HASH) 
another_method_that_takes_the_same_arguments(**args) 

Answer 8

Dal Rubino 2.1 è possibile utilizzare per binding.local_variable_get leggere il valore di qualsiasi variabile locale, inclusi i parametri del metodo (argomenti). Grazie a ciò è possibile migliorare il accepted answer per evitare-malvagio eval.

def foo(x, y) 
    method(__method__).parameters.map do |_, name| 
    binding.local_variable_get(name) 
    end 
end 

foo(1, 2) # => 1, 2 

Answer 9

Questo può essere utile ...

def foo(x, y) 
    args(binding) 
    end 

    def args(callers_binding) 
    callers_name = caller[0][/`.*'/][1..-2] 
    parameters = method(callers_name).parameters 
    parameters.map { |_, arg_name| 
     callers_binding.local_variable_get(arg_name) 
    }  
    end 

Answer 10

Se avete bisogno di argomenti come Hash, e non si vuole inquinare il corpo di metodo con estrazione complicata di parametri, utilizzare questo:

def mymethod(firstarg, kw_arg1:, kw_arg2: :default) 
    args = MethodArguments.(binding) # All arguments are in `args` hash now 
    ... 
end 

Basta aggiungere questa classe per il vostro progetto:

class MethodArguments 
    def self.call(ext_binding) 
    raise ArgumentError, "Binding expected, #{ext_binding.class.name} given" unless ext_binding.is_a?(Binding) 
    method_name = ext_binding.eval("__method__") 
    ext_binding.receiver.method(method_name).parameters.map do |_, name| 
     [name, ext_binding.local_variable_get(name)] 
    end.to_h 
    end 
end