在Ruby 1.8中,proc / lambda与Proc.new之间存在细微差别。

  • 这些差异是什么?
  • 你能给出如何决定选择哪一个的指导方针吗?
  • 在Ruby 1.9中,proc和lambda是不同的。 这是怎么回事?

===============>>#1 票数:377 已采纳

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

  • lambda创建的proc中, return语句仅从proc本身返回
  • Proc.new -created proc中, return语句更令人惊讶:它不仅从proc返回控制, 还从包含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"

由于这种令人惊讶的行为(以及较少的打字),我倾向于在制作Proc.new时使用lambda不是Proc.new

===============>>#2 票数:95

进一步澄清:

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

这实际上解释了为什么Procs在arity(参数数量)方面是灵活的,而lambdas则不是。 块不需要提供它们的所有参数,但是方法会提供(除非提供默认值)。 虽然在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)对于Procs和lambda在Ruby 1.9中与arity表现相同是不正确的。 我已经验证他们仍然保持上述1.8的行为。

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

在proc和lambdas中, nextredoraise行为相同。 虽然两者都不允许retry ,但会引发异常。

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

有关更多信息,我强烈推荐O'Reilly的The Ruby Programming Language ,这是我获取大部分信息的源代码。

===============>>#3 票数:43

我发现这个页面显示了Proc.newlambda之间的区别。 根据该页面,唯一的区别是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 票数:16

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

  1. 如果你使用proc,你最有可能使用某种功能范例。
  2. Proc可以退出封闭范围(参见前面的回复),这本质上是一个转向,并且本质上是高度无功能的。

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

===============>>#5 票数:11

我不能多说这些微妙的差异。 但是,我可以指出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,请查看这篇文章 (无耻的自我推销)。

===============>>#6 票数:11

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

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

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

如果要创建新的语言结构(如循环,if-else结构等),您只需要这样做。

===============>>#7 票数:10

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

===============>>#8 票数:8

我没有注意到对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

===============>>#9 票数:7

Ruby中的闭包是对Ruby ,lambda和proc如何在Ruby中工作的一个很好的概述。

===============>>#10 票数:5

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

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

Proc.new创建的proc中的return语句Proc.new会从自身返回控制, 还会从包含它的方法返回控制。

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

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

您可以争辩说Proc.new代码插入到封闭方法中,就像阻塞一样。 但是Proc.new创建了一个对象,而块是对象的一部分

而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"

顺便说一下,R​​uby 1.8中的proc创建了一个lambda,而在Ruby 1.9中, proc就像Proc.new一样,这实在令人困惑。

===============>>#11 票数:3

我对此有点迟,但有一个很好但鲜为人知的关于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!

===============>>#12 票数:3

详细说明Accordion Guy的回应:

请注意, Proc.new通过传递块来创建一个proc。 我相信lambda {...}被解析为一种文字,而不是传递一个块的方法调用。 return从内部连接到一方法调用的块将从该方法中,不是块返回,和ING的Proc.new情况下是在起作用的这样一个例子。

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

===============>>#13 票数:1

值得强调的是return从词法封闭方法PROC的回报,即在其中创建PROC的方法 ,而不是所谓的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时则不那么直观。

===============>>#14 票数:1

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

  ask by Michiel de Mare translate from so

未解决问题?本站智能推荐: