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

#1 楼

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


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


这里的lambda-创建了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-创建的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"

由于这种令人惊讶的行为（以及减少了键入） ），在制作proc时，我倾向于使用lambda而不是Proc.new。

#2 楼

为了进一步说明问题，

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

这实际上解释了为什么Procs在涉及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"

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

next，redo和raise在Procs和lambdas。而在任何一个中都不允许使用retry，并且会引发异常。最后，永远不要使用proc方法，因为它前后不一致且具有意外行为。在Ruby 1.8中，它实际上返回一个lambda！在Ruby 1.9中，此问题已修复，并返回Proc。如果要创建Proc，请坚持使用Proc.new。

有关更多信息，我强烈建议使用O'Reilly的Ruby编程语言，该书是我获得大部分信息的来源。

#3 楼

我发现此页面显示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但我不认为他们会对此做出很大的改变（尽管不要相信我，看来您已经听说了一些变化，所以我在那里可能是错的）。

#4 楼

Proc年龄较大，但是return的语义对我而言是高度违反直觉的（至少在我学习语言时），原因是：


如果您使用proc，则很可能会使用某些一种功能范式。
Proc可以退出封闭范围（请参阅先前的响应），这基本上是goto的方法，本质上是高度非功能性的。我总是用它代替proc。

#5 楼

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

这是1.9以下的稳定lambda的新语法：

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

Ruby 1.8没有该语法。常规的声明块/ lambda的方法也都不支持可选的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，请查看此文章（无耻的自我推广）。

#6 楼

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

#7 楼

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

还不清楚为什么要使用它们。 lambda是我们期望在功能编程意义上应该做的事情。它基本上是一个匿名方法，当前范围自动绑定。在这两种语言中，lambda可能是您应该使用的语言。另一方面，Proc对于实现语言本身非常有用。例如，您可以使用它们来实现“ if”语句或“ for”循环。在proc中找到的任何返回值都将从调用它的方法中返回，而不仅仅是“ if”语句。这就是语言的工作方式，“ if”语句的工作方式，所以我猜Ruby是在幕后使用它的，只是因为它看起来强大而就公开了它。创建新的语言结构，例如循环，if-else结构等。

#8 楼

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

#9 楼

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

#10 楼

lambda可以像其他语言一样按预期工作。

有线的Proc.new令人惊讶且令人困惑。 ，也可以从包围它的方法中进行。

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

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

您可以说return就像在代码块中一样，将代码插入了包围方法中。对象，而块是对象的一部分。

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"

BTW，Ruby 1.8中的Proc.new创建一个lambda，而在Ruby 1.9+中的行为类似于Proc.new，这实际上令人困惑。

#11 楼

要详细说明手风琴Guy的响应，请注意：

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

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

#12 楼

我有点迟了，但是关于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!

#13 楼

值得强调的是proc中的return是从词法包围方法（即创建proc的方法，而不是调用proc的方法）返回的。这是procs的闭合属性的结果。因此，以下代码不会输出任何内容：尽管proc在foobar中执行，但它是在foo中创建的，因此return退出foo，而不仅仅是foobar。正如查尔斯·考德威尔（Charles Caldwell）上文所述，它具有GOTO的感觉。我认为，return在以其词法上下文执行的块中很好，但在以不同上下文执行的proc中使用时，则不太直观。

#14 楼

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