ruby -何时使用lambda,何时使用Proc.new?

Translate

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

  • 这些差异是什么?
  • 您可以就如何决定选择哪一项提供指导吗?
  • 在Ruby 1.9中,proc和lambda是不同的。这是怎么回事?
This question and all comments follow the "Attribution Required."

所有的回答

Translate

使用proc创建的proc之间的另一个重要但细微的区别lambda和过程创建Proc.new他们如何处理return声明:

  • 在一个lambda创建的proc,return语句仅从proc本身返回
  • 在一个Proc.new创建的proc,return语句有点令人惊讶:它不仅从proc返回控制,而且还可以从包含proc的方法中获得!

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

来源
Translate

为了进一步说明:

乔伊(Joey)说,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"

而且,Michiel de Mare(OP)关于Procs和lambda在Ruby 1.9中具有相同的含义是不正确的。我已验证他们仍然保持上述指定的行为1.8。

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

next, redoraise在Procs和Lambda中的行为相同。鉴于retry两者都不被允许,并且会引发异常。

最后,proc永远不要使用该方法,因为它前后不一致且具有意外行为。在Ruby 1.8中,它实际上返回一个lambda!在Ruby 1.9中,此问题已修复,并返回Proc。如果要创建Proc,请坚持使用Proc.new.

有关更多信息,我强烈推荐O'Reilly'sRuby编程语言这是我获得的大部分此类信息的来源。

来源
Translate

我发现这一页这说明了两者之间的区别Proc.newlambda是。根据该页面,唯一的区别是lambda严格接受它接受的参数数量,而Proc.new将缺少的参数转换为nil。这是示例IRB会话,说明了不同之处:

irb(main):001:0> l = lambda { |x, y| x + y }
=> #<Proc:[email protected](irb):1>
irb(main):002:0> p = Proc.new { |x, y| x + y }
=> #<Proc:[email protected](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,但我不认为他们会做很多改变(尽管请不要相信我,看来您已经听说了一些更改,所以我可能在那里错了。

来源
Louise Lee
Translate

Proc年龄较大,但是return的语义对我来说是非常违反直觉的(至少在我学习语言时),因为:

  1. 如果您使用proc,则很可能使用某种功能范例。
  2. Proc可以退出封闭范围(请参阅先前的响应),这基本上是goto,本质上是高度不起作用的。

Lambda在功能上更安全,更容易推理-我始终使用它而不是proc。

来源
Translate

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

这是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:[email protected](irb):1 (lambda)>
l.call
#=> inside the regular lambda
l.call('jeez')
#=> jeez

如果您想为Leopard或Linux构建Ruby1.9,请查看本文(无耻的自我提升)。

来源
Translate

简短答案:重要的是什么return这样做:lambda返回自身,而proc返回自身,并返回调用它的函数。

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

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

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

来源
Translate

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

来源
Translate

我没有注意到对问题的第三个方法“ 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
来源
Geoffrey Lee
Translate

Ruby中的闭包是一个很好的概述,介绍了如何在Ruby中使用Ruby进行块,lambda和proc的工作。

来源
Translate

lambda可以像其他语言一样正常工作。

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

returnproc中的语句创建者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和Proc.new,这是他们对(错误)参数的处理。 lambda对此有所抱怨,而Proc.new忽略多余的参数或将不存在的参数视为nil。

irb(main):021:0> l = -> (x) { x.to_s }
=> #<Proc:[email protected](irb):21 (lambda)>
irb(main):022:0> p = Proc.new { |x| x.to_s}
=> #<Proc:[email protected](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,这确实令人困惑。

来源
Translate

要详细说明“手风琴家”的回应:

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

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

来源
Translate

我在这方面有点迟了,但是有一件很棒但鲜为人知的事情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!
来源
Translate

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

来源
Translate

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

虽然proc在执行foobar,它是在foo所以return出口foo, 不只是foobar。正如查尔斯·考德威尔(Charles Caldwell)上文所述,它具有GOTO的感觉。在我看来,return在以其词法上下文执行的块中很好,但是在以不同上下文执行的proc中使用时则不太直观。

来源