Baru mengenal Ruby dan ROR dan menyukainya setiap hari, jadi inilah pertanyaan saya karena saya tidak tahu bagaimana cara meng-google-nya (dan saya sudah mencobanya :))

kami punya metode

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

Jadi apa yang saya cari cara untuk mendapatkan semua argumen diteruskan ke metode, tanpa mendaftar masing-masing. Karena ini Ruby, saya berasumsi ada cara :) jika itu adalah java saya hanya akan mencantumkannya :)

Outputnya adalah:

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

Di Ruby 1.9.2 dan yang lebih baru, Anda dapat menggunakan parametersmetode pada suatu metode untuk mendapatkan daftar parameter untuk metode itu. Ini akan mengembalikan daftar pasangan yang menunjukkan nama parameter dan apakah itu diperlukan.

misalnya

Jika kamu melakukan

def foo(x, y)
end

kemudian

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

Anda dapat menggunakan variabel khusus __method__untuk mendapatkan nama metode saat ini. Jadi dalam suatu metode, nama parameternya dapat diperoleh melalui

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

Anda kemudian dapat menampilkan nama dan nilai setiap parameter dengan

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

Catatan: karena jawaban ini aslinya ditulis, di versi Ruby saat evalini tidak bisa lagi disebut dengan simbol. Untuk mengatasi ini, sebuah eksplisit to_stelah ditambahkan saat membangun daftar nama parameter yaituparameters.map { |arg| arg[1].to_s }

Sejak Ruby 2.1 Anda dapat menggunakan binding.local_variable_get untuk membaca nilai variabel lokal apa pun, termasuk parameter metode (argumen). Berkat itu Anda dapat meningkatkan jawaban yang diterima untuk dihindarijahat eval.

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

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

Salah satu cara untuk mengatasinya adalah:

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

Ini pertanyaan yang menarik. Mungkin menggunakan local_variables ? Tetapi harus ada cara selain menggunakan eval. Saya mencari di dokumen Kernel

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

Ini mungkin membantu ...

  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

Anda dapat menentukan konstanta seperti:

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

Dan gunakan dalam kode Anda seperti:

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

Sebelum saya melangkah lebih jauh, Anda menyampaikan terlalu banyak argumen ke foo. Sepertinya semua argumen tersebut adalah atribut pada Model, benar? Anda harus benar-benar melewati objek itu sendiri. Akhir pidato.

Anda bisa menggunakan argumen "percikan". Ini mendorong semuanya menjadi sebuah array. Ini akan terlihat seperti:

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

Jika Anda ingin mengubah tanda tangan metode, Anda dapat melakukan sesuatu seperti ini:

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

Atau:

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

Dalam hal ini, diinterpolasi argsatau opts.valuesakan menjadi sebuah array, tetapi Anda bisa joinjika menggunakan koma. Bersulang

Sepertinya apa yang ingin dicapai oleh pertanyaan ini dapat dilakukan dengan permata yang baru saja saya rilis, https://github.com/ericbeland/exception_details . Ini akan mencantumkan variabel dan variabel lokal (dan variabel instan) dari pengecualian yang diselamatkan. Mungkin layak untuk dilihat ...

Jika Anda memerlukan argumen sebagai Hash, dan Anda tidak ingin mencemari tubuh metode dengan ekstraksi parameter yang rumit, gunakan ini:

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

Cukup tambahkan kelas ini ke proyek Anda:

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

Jika fungsinya ada di dalam beberapa kelas maka Anda dapat melakukan sesuatu seperti ini:

class Car
  def drive(speed)
  end
end

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

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