ใหม่กับ Ruby และ ROR และรักมันทุกวันดังนั้นนี่คือคำถามของฉันเนื่องจากฉันไม่รู้ว่าจะใช้ Google อย่างไร (และฉันได้ลองแล้ว :))

เรามีวิธีการ

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

ดังนั้นสิ่งที่ฉันกำลังมองหาวิธีที่จะส่งข้อโต้แย้งทั้งหมดไปยังวิธีการโดยไม่ต้องระบุรายการแต่ละรายการ เนื่องจากนี่คือ Ruby ฉันคิดว่ามีวิธี :) ถ้าเป็น java ฉันจะแสดงรายการเหล่านั้น :)

ผลลัพธ์จะเป็น:

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

ใน Ruby 1.9.2 และใหม่กว่าคุณสามารถใช้parametersเมธอดบนเมธอดเพื่อรับรายการพารามิเตอร์สำหรับเมธอดนั้น สิ่งนี้จะส่งคืนรายการคู่ที่ระบุชื่อของพารามิเตอร์และระบุว่าจำเป็นหรือไม่

เช่น

ถ้าคุณทำ

def foo(x, y)
end

แล้ว

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

คุณสามารถใช้ตัวแปรพิเศษ__method__เพื่อรับชื่อของเมธอดปัจจุบัน ดังนั้นภายในเมธอดสามารถรับชื่อของพารามิเตอร์ได้ทาง

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

จากนั้นคุณสามารถแสดงชื่อและค่าของแต่ละพารามิเตอร์ด้วย

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

หมายเหตุ:เนื่องจากคำตอบนี้ถูกเขียนขึ้นในตอนแรก Ruby ในเวอร์ชันปัจจุบันevalจึงไม่สามารถเรียกด้วยสัญลักษณ์ได้อีกต่อไป เพื่อแก้ไขปัญหานี้to_sได้มีการเพิ่มExplicit เมื่อสร้างรายการชื่อพารามิเตอร์เช่นparameters.map { |arg| arg[1].to_s }

เนื่องจาก Ruby 2.1 คุณสามารถใช้binding.local_variable_getเพื่ออ่านค่าของตัวแปรโลคัลรวมทั้งพารามิเตอร์วิธีการ (อาร์กิวเมนต์) ขอบคุณที่คุณสามารถปรับปรุงคำตอบที่ยอมรับเพื่อหลีกเลี่ยงชั่วร้าย ประเมิน

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

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

วิธีหนึ่งในการจัดการสิ่งนี้คือ:

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

นี่เป็นคำถามที่น่าสนใจ อาจใช้local_variables ? แต่ต้องมีวิธีอื่นที่ไม่ใช่การใช้ eval ฉันกำลังมองหาใน 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

นี่อาจเป็นประโยชน์ ...

  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

คุณสามารถกำหนดค่าคงที่เช่น:

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

และใช้ในรหัสของคุณเช่น:

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

ก่อนที่ฉันจะไปไกลกว่านี้คุณกำลังมีข้อโต้แย้งเกี่ยวกับ foo มากเกินไป ดูเหมือนว่าอาร์กิวเมนต์ทั้งหมดจะเป็นแอตทริบิวต์ใน Model ใช่ไหม คุณควรจะส่งผ่านวัตถุนั้นจริงๆ สิ้นสุดคำพูด

คุณสามารถใช้อาร์กิวเมนต์ "splat" มันผลักทุกอย่างลงในอาร์เรย์ ดูเหมือนว่า:

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

หากคุณจะเปลี่ยนลายเซ็นของวิธีการคุณสามารถทำสิ่งนี้:

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

หรือ:

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

ในกรณีนี้จะสอดแทรกargsหรือopts.valuesจะเป็นอาร์เรย์ แต่คุณสามารถทำได้joinหากใช้ลูกน้ำ ไชโย

ดูเหมือนว่าสิ่งที่คำถามนี้พยายามที่จะบรรลุสามารถทำได้ด้วยอัญมณีฉันเพิ่งปล่อยตัวhttps://github.com/ericbeland/exception_details มันจะแสดงรายการตัวแปรท้องถิ่นและ vlaues (และตัวแปรอินสแตนซ์) จากข้อยกเว้นที่ได้รับการช่วยเหลือ น่าดู ...

หากคุณต้องการอาร์กิวเมนต์เป็น Hash และคุณไม่ต้องการสร้างมลพิษให้กับร่างกายของวิธีการด้วยการแยกพารามิเตอร์ที่ยุ่งยากให้ใช้สิ่งนี้:

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

เพียงเพิ่มชั้นเรียนนี้ในโครงการของคุณ:

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

หากฟังก์ชันอยู่ในบางคลาสคุณสามารถทำสิ่งนี้ได้:

class Car
  def drive(speed)
  end
end

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

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