什么时候用，什么时候用proc。new?

我找到了这个页面，它显示了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，但我不认为他们会有那么大的变化(不过不要相信我的话，似乎你已经听说了一些变化，所以我可能错了)。

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

• 在__abc0创建的过程中，return语句只从过程本身返回
• 在__abc0创建的过程中，return语句有点令人惊讶:它不仅从过程但是也可以从包含proc!返回控制

下面是__abc0创建的进程的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"

现在这里是一个__abc0创建的进程的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"

由于这种令人惊讶的行为(以及更少的输入)，我倾向于在执行procs时使用lambda而不是Proc.new。

在我看来，return的行为差异是两者之间最重要的区别。我也更喜欢lambda，因为它的类型比Proc.new少:-)

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

来详细解释一下Accordion Guy的回应:

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

(这是1.8。我不知道这是如何转换成1.9的。)

Proc比较老，但是返回的语义对我来说是非常违反直觉的(至少在我学习这门语言的时候)，因为:

1. 如果您正在使用proc，那么您很可能正在使用某种函数范式。
2. Proc可以返回封闭作用域之外(参见前面的响应)，这基本上是一个goto，本质上是非功能性的。

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

我不能说太多细微的差别。但是，我可以指出Ruby 1.9现在允许lambdas和block的可选参数。

下面是1.9版本中stabby lambdas的新语法:

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

Ruby 1.8没有这种语法。声明blocks/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，请查看这篇文章(无耻的自我宣传)。

一个很好的方法是，lambdas是在它们自己的作用域内执行的(就好像它是一个方法调用一样)，而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

为了进一步澄清:

Joey说Proc.new的返回行为令人惊讶。然而，当你认为Proc.new的行为就像一个块，这并不奇怪，因为这正是块的行为。另一方面，Lambas的行为更像方法。

这实际上解释了为什么Procs在涉及到arity(参数数量)时很灵活，而lambdas则不是。block不需要提供它们的所有参数，但方法需要(除非提供默认值)。虽然在Ruby 1.8中没有提供lambda参数default的选项，但现在Ruby 1.9支持它，并提供了另一种lambda语法(如webmat所述):

concat = ->(a, b=2){ "#{a}#{b}" }
concat.call(4,5) # => "45"
concat.call(1)   # => "12"

Michiel de Mare (OP)关于proc和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's Ruby编程语言，这是我大部分信息的来源。

简单的回答:重要的是return所做的事情:lambda返回自身，proc返回自身和调用它的函数。

不太清楚的是为什么要使用它们。Lambda是我们在函数式编程中所期望的。它基本上是一个匿名方法，当前范围自动绑定。这两个中，应该用的是。

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

只有当你创建新的语言结构，如循环，if-else结构等，你才真正需要这个。

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

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中proc创建了一个lambda，而在Ruby 1.9+中则表现为Proc.new，这确实令人困惑。

我在这方面有点晚了，但有一个关于Proc.new的伟大但鲜为人知的事情在评论中根本没有提到。如文档所示:

Proc::new只能在带有附加块的方法中不带块地调用，在这种情况下，块被转换为Proc .对象。

也就是说，Proc.new允许链接yield方法:

def m1
yield 'Finally!' if block_given?
end


def m2
m1 &Proc.new
end


m2 { |e| puts e }
#⇒ Finally!

值得强调的是，proc中的return从词法上的封闭方法返回，即创建过程的方法， 不调用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在在其词法上下文中执行的块中很好，但在在不同上下文中执行的过程中使用时就不那么直观了。