Ruby ve ROR'da yeni ve her gün onu seviyorum, işte benim sorum şu, çünkü onu nasıl google'layacağımı bilmiyorum (ve denedim :))

yöntemimiz var

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

Yani, her birini listelemeden yönteme aktarılan tüm argümanları almanın bir yolunu arıyorum. Bu Ruby olduğundan, bir yolu olduğunu varsayıyorum :) eğer java olsaydı sadece listelerdim :)

Çıktı şu şekilde olacaktır:

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

Ruby 1.9.2 ve sonrasında, parametersyöntemi bir yöntemde, o yöntemin parametrelerinin listesini almak için kullanabilirsiniz. Bu, parametrenin adını ve gerekli olup olmadığını gösteren bir çift listesi döndürür.

Örneğin

Yaparsan

def foo(x, y)
end

sonra

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

__method__Mevcut yöntemin adını almak için özel değişkeni kullanabilirsiniz . Dolayısıyla bir yöntem içinde parametrelerinin adları şu yolla elde edilebilir:

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

Daha sonra her parametrenin adını ve değerini şu şekilde görüntüleyebilirsiniz:

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

Not: Bu cevap orijinal olarak yazıldığından, Ruby'nin mevcut sürümlerinde evalartık bir sembolle çağrılamaz. Bunu ele almak to_siçin, parametre adları listesi oluşturulurken açık bir şekilde eklenmiştir, örn.parameters.map { |arg| arg[1].to_s }

Ruby 2.1'den beri , yöntem parametreleri (argümanlar) dahil olmak üzere herhangi bir yerel değişkenin değerini okumak için binding.local_variable_get'i kullanabilirsiniz . Bunun sayesinde iyileştirebilirsiniz kaçınmak kabul edilen cevabıkötü eval.

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

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

Bunu halletmenin bir yolu şudur:

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

Bu ilginç bir soru. Belki local_variables kullanarak ? Ama eval kullanmaktan başka bir yol olmalı. Kernel belgesine bakıyorum

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

Bu yardımcı olabilir ...

  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

Aşağıdaki gibi bir sabit tanımlayabilirsiniz:

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

Ve bunu kodunuzda şu şekilde kullanın:

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

Daha ileri gitmeden önce, foo'ya çok fazla argüman iletiyorsun. Görünüşe göre tüm bu argümanlar bir Modeldeki özellikler, değil mi? Gerçekten nesnenin kendisini iletmelisiniz. Konuşmanın Sonu.

Bir "uyarma" argümanı kullanabilirsiniz. Her şeyi bir diziye sokar. Şöyle görünür:

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

Yöntem imzasını değiştirirseniz, şöyle bir şey yapabilirsiniz:

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

Veya:

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

Bu durumda, enterpolasyonlu argsveya opts.valuesbir dizi olacaktır, ancak joinvirgül üzerindeyse yapabilirsiniz . Şerefe

Görünüşe göre bu sorunun başarmaya çalıştığı şey, yeni çıkardığım bir mücevher ile yapılabilir, https://github.com/ericbeland/exception_details . Kurtarılan istisnalardan yerel değişkenleri ve değerleri (ve örnek değişkenleri) listeleyecektir. Bir bakmaya değer olabilir ...

Bir Hash olarak argümanlara ihtiyacınız varsa ve metodun gövdesini karmaşık parametrelerin çıkarılmasıyla kirletmek istemiyorsanız, şunu kullanın:

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

Sadece bu sınıfı projenize ekleyin:

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

İşlev bir sınıfın içindeyse, şöyle bir şey yapabilirsiniz:

class Car
  def drive(speed)
  end
end

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

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