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 回答