在Ruby 1.8中，一方面proc / lambda与" Proc.new"之间存在细微的差别。

这些区别是什么？我们可以就如何决定选择哪一项提供指导吗？在Ruby 1.9中，proc和lambda是不同的。这是怎么回事？

解决方案：

我发现此页面显示了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，但是我不认为他们会做很多改变(尽管请不要相信我，看来我们已经听说了一些更改，所以我可能在那里错了。

用lambda创建的proc和用Proc.new创建的proc之间的另一个重要但细微的区别是它们如何处理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"

由于这种令人惊讶的行为(以及更少的键入)，我在制作proc时倾向于使用lambda而不是Proc.new。

恕我直言，" return"与" return"在行为上的区别是2之间的最重要区别。我也更喜欢lambda，因为它的类型比Proc.new少：-)

Ruby中的闭包很好地概述了Ruby中的块，lambda和proc如何在Ruby中工作。

要详细说明"手风琴家"的回应：

注意，Proc.new通过传递一个块来创建一个proc out。我相信lambda {...}被解析为一种文字，而不是通过块的方法调用。从添加到方法调用的块内部进行"返回"将从该方法而不是该块返回，而Proc.new案例就是这种情况的一个例子。

(这是1.8. 我不知道这如何转换为1.9. )

Proc年龄较大，但是return的语义对我来说是非常违反直觉的(至少在我学习语言时)，因为：

如果我们使用proc，则很可能使用某种功能范例。 Proc可以退出封闭范围(请参阅先前的响应)，这基本上是goto，本质上是高度不起作用的。

Lambda在功能上更安全，更容易推理，因为我始终使用它而不是proc。

对于细微的差异，我不能说太多。但是，我可以指出，Ruby 1.9现在允许用于lambda和block的可选参数。

这是1.9以下的稳定lambda的新语法：

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

Ruby 1.8没有该语法。常规的声明块/ lambda的方法也不支持可选的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，请查看本文(无耻的自我推广)。

看到它的一个好方法是，lambda在其自己的范围内执行(就像它是一个方法调用一样)，而Procs可能被视为与调用方法内联执行，至少这是决定使用哪一个方法的好方法在每种情况下。

我没有注意到对问题的第三个方法" 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

为了进一步说明：

Joey说Proc.new的返回行为令人惊讶。但是，当我们认为Proc.new的行为类似于块时，这并不奇怪，因为这正是块的行为方式。另一方面，lambas的行为更像方法。

这实际上解释了为什么Procs在处理Arity(参数数量)时灵活，而Lambda却不灵活。块不需要提供所有参数，而方法需要(除非提供了默认值)。虽然在Ruby 1.8中不提供默认的lambda参数选项，但现在在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中具有相同的含义是不正确的。我已经验证他们仍然保持上述指定的行为1.8.

实际上，无论是Procs还是lambda，break语句都没有多大意义。在Procs中，中断将使我们从已经完成的Proc.new返回。而且，从lambda中断并没有任何意义，因为它本质上是一种方法，并且我们永远也不会从方法的顶层中断。

在Procs和Lambda中，next，redo和raise的行为相同。然而，任何一种都不允许使用"重试"，这将引发异常。

最后，永远不要使用proc方法，因为它是不一致的并且具有意外的行为。在Ruby 1.8中，它实际上返回一个lambda！在Ruby 1.9中，此问题已修复，并返回Proc。如果要创建Proc，请坚持使用Proc.new。

有关更多信息，我强烈推荐O''Reilly的Ruby编程语言，它是我获得大部分此类信息的来源。