何时使用 lambda，何时使用 Proc.new？

StackOverflow https://stackoverflow.com/questions/626

  •  08-06-2019
  •  | 
  •  

题

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

  • 这些差异是什么？
  • 您能否给出如何决定选择哪一个的指南？
  • 在 Ruby 1.9 中，proc 和 lambda 是不同的。这是怎么回事？
有帮助吗？

解决方案

使用创建的过程之间的另一个重要但微妙的区别 lambda 和创建的进程 Proc.new 他们是如何处理的 return 陈述：

  • 在一个 lambda-创建的过程， return 语句仅从过程本身返回
  • 在一个 Proc.new-创建的过程， return 声明有点令人惊讶：它不仅从进程返回控制权， 而且还来自包含过程的方法！

这是 lambda-创建的过程 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-创建的过程 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 制作过程时。

其他提示

提供进一步说明：

乔伊说，返回行为 Proc.new 令人惊讶。然而，当您考虑到 Proc.new 的行为类似于块时，这并不奇怪，因为这正是块的行为方式。另一方面，lambas 的行为更像方法。

这实际上解释了为什么 Proc 在 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）关于 Ruby 1.9 中 Procs 和 lambda 的行为与 arity 相同的说法是错误的。我已验证它们仍然保持上述 1.8 中指定的行为。

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

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

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

欲了解更多信息，我强烈推荐 O'Reilly's Ruby 编程语言 这是我大部分信息的来源。

我发现 这一页 这显示了之间的区别 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，但我不认为他们会改变那么多（不过不要相信我的话，看来你已经听说过一些变化，所以我可能错了）。

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

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

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

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

以下是 1.9 版本中的 stable lambda 的新语法：

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

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

# 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，请查看 本文 （无耻的自我推销）。

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

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

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

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

观察它的一个好方法是 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

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

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 将代码插入到封闭的方法中，就像 block 一样。但 Proc.new 创建一个对象，而块是 部分 一个东西。

lambda 和 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, ，这确实令人困惑。

详细说明手风琴人的回应：

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

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

我在这方面有点晚了，但有一件伟大但鲜为人知的事情 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!

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

值得强调的是 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

虽然过程执行在 foobar, ，它创建于 foo 所以 return 退出 foo, ， 不只是 foobar. 。正如 Charles Caldwell 上面所写，它有一种 GOTO 的感觉。在我看来， return 在词法上下文中执行的块中很好，但在不同上下文中执行的过程中使用时就不太直观了。

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top