何时使用lambda,何时使用proc.new?

使用 lambda 和用创建的过程 Proc.new 是他们如何处理 return 声明:

• 在一个 兰姆达 -创建过程, 返回 语句只从进程本身返回
• 在一个 新进展 -创建过程, 返回 语句更令人惊讶:它不仅从proc返回控件, 但也来自封闭过程的方法!

这里是 兰姆达 -创建PROC 返回 在行动中。它的行为方式可能是您所期望的:

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 返回 做同样的事情。您将看到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.new 令人惊讶。但是,当您认为proc.new的行为类似于一个块时,这并不奇怪,因为这正是块的行为方式。另一方面,lamba的行为更像方法。

这就解释了为什么当涉及到arity(参数数量)时procs是灵活的,而lambda不是。块不需要提供它们的所有参数,但方法需要(除非提供了默认值)。虽然在Ruby1.8中提供lambda参数default不是一个选项,但现在Ruby1.9中支持它,并提供了可选的lambda语法(如webmat所指出的那样):

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

对于Ruby1.9中的procs和lambda,michiel de mare(op)的行为与arity相同,这是错误的。我已经确认他们仍然保持上述1.8的行为。

break 无论是Procs还是Lambda,声明实际上都没有多大意义。在procs中,break将从proc.new返回您,而proc.new已经完成。从lambda中分离是没有意义的,因为它本质上是一个方法,而且您永远不会从方法的顶级分离出来。

next , redo 和 raise 在procs和lambda中的行为相同。反之 retry 两者都不允许,将引发异常。

最后, proc 方法不应使用,因为它不一致并且具有意外的行为。在Ruby1.8中,它实际上返回一个lambda!在Ruby1.9中,这已经被修复,它返回一个过程。如果你想创建一个过程,坚持 新进展 .

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

我发现 this page 这说明了两者之间的区别 Proc.new 和 lambda 是。根据页面,唯一的区别是lambda严格限制了它接受的参数的数量,而 新进展 将缺少的参数转换为 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似乎有点简洁,并且有如此微小的差别,在一般情况下它似乎是更好的选择。

至于Ruby1.9,抱歉,我还没有研究过1.9,但是我不认为它们会改变那么多(尽管不要相信我的话,你好像听说过一些变化,所以我可能错了)。

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

1. 如果您使用proc,那么您很可能使用某种函数范式。
2. proc可以返回封闭范围之外(参见前面的响应),这基本上是一个goto,本质上是高度不起作用的。

lambda在功能上更安全,也更容易解释——我总是使用它而不是proc。

我不能说太多细微的差别。但是,我可以指出Ruby1.9现在允许为lambda和块使用可选参数。

下面是1.9下面的刺伤lambda的新语法:

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

Ruby1.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 }

然而,Ruby1.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 (无耻的自我提升)。

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

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

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

只有在创建新的语言结构(如循环、if-else结构等)时,才真正需要这样做。

一个很好的方法是在自己的范围内执行lambda(就好像它是一个方法调用),而proc可以被视为与调用方法内联执行,至少这是决定在每种情况下使用哪个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

Closures in Ruby 对于块、lambda和proc如何在Ruby和Ruby中工作是一个很好的概述。

Understanding Ruby Blocks, Procs and Lambdas 作者Robert Sosinski清楚地解释了这些编程概念,并用示例代码加强了解释。 方法对象 也有关联和覆盖。

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

有线电视 Proc.new 令人惊讶和困惑。

这个 return 语句在进程中由创建 新进展 不仅从自身返回控制权,而且 也从包围它的方法 .

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

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

你可以这么说 新进展 将代码插入封闭方法,就像块一样。 但是 新进展 创建一个对象,而块是 部分 物体。

lambda和 新进展 这是他们对(错误)论点的处理。 lambda抱怨,而 新进展 忽略多余的参数或将缺少参数视为零。

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 在Ruby1.8中创建一个lambda,而在Ruby1.9+中的行为类似于 新进展 ,这真让人困惑。

详细说明手风琴演奏者的反应:

注意到 Proc.new 通过传递一个块来创建一个proc out。我相信 lambda {...} 被解析为一种文本,而不是传递块的方法调用。 return 从附加到方法调用的块内部返回的是方法,而不是块,并且 新进展 案例就是这样一个例子。

(这是1.8。我不知道这是怎么翻译成1.9的。)

我在这方面有点晚了,但有一件很好但鲜为人知的事 Proc.new 评论中根本没有提到。按 documentation :

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

这就是说, 新进展 让我们来链屈服方法:

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的方法。这是Procs关闭属性的结果。因此以下代码不输出任何内容:

def foo
  proc = Proc.new{return}
  foobar(proc)
  puts 'foo'
end

def foobar(proc)
  proc.call
  puts 'foobar'
end

foo

尽管过程在 foobar ,创建于 foo 所以 返回 出口 福 不仅仅是 福巴 . 正如查尔斯考德威尔在上面写的,它有一种哥特式的感觉。在我看来, 返回 在一个在其词汇上下文中执行的块中是很好的,但在另一个上下文中执行的过程中使用时则不太直观。