什么时候使用lambda，什么时候使用Proc.new？

在Ruby 1.8中，proc / lambda与Proc.new之间存在细微差异。

• 这些差别是什么？
• 你能给出如何决定选择哪个的指导方针吗？
• 在Ruby 1.9中，proc和lambda是不一样的。 这是怎么回事？

---

#1楼

我没有注意到对queston中的第三个方法的任何评论，“proc”已被弃用，但在1.8和1.9中处理方式不一样。

这是一个至关冗长的例子，能够很容易地看到三个相似调用之间的差别：

def meth1
  puts "method start"

  pr = lambda { return }
  pr.call

  puts "method end"  
end

def meth2
  puts "method start"

  pr = Proc.new { return }
  pr.call

  puts "method end"  
end

def meth3
  puts "method start"

  pr = proc { return }
  pr.call

  puts "method end"  
end

puts "Using lambda"
meth1
puts "--------"
puts "using Proc.new"
meth2
puts "--------"
puts "using proc"
meth3

---

#2楼

进一步澄清：

乔伊说， Proc.new的回归行为使人惊讶。 可是，当您认为Proc.new的行为相似于块时，这并不奇怪，由于这正是块的行为方式。 另外一方面，lambas更像是方法。

这实际上解释了为何Procs在arity（参数数量）方面是灵活的，而lambdas则不是。 块不须要提供它们的全部参数，可是方法会提供（除非提供默认值）。 虽然在Ruby 1.8中提供lambda参数default不是一个选项，但Ruby 1.9中如今支持使用替代lambda语法（如webmat所述）：

concat = ->(a, b=2){ "#{a}#{b}" }
concat.call(4,5) # => "45"
concat.call(1)   # => "12"

而且Michiel de Mare（OP）对于Procs和lambda在Ruby 1.9中与arity表现相同是不正确的。 我已经验证他们仍然保持上述1.8的行为。

在Procs或lambdas中， break语句实际上没有多大意义。 在Procs中，休息将从Proc.new返回，已经完成。 从lambda中断是没有任何意义的，由于它本质上是一种方法，你永远不会脱离方法的顶层。

在proc和lambdas中， next ， redo和raise行为相同。 虽然二者都不容许retry ，但会引起异常。

最后，不该该使用proc方法，由于它不一致而且具备意外行为。 在Ruby 1.8中它实际上返回一个lambda！ 在Ruby 1.9中，这已获得修复，并返回Proc。 若是你想建立一个Proc，请坚持使用Proc.new 。

有关更多信息，我强烈推荐O'Reilly的The Ruby Programming Language ，这是我获取大部分信息的源代码。

---

#3楼

与其余语言同样，lambda按预期工做。

有线的Proc.new使人惊讶和困惑。

Proc.new建立的proc中的return语句Proc.new会从自身返回控制， 还会从包含它的方法返回控制。

def some_method
  myproc = Proc.new {return "End."}
  myproc.call

  # Any code below will not get executed!
  # ...
end

您能够争辩说Proc.new代码插入到封闭方法中，就像阻塞同样。 可是Proc.new建立了一个对象，而块是对象的一部分 。

而lambda和Proc.new之间还有另外一个区别，那就是它们对（错误）参数的处理。 lambda抱怨它，而Proc.new忽略额外的论点或认为没有参数为零。

irb(main):021:0> l = -> (x) { x.to_s }
=> #<Proc:0x8b63750@(irb):21 (lambda)>
irb(main):022:0> p = Proc.new { |x| x.to_s}
=> #<Proc:0x8b59494@(irb):22>
irb(main):025:0> l.call
ArgumentError: wrong number of arguments (0 for 1)
        from (irb):21:in `block in irb_binding'
        from (irb):25:in `call'
        from (irb):25
        from /usr/bin/irb:11:in `<main>'
irb(main):026:0> p.call
=> ""
irb(main):049:0> l.call 1, 2
ArgumentError: wrong number of arguments (2 for 1)
        from (irb):47:in `block in irb_binding'
        from (irb):49:in `call'
        from (irb):49
        from /usr/bin/irb:11:in `<main>'
irb(main):050:0> p.call 1, 2
=> "1"

顺便说一下，R​​uby 1.8中的proc建立了一个lambda，而在Ruby 1.9中， proc就像Proc.new同样，这实在使人困惑。

---

#4楼

我对此有点迟，但有一个很好但不为人知的关于Proc.new事情在评论中没有提到。 做为文件 ：

只有在带有附加块的方法中，才能够在没有块的状况下调用Proc::new ，在这种状况下，该块将转换为Proc对象。

也就是说， Proc.new容许连接屈服方法：

def m1
  yield 'Finally!' if block_given?
end

def m2
  m1 &Proc.new
end

m2 { |e| puts e } 
#⇒ Finally!

---

#5楼

我不能多说这些微妙的差别。 可是，我能够指出Ruby 1.9如今容许lambdas和blocks的可选参数。

这是1.9下的stabby lambdas的新语法：

stabby = ->(msg='inside the stabby lambda') { puts msg }

Ruby 1.8没有那种语法。 声明块/ lambdas的传统方式也不支持可选的args：

# under 1.8
l = lambda { |msg = 'inside the stabby lambda'|  puts msg }
SyntaxError: compile error
(irb):1: syntax error, unexpected '=', expecting tCOLON2 or '[' or '.'
l = lambda { |msg = 'inside the stabby lambda'|  puts msg }

可是，Ruby 1.9支持可选参数，即便使用旧语法：

l = lambda { |msg = 'inside the regular lambda'|  puts msg }
#=> #<Proc:0x0e5dbc@(irb):1 (lambda)>
l.call
#=> inside the regular lambda
l.call('jeez')
#=> jeez

若是你想为Leopard或Linux构建Ruby1.9，请查看这篇文章 （无耻的自我推销）。