Neu bei Ruby und ROR und ich liebe es jeden Tag. Hier ist meine Frage, da ich keine Ahnung habe, wie ich es googeln soll (und ich habe es versucht :)).

Wir haben Methode

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

Also, was ich suche, um alle Argumente an die Methode zu übergeben, ohne jedes einzelne aufzulisten. Da dies Ruby ist, nehme ich an, dass es einen Weg gibt :) Wenn es Java wäre, würde ich sie einfach auflisten :)

Ausgabe wäre:

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

In Ruby 1.9.2 und höher können Sie die parametersMethode für eine Methode verwenden, um die Liste der Parameter für diese Methode abzurufen. Dies gibt eine Liste von Paaren zurück, die den Namen des Parameters angeben und angeben, ob er erforderlich ist.

z.B

Wenn Sie tun

def foo(x, y)
end

dann

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

Sie können die spezielle Variable verwenden __method__, um den Namen der aktuellen Methode abzurufen. Innerhalb einer Methode können also die Namen ihrer Parameter über abgerufen werden

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

Sie können dann den Namen und den Wert jedes Parameters mit anzeigen

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

Hinweis: Da diese Antwort ursprünglich geschrieben wurde, evalkann Ruby in aktuellen Versionen nicht mehr mit einem Symbol aufgerufen werden. Um dies zu beheben, to_swurde beim Erstellen der Liste der Parameternamen eine explizite hinzugefügt, d. H.parameters.map { |arg| arg[1].to_s }

Seit Ruby 2.1 können Sie binding.local_variable_get verwenden , um den Wert jeder lokalen Variablen einschließlich der Methodenparameter (Argumente) zu lesen. Dank dessen können Sie die akzeptierte Antwort verbessern , um dies zu vermeidenböse eval.

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

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

Eine Möglichkeit, damit umzugehen, ist:

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

Dies ist eine interessante Frage. Vielleicht mit local_variables ? Aber es muss einen anderen Weg geben als die Verwendung von eval. Ich suche 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

Dies kann hilfreich sein ...

  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

Sie können eine Konstante definieren wie:

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

Und verwenden Sie es in Ihrem Code wie:

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

Bevor ich weiter gehe, geben Sie zu viele Argumente an foo weiter. Es sieht so aus, als wären alle diese Argumente Attribute in einem Modell, richtig? Sie sollten das Objekt selbst wirklich übergeben. Ende der Rede.

Sie könnten ein "splat" -Argument verwenden. Es verschiebt alles in ein Array. Es würde so aussehen:

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

Wenn Sie die Methodensignatur ändern würden, können Sie Folgendes tun:

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

Oder:

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

In diesem Fall interpoliert argsoder opts.valueswird ein Array, aber Sie können, joinwenn auf Komma. Prost

Es scheint, als könnte das, was mit dieser Frage erreicht werden soll, mit einem Juwel geschehen, das ich gerade veröffentlicht habe: https://github.com/ericbeland/exception_details . Es werden lokale Variablen und Werte (und Instanzvariablen) aus geretteten Ausnahmen aufgelistet. Könnte einen Blick wert sein ...

Wenn Sie Argumente als Hash benötigen und den Körper der Methode nicht mit einer schwierigen Extraktion von Parametern verschmutzen möchten, verwenden Sie Folgendes:

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

Fügen Sie diese Klasse einfach Ihrem Projekt hinzu:

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

Wenn sich die Funktion in einer Klasse befindet, können Sie Folgendes tun:

class Car
  def drive(speed)
  end
end

car = Car.new
method = car.method(:drive)

p method.parameters #=> [[:req, :speed]]