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

Question

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

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

Answer 1

使用lambda Proc.new的 proc 之间的另一个重要但微妙的区别是它们如何处理return语句：

• 在lambda创建的 proc 中， return语句仅从 proc 本身返回
• 在Proc.new创建的 proc 中， return语句有点令人惊讶：它不仅从 proc 中返回控制权，还从包含 proc 的方法中返回控制！

这是lambda -created 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 -created 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"

由于这种令人惊讶的行为（以及更少的打字），在制作 procs 时，我倾向于使用lambda而不是Proc.new 。

Answer 2

为了提供进一步的说明：

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

这实际上解释了为什么 Procs 在涉及到 arity（参数数量）时是灵活的，而 lambdas 则不是。 块不需要提供所有的 arguments，但方法需要提供（除非提供了默认值）。 While providing lambda argument default is not an option in Ruby 1.8, it is now supported in Ruby 1.9 with the alternative lambda syntax (as noted by 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 的行为。

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

next 、 redo和raise在 Procs 和 lambda 中的行为相同。 两者都不允许retry ，并且会引发异常。

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

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

Answer 3

我发现这个页面显示了Proc.new和lambda之间的区别。 根据页面，唯一的区别是 lambda 对它接受的 arguments 的数量是严格的，而Proc.new将缺少的 arguments 转换为nil 。 这是一个示例 IRB session 说明了差异：

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，但我不认为他们会改变它（不过不要相信我的话，你似乎听说过一些改变，所以我可能在那里错了）。

Answer 4

Proc 比较老，但是 return 的语义对我来说是非常违反直觉的（至少在我学习语言时），因为：

1. 如果您使用的是 proc，那么您很可能会使用某种功能范式。
2. Proc 可以从封闭的 scope 中返回（请参阅之前的回复），这基本上是一个 goto，并且本质上是高度非功能性的。

Lambda 在功能上更安全，更容易推理 - 我总是使用它而不是 proc。

Answer 5

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

这是 1.9 下 stabby lambda 的新语法：

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

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

# 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 支持可选的 arguments，即使使用旧语法：

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，请查看这篇文章（无耻的自我宣传）。

Answer 6

简短的回答：重要的是return的作用：lambda 从自身返回，proc 从自身返回以及调用它的 function。

不太清楚的是为什么要使用每个。 lambda 是我们期望在函数式编程意义上应该做的事情。 它基本上是一种匿名方法，自动绑定当前的 scope。 在这两者中，您可能应该使用 lambda。

另一方面，Proc 对于实现语言本身非常有用。 例如，您可以使用它们实现“if”语句或“for”循环。 在 proc 中找到的任何返回都将从调用它的方法中返回，而不仅仅是“if”语句。 这就是语言的工作方式，“if”语句的工作方式，所以我的猜测是 Ruby 在幕后使用它，他们只是暴露了它，因为它看起来很强大。

只有在创建新的语言结构（如循环、if-else 结构等）时才真正需要它。

Answer 7

看到它的一个好方法是 lambdas 在它们自己的 scope 中执行（好像它是一个方法调用），而 Procs 可以被视为与调用方法内联执行，至少这是决定使用哪一个的好方法在每种情况下。

Answer 8

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

Answer 9

Ruby中的闭包很好地概述了块、lambda 和 proc 如何在 Ruby 中与 Z9916D1FC59FE27FECC04454A 一起工作。

Answer 10

lambda 按预期工作，就像在其他语言中一样。

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

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

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

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

您可以争辩说Proc.new将代码插入到封闭方法中，就像块一样。 但是Proc.new创建了一个 object，而块是 object 的一部分。

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

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"

顺便说一句，Ruby 1.8 中的proc创建了一个 lambda，而在 Ruby 1.9+ 中的行为类似于Proc.new ，这确实令人困惑。

Answer 11

我对此有点晚了，但是评论中根本没有提到关于Proc.new的一件很棒但鲜为人知的事情。 根据文档：

Proc::new只能在带有附加块的方法中调用而没有块，在这种情况下，该块将转换为Proc object。

也就是说， Proc.new允许链接产生方法：

def m1
  yield 'Finally!' if block_given?
end

def m2
  m1 &Proc.new
end

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

Answer 12

详细说明 Accordion Guy 的回应：

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

（这是 1.8。我不知道如何转换为 1.9。）

Answer 13

值得强调的是，proc 中的return从词法封闭的方法返回，即创建 proc的方法，而不是调用 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 。 正如查尔斯考德威尔在上面写的那样，它有一种 GOTO 的感觉。 在我看来， return在在其词法上下文中执行的块中很好，但在用于在不同上下文中执行的 proc 中时就不太直观了。

Answer 14

return行为的差异是恕我直言，两者之间最重要的差异。我也更喜欢 lambda 因为它的打字比 Proc.new 少:-)