在Ruby 1.8中，proc / lambda与Proc.new之间存在细微差别。
答案 0 :(得分：376)
使用lambda创建的过程与使用Proc.new创建的过程之间的另一个重要但微妙的区别是它们如何处理return语句：
lambda - 创建的proc中，return语句仅从proc本身返回Proc.new创建的proc中，return语句更令人惊讶：它不仅从proc，返回控件，还从包含proc的方法返回控件！ 这是lambda - 创建了proc return。它的行为方式可能是您所期望的：
def whowouldwin
mylambda = lambda {return "Freddy"}
mylambda.call
# mylambda gets called and returns "Freddy", and execution
# continues on the next line
return "Jason"
end
whowouldwin
#=> "Jason"
现在这里是一个Proc.new - 创建的proc return做同样的事情。你将要看到其中一个案例，其中Ruby打破了大肆吹嘘的最低惊喜原则：
def whowouldwin2
myproc = Proc.new {return "Freddy"}
myproc.call
# myproc gets called and returns "Freddy",
# but also returns control from whowhouldwin2!
# The line below *never* gets executed.
return "Jason"
end
whowouldwin2
#=> "Freddy"
由于这种令人惊讶的行为（以及较少的输入），我倾向于在制作过程时使用lambda而不是Proc.new。
答案 1 :(得分：95)
进一步澄清：
Joey说Proc.new的回归行为令人惊讶。但是，当您认为Proc.new的行为类似于块时，这并不奇怪，因为这正是块的行为方式。另一方面，lambas更像是方法。
这实际上解释了为什么Procs在arity（参数数量）方面是灵活的，而lambdas则不是。块不需要提供它们的所有参数，但是方法会提供（除非提供默认值）。虽然提供lambda参数默认值不是Ruby 1.8中的一个选项，但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中断是没有任何意义的，因为它本质上是一种方法，你永远不会脱离方法的顶层。
next，redo和raise的行为相同。虽然两者都不允许retry，但会引发异常。
最后，永远不应该使用proc方法，因为它不一致并且具有意外行为。在Ruby 1.8中它实际上返回一个lambda！在Ruby 1.9中，这已得到修复，并返回Proc。如果您想创建一个Proc，请坚持使用Proc.new。
有关更多信息，我强烈推荐O'Reilly的 The Ruby Programming Language ，这是我获取大部分信息的来源。
答案 2 :(得分：43)
我找到了this page，其中显示了Proc.new和lambda之间的区别。根据该页面，唯一的区别是lambda对它接受的参数数量是严格的，而Proc.new将缺少的参数转换为nil。以下是IRB会议的示例，说明了不同之处：
irb(main):001:0> l = lambda { |x, y| x + y }
=> #<Proc:0x00007fc605ec0748@(irb):1>
irb(main):002:0> p = Proc.new { |x, y| x + y }
=> #<Proc:0x00007fc605ea8698@(irb):2>
irb(main):003:0> l.call "hello", "world"
=> "helloworld"
irb(main):004:0> p.call "hello", "world"
=> "helloworld"
irb(main):005:0> l.call "hello"
ArgumentError: wrong number of arguments (1 for 2)
from (irb):1
from (irb):5:in `call'
from (irb):5
from :0
irb(main):006:0> p.call "hello"
TypeError: can't convert nil into String
from (irb):2:in `+'
from (irb):2
from (irb):6:in `call'
from (irb):6
from :0
除非您特别需要容错行为，否则该页面还建议使用lambda。我同意这种观点。使用lambda似乎更简洁，并且具有如此微不足道的差异，在平均情况下似乎是更好的选择。
对于Ruby 1.9，对不起，我还没有考虑过1.9，但我不认为他们会改变这一切（尽管你不听我的话，似乎你听说过一些变化，所以我可能错了）。
答案 3 :(得分：16)
Proc比较老，但返回的语义对我来说非常违反直觉（至少在我学习语言时），因为：
Lambda在功能上更安全，更容易推理 - 我总是使用它而不是proc。
答案 4 :(得分：11)
我不能多说微妙的差异。但是，我可以指出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 }
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，请查看this article（无耻的自我推销）。
答案 5 :(得分：11)
简短回答：重要的是return的作用：lambda返回自身，proc返回自身以及调用它的函数。
不太清楚的是你想要使用它们的原因。 lambda是我们期望在函数编程意义上应该做的事情。它基本上是一个匿名方法，当前范围自动绑定。在这两个中，lambda是你应该使用的那个。
另一方面，Proc对于实现语言本身非常有用。例如，您可以使用它们实现“if”语句或“for”循环。在proc中找到的任何返回都将返回调用它的方法，而不仅仅是“if”语句。这就是语言的工作方式，“if”语句是如何工作的，所以我的猜测是Ruby在封面上使用它，它们只是暴露它，因为它看起来很强大。如果你要创建像loop，if-else构造等新的语言结构，你真的需要这个。
答案 6 :(得分：10)
看到它的一个好方法是lambdas在它们自己的范围内执行（好像它是一个方法调用），而Procs可能被视为与调用方法内联执行，至少这是决定哪个方法的好方法一个在每种情况下使用。
答案 7 :(得分：8)
我没有注意到对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
答案 8 :(得分：7)
Closures in Ruby是对Ruby，lambda和proc如何在Ruby中工作的一个很好的概述。
答案 9 :(得分：5)
lambda按预期工作，就像在其他语言中一样。
有线Proc.new令人惊讶且令人困惑。
由return创建的proc中的Proc.new语句不仅会从自身返回控件，而且也会从包含它的方法中返回。
def some_method
myproc = Proc.new {return "End."}
myproc.call
# Any code below will not get executed!
# ...
end
你可以说Proc.new将代码插入到封闭方法中，就像阻塞一样。
但Proc.new创建了一个对象，而block 是对象的一部分。
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"
proc创建了一个lambda，而在Ruby 1.9+中表现得像Proc.new，这实在令人困惑。
答案 10 :(得分：3)
详细说明手风琴家的回应：
请注意Proc.new通过传递一个块来创建一个proc。我相信lambda {...}被解析为一种文字，而不是传递一个块的方法调用。从附加到方法调用的块内部return将从方法返回，而不是块，Proc.new情况就是这个例子。
（这是1.8。我不知道这是如何转换为1.9。）
答案 11 :(得分：3)
我在这方面有点迟，但有一个很好但鲜为人知的事情，Proc.new在评论中没有提到。截至documentation：
只有在带有附加块的方法中，才能在没有块的情况下调用
Proc::new，在这种情况下，块将转换为Proc对象。
那就是说，Proc.new允许链接让步方法：
def m1
yield 'Finally!' if block_given?
end
def m2
m1 &Proc.new
end
m2 { |e| puts e }
#⇒ Finally!
答案 12 :(得分：1)
与return的行为差异是恕我直言2之间最重要的区别。我也更喜欢lambda，因为它的输入次数少于Proc.new： - ）
答案 13 :(得分：1)
值得强调的是，proc中的return从词法包围方法中返回，即创建proc的方法，不是该过程。这是procs的闭合属性的结果。所以下面的代码什么都不输出：
def foo
proc = Proc.new{return}
foobar(proc)
puts 'foo'
end
def foobar(proc)
proc.call
puts 'foobar'
end
foo
尽管proc在foobar中执行，但它是在foo中创建的，因此return退出foo，而不仅仅是foobar。正如查尔斯·考德威尔（Charles Caldwell）上文所述，它具有GOTO的感觉。在我看来，return在以其词法上下文执行的块中很好，但是在以不同上下文执行的proc中使用时则不太直观。