Ruby:lambda函数参数可以有默认值吗？

我想做类似的事情：

def creator()
        return lambda { |arg1, arg2 = nil|
                puts arg1
                if(arg2 != nil)
                        puts arg2
                end
        }
end

test = creator()

test('lol')
test('lol', 'rofl')

我发现了一些语法错误：

test.rb:2: syntax error
        return lambda { |arg1, arg2 = nil|
                                 ^
test.rb:3: syntax error
test.rb:7: syntax error
test.rb:14: syntax error

---

这在ruby中可能吗？我想为Ruby 1.9+中的lambda函数设置参数的默认值，您可以使用旧式lambda或新的“arrow”lambda语法来设置默认参数：

ruby-1.9.1-p378 > f = lambda {|x, y=1| puts(x+y) }
 => #<Proc:0x000001009da388@(irb):4 (lambda)> 
ruby-1.9.1-p378 > f.call(1)
2
 => nil 
ruby-1.9.1-p378 > f.call(1,5)
6
 => nil 

ruby-1.9.1-p378 > f = ->(a, b=5) { puts(a+b) }
 => #<Proc:0x00000100a0e1b0@(irb):1 (lambda)> 
ruby-1.9.1-p378 > f.call(1)
6
 => nil 
ruby-1.9.1-p378 > f.call(1,2)
3
 => nil 

ruby-1.9.1-p378>f=lambda{x，y=1 | put（x+y）}
=> # 
ruby-1.9.1-p378>f.call（1）
2.
=>零
ruby-1.9.1-p378>f.call（1,5）
6.
=>零
ruby-1.9.1-p378>f=->（a，b=5）{put（a+b）}
=> # 
ruby-1.9.1-p378>f.call（1）
6.
=>零
ruby-1.9.1-p378>f.call（1,2）
3.
=>零

在Ruby 1.8.x中，您可以按照以下方式对其进行排序：

def creator
  lambda do |*args|
    raise ArgumentError if args.empty? || args.size > 2
    arg1, arg2 = args
    puts arg1
    puts arg2 unless arg2.nil?
  end
end

>> test = creator
=> #<Proc:0x000000010125e138@(irb):2>
>> test.call("foo")
foo
=> nil
>> test.call("foo", "bar")
foo
bar
=> nil
>> test.call("foo", "bar", "baz")
ArgumentError: ArgumentError

def创建者
lambda do |*args|
如果args.empty？| |则引发ArgumentErrorargs.size>2
arg1，arg2=args
放arg1
将arg2放入arg2，除非arg2.nil？
结束
结束
>>测试=创建者
=> #
>>测试调用（“foo”）
福
=>零
>>测试调用（“foo”、“bar”）
福
酒吧
=>零
>>测试调用（“foo”、“bar”、“baz”）
ArgumentError:ArgumentError

编辑：上面的示例将第二个参数默认为

nil

，但是如果您希望有另一个默认值，可以基于

args.size

（例如，如果args.size<2，则

arg2=mydefault）。类似地，如果有两个以上的参数，除非您自己指定，否则未指定的参数将默认为
nil

对于Ruby 1.9+，请参阅其他答案。
小心，传递nil不会触发默认值：在Ruby 1.9.3中，在插入lamba和括号之间放置空格时，我遇到语法错误
f->（x=123）{…}
。它可以在没有空格的情况下正常工作。
f->（x=123）{…}
.for
l=->（k，v，r=nil）{}
在
{a:“a”{a:“a”}每个{k，v | l.call（k，v）}
都会在
lambda{arg1，arg2*.