何时使用lambda，何时使用Proc.new？-Java 学习之路

325

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

这些差异是什么？
您能否就如何决定选择哪一个提供指导？
在Ruby 1.9中，proc和lambda是不同的 . 这是怎么回事？

15 回答

11
使用 lambda 创建的proc和使用 Proc.new 创建的proc之间的另一个重要但微妙的区别是它们如何处理 return 语句：
- 在 lambda 创建的proc中， return 语句仅从proc本身返回
- 在 Proc.new 创建的proc中， return 语句更令人惊讶：它不仅仅从proc返回控件， but also from the method enclosing the 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"
```
由于这种令人惊讶的行为（以及较少的打字），我倾向于在制作过程时使用 lambda 而不是 Proc.new .
回复于 2024-04-26T04:10:05+08:00
1
进一步澄清：

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

这实际上解释了为什么Procs在arity（参数数量）方面是灵活的，而lambdas则不是 . 块不需要提供它们的所有参数，但是方法会提供（除非提供默认值） . 虽然提供lambda参数默认值不是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和lambda中， next ， redo 和 raise 的行为相同 . 而 retry 中的任何一个都不允许，并且会引发异常 .

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

有关更多信息，我强烈推荐O 'Reilly'的Ruby编程语言，这是我获取大部分信息的来源 .
回复于 2024-04-26T04:10:05+08:00
6
我找到了this page，它显示了 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，但我不认为他们会改变它那么多（尽管你不听我的话，似乎你听说过一些变化，所以我可能错了） .
回复于 2024-04-26T04:10:05+08:00
94
Proc比较老，但返回的语义对我来说非常违反直觉（至少在我学习语言时），因为：
- 如果您正在使用proc，那么您最有可能使用某种功能范例 .
- Proc可以退出封闭范围（参见前面的答复），这本质上是一个goto，并且本质上是非功能性的 .
Lambda在功能上更安全，更容易推理 - 我总是使用它而不是proc .
回复于 2024-04-26T04:10:05+08:00

我不能多说这些微妙的差异 . 但是，我可以指出Ruby 1.9现在允许lambdas和blocks的可选参数 .

这是1.9下的stabby lambdas的新语法：

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

Ruby 1.8没有那种语法 . 声明块/ lambdas的传统方式也不支持可选的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，请查看this article（无耻的自我推销） .

回复于 2024-04-26T04:10:05+08:00

5

简短的回答：重要的是 return 的作用：lambda返回自身，并且proc返回自身以及调用它的函数 .

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

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

如果要创建新的语言结构（如循环，if-else构造等），您只需要这样做 .

回复于 2024-04-26T04:10:05+08:00
1

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

回复于 2024-04-26T04:10:05+08:00

373

我没有注意到对queston中的第三个方法的任何评论，“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

回复于 2024-04-26T04:10:05+08:00

14

Closures in Ruby很好地概述了Ruby，lambda和proc如何在Ruby中工作 .

回复于 2024-04-26T04:10:05+08:00
41

Robert Sosinski的Understanding Ruby Blocks, Procs and Lambdas清楚地解释了这些编程概念，并通过示例代码强化了解释 . 方法对象也是相关的并且也包含在内 .

回复于 2024-04-26T04:10:05+08:00

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 创建了一个对象，而block是一个对象的一部分 .

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

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中的BTW， proc 创建了一个lambda，而在Ruby 1.9中的行为就像 Proc.new ，这实在令人困惑 .

回复于 2024-04-26T04:10:05+08:00

8

详细说明Accordion Guy的回应：

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

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

回复于 2024-04-26T04:10:05+08:00
9
我在这方面有点晚了，但是有一个很好但鲜为人知的事情 Proc.new 在评论中没有提到 . 由documentation：

只有在带有附加块的方法中，才可以在没有块的情况下调用Proc :: new，在这种情况下，该块将转换为Proc对象 .

也就是说， Proc.new 允许链接让步方法：
```
def m1
  yield 'Finally!' if block_given?
end

def m2
  m1 &Proc.new
end

m2 { |e| puts e } 
#⇒ Finally!
```
回复于 2024-04-26T04:10:05+08:00
3

与 return 的行为差异是恕我直言2之间最重要的区别 . 我也更喜欢lambda，因为它的输入比Proc.new少:-)

回复于 2024-04-26T04:10:05+08:00
11
值得强调的是，proc中的 return 从词法封闭方法返回，即创建proc的方法， not 调用proc的方法 . 这是procs的closure属性的结果 . 所以下面的代码没有输出：
```
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 . 正如查尔斯·考德威尔（Charles Caldwell）在上面写的那样，它有一种GOTO感觉 . 在我看来， return 在一个在其词汇上下文中执行的块中很好，但是当在一个在不同上下文中执行的proc中使用时更不直观 .
回复于 2024-04-26T04:10:05+08:00

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

15 回答

相关问题