342

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

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

14 回答 14

380

lambdaprocs created with和 procs created with之间另一个重要但微妙的区别Proc.new是它们如何处理return语句：

  • 在lambda-created proc 中，return语句仅从 proc 本身返回
  • 在Proc.new-created 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 procreturn做同样的事情。您即将看到 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 时使用lambdaover 。Proc.new

于 2008-08-03T15:21:52.760 回答
95

为了提供进一步的说明：

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

这实际上解释了为什么 Procs 在涉及到 arity（参数数量）时是灵活的，而 lambdas 则不是。块不需要提供所有参数，但方法需要提供（除非提供默认值）。虽然提供 lambda 参数 default 在 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 的行为。

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

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

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

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

于 2009-10-04T05:23:22.903 回答
42

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

irb(main):001:0> l = lambda { |x, y| x + y }
=> #<过程：0x00007fc605ec0748@(irb):1>
irb(main):002:0> p = Proc.new { |x, y| x + y }
=> #<过程：0x00007fc605ea8698@(irb):2>
irb(main):003:0> l.call "hello", "world"
=>“你好世界”
irb(main):004:0> p.call "hello", "world"
=>“你好世界”
irb(main):005:0> l.call“你好”
ArgumentError：参数数量错误（1 对 2）
    来自 (irb):1
    来自 (irb):5:in `call'
    来自 (irb):5
    从 :0
irb(main):006:0> p.call“你好”
TypeError：无法将 nil 转换为字符串
    来自 (irb):2:in `+'
    来自 (irb):2
    来自 (irb):6:in `call'
    来自 (irb):6
    从 :0

该页面还建议使用 lambda，除非您特别想要容错行为。我同意这种观点。使用 lambda 似乎更简洁一些，而且差异如此之小，在一般情况下似乎是更好的选择。

至于 Ruby 1.9，对不起，我还没有研究 1.9，但我不认为他们会改变它（不过不要相信我的话，你似乎听说过一些改变，所以我可能在那里错了）。

于 2008-08-03T07:28:54.070 回答
15

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

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

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

于 2008-09-10T23:32:34.683 回答
11

我不能说太多的细微差别。但是，我可以指出，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 即使使用旧语法也支持可选参数：

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

于 2008-11-19T21:28:28.783 回答
11

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

于 2008-12-09T14:17:51.017 回答
11

简短的回答：重要的是做什么return：lambda 从自身返回，proc 从自身和调用它的函数返回。

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

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

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

于 2011-10-06T18:33:20.840 回答
7

我没有注意到对问题中的第三种方法“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
于 2009-06-25T11:22:32.633 回答
6

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

于 2008-08-28T13:50:12.320 回答
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创建一个对象，而块是对象的一部分。

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

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在 Ruby 1.8 中创建了一个 lambda，而在 Ruby 1.9+ 中的行为类似于Proc.new，这确实令人困惑。

于 2014-10-29T16:22:59.553 回答
3

详细说明 Accordion Guy 的回应：

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

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

于 2008-09-07T02:31:40.607 回答
3

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!
于 2015-04-28T13:15:25.247 回答
3

值得强调的是，return在proc 中返回的是词法封闭的方法，即创建proc的方法，而不是调用proc 的方法。这是 procs 的闭包属性的结果。所以下面的代码什么也不输出：

def foo
  proc = Proc.new{return}
  foobar(proc)
  puts 'foo'
end

def foobar(proc)
  proc.call
  puts 'foobar'
end

foo

虽然 proc 在 in 中执行foobar，但它是在 in 中创建的foo，因此return退出foo，而不仅仅是foobar. 正如查尔斯考德威尔在上面写的那样，它有一种 GOTO 的感觉。在我看来，return在其词法上下文中执行的块中很好，但在在不同上下文中执行的 proc 中使用时就不那么直观了。

于 2018-11-15T10:00:54.907 回答
1

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

于 2008-08-11T02:09:46.683 回答