Ruby 如果改为传递定位参数，如何设置关键字参数

出于向后兼容性的原因，是否有办法定义

my

方法，以便以下两个调用是相同的

my(1, A)
my(1, before: A)

其中，之前的

是一个关键字参数

我现在有

def my(n, klass)
 puts "#{n} and #{klass}"
end

现在我需要能够调用
my（1，before:A）
并获得相同的结果（即“1和A”）

my
方法也可以使用第二个关键字参数调用，即
my（1，在：a之前，在：B之后）

下面是MCVE和使用示例

def my（之后=nil，**args）
之后| 124;=args[：之后]
before=args[：before]
将“after=“#{after}”置于“#{before}”之前
结束
我的“A”
#⇒after=“A”| before=“”
我的名字在“A”之后
#⇒ after=“A”| before=“”
我的名字在“B”之前
#⇒在=“B”之前
您可以将方法定义为：

def my(n, klass = nil, before: nil)
  p n: n, klass: klass, before: before
end

这允许您传递位置参数或关键字参数：

my(1, A)
#=> {:n=>1, :klass=>A, :before=>nil}

my(1, before: A)
#=> {:n=>1, :klass=>nil, :before=>A}

在该方法中，您可以将一个变量分配给另一个变量，即：

def my(n, klass = nil, before: nil)
  klass ||= before
  p n: n, klass: klass
end

my(1, A)         #=> {:n=>1, :klass=>A}
my(1, before: A) #=> {:n=>1, :klass=>A}

或：

后者可能更干净，并在

关键字之后附加一个

：

def my(n, klass = nil, before: nil, after: nil)
  before ||= klass
  p n: n, before: before, after: after
end

my(1, A, after: B)         #=> {:n=>1, :before=>A, :after=>B}
my(1, before: A, after: B) #=> {:n=>1, :before=>A, :after=>B}


请注意，从技术上讲，您也可以在
之前通过
klass
和
，或者根本不通过：

def my(n, klass = nil, before: nil)
  p n: n, klass: klass, before: before
end

my(1, A, before: A) #=> {:n=>1, :klass=>A, :before=>A}
my(1)               #=> {:n=>1, :klass=>nil, :before=>nil}

在这种情况下，您可能希望提出一个
ArgumentError
。
不幸的是，您的要求不是很清楚，但我认为这应该满足您的要求：

def my（n，klass=nil，前：klass，后：nil）
local_variables.map{| var | next var.to_sym，binding.local_variable_get（var）}.to_h
结束
我的1
#=>{n:1，klass:nil，before:nil，after:nil}
我的1，‘A’
#=>{n:1，klass'A'，在'A'之前，在'nil'之后}
我的1，在“A”之前
#=>{n:1，klass:nil，在'A'之前，在'nil'之后}
我的1，在'A'之前，在'B'之后
#=>{n:1，klass:nil，在'A'之前，在'B'之后}
我的1“A”，在“B”之后
#=>{n:1，klass'A'，在'A'之前，在'B'之后}
我的1，‘A’，在‘B’之前，在‘C’之后
#=>{n:1，klass'A'，在'B'之前，在'C'之后}

如果您想知道在
通过之前是
klass
还是
，您必须使用旧的“将标志指定为副作用技巧”：

def my（n，klass=（klass\u not\u passed=true；nil），before:（before\u not\u passed=true；klass），after:nil）
引发ArgumentError，“您只能通过'klass'或'before'中的一个，但您通过了'klass=={klass.inspect}'和'before={before.inspect}`”，除非klass未通过| before未通过
local_variables.map{| var | next var.to_sym，binding.local_variable_get（var）}.to_h
结束
我的1
#=>{n:1，klass:nil，before:nil，after:nil，klass\u not\u passed:true，before\u not\u passed:true}
我的1，‘A’
#=>{n:1，klass'A'，before'A'，after:nil，klass_not_passed:nil，before_not_passed:true}
我的1，在“A”之前
#=>{n:1，klass:nil，before'A'，before:nil，klass\u not\u passed:true，before\u not\u passed:nil}
我的1，在'A'之前，在'B'之后
#=>{n:1，klass:nil，在'A'之前，在'B'之后，klass\u not\u passed:true，在'u not\u passed:nil'之前}
我的1“A”，在“B”之后
#=>{n:1，klass'A'，在'A'之前，在'B'之后，klass'u not_passed:nil，在'u not_passed:true'之前}
我的1，‘A’，在‘B’之前，在‘C’之后
#ArgumentError:您只能通过'klass'或'before'中的一个，但您通过了'klass==“A”`和'before==“B”`
#来自测试。rb:36:in'my'
def my（n，maybe_afrer=nil，after:nil）
并检查。当我运行
my（1，before:A）
时，我得到
rake中止！未知关键字：before
你更新了方法定义吗？你的意思是像Aleksei建议的那样吗？当然，我得到了（对我来说并不意外）上面的错误。你能用旧定义的最小工作代码和预期的新行为发布更新吗？谢谢。不幸的是，它没有按预期工作。你缺少第一个参数。如果我在| |＝args[：after]before=args[：before]放置“#{n}和#{after}之后添加它，
def my（n，after=nil，**args）#{before}“end
我得到了``1和A但是1，但是A 1和B但是A``第二种情况是错误的，before被保存为after。这是MCVE，它按预期工作。现在由您来调整它以适应您的需要。幸运的是，即使需求非常不明确，这个问题已经解决了（请参阅接受的答案）。谢谢。
def my(n, klass = nil, before: nil, after: nil)
  before ||= klass
  p n: n, before: before, after: after
end

my(1, A, after: B)         #=> {:n=>1, :before=>A, :after=>B}
my(1, before: A, after: B) #=> {:n=>1, :before=>A, :after=>B}

def my(n, klass = nil, before: nil)
  p n: n, klass: klass, before: before
end

my(1, A, before: A) #=> {:n=>1, :klass=>A, :before=>A}
my(1)               #=> {:n=>1, :klass=>nil, :before=>nil}