关于ruby：何时使用lambda，何时使用Proc.new？


When to use lambda, when to use Proc.new?

在Ruby1.8中，一方面proc/lambda与另一方面Proc.new之间存在细微的差异。

  • 这些区别是什么？
  • 你能就如何决定选择哪一个给出指导吗？
  • 在Ruby1.9中，proc和lambda是不同的。怎么回事？
相关讨论

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

  • 在lambda创建的过程中，return语句只从过程本身返回
  • 在一个Proc.new创建的过程中，return语句更令人惊讶：它不仅从过程返回控制，还从包含过程的方法返回控制！

这是由lambda创建的proc的return正在运行。它的行为方式可能是您所期望的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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打破了自吹自擂的最不令人惊讶的原则：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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。

相关讨论

进一步澄清：

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

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

1
2
3
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的行为。

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

next、redo和raise在Procs和Lambdas中表现相同。而retry在两者中都不允许，并将引发一个例外。

最后，不应使用proc方法，因为它不一致并且具有意外行为。在Ruby1.8中，它实际上返回一个lambda！在Ruby1.9中，这已经被修复，它返回一个过程。如果要创建一个过程，请使用Proc.new。

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

相关讨论

我找到了这个页面，显示了Proc.new和lambda之间的区别。根据该页面，唯一的区别是lambda严格限制它接受的参数的数量，而Proc.new将缺少的参数转换为nil。下面是一个IRB会话示例，说明了不同之处：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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比较老，但是返回的语义对我来说是非常违反直觉的(至少在我学习语言的时候)，因为：

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

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

    简短的回答：重要的是return所做的：lambda从自身返回，proc从自身和调用它的函数返回。

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

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

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

    相关讨论

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

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

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

    Ruby1.8没有这种语法。声明块/lambda的常规方法也不支持可选参数：

    1
    2
    3
    4
    5
    # 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支持可选参数，即使使用旧语法：

    1
    2
    3
    4
    5
    6
    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，请阅读本文(无耻的自我提升)。

    相关讨论

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

    我没有注意到关于问题"proc"中第三个方法的任何评论，它被否决了，但是在1.8和1.9中处理方式不同。

    下面是一个相当详细的示例，可以很容易地看到三个类似调用之间的区别：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    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
    相关讨论

    Ruby中的闭包是Ruby中如何使用块、lambda和proc的一个很好的概述。

    相关讨论

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

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

    由Proc.new创建的return语句不仅从本身返回控制，而且从包含它的方法返回控制。

    1
    2
    3
    4
    5
    6
    7
    def some_method
      myproc = Proc.new {return"End."}
      myproc.call

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

    可以说，Proc.new将代码插入封闭方法，就像块一样。但Proc.new创建了一个对象，而block是对象的一部分。

    lambda和Proc.new之间还有另一个区别，那就是它们对(错误)参数的处理。lambda抱怨这一点，而Proc.new忽略了额外的参数或认为缺少参数为零。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    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"

    顺便说一句，Ruby1.8中的proc创建了一个lambda，而Ruby1.9+中的行为类似于Proc.new，这确实令人困惑。

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

    Proc::new may be called without a block only within a method with an attached block, in which case that block is converted to the Proc object.

    这就是说，Proc.new允许链屈服方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    def m1
      yield 'Finally!' if block_given?
    end

    def m2
      m1 &Proc.new
    end

    m2 { |e| puts e }
    #? Finally!
    相关讨论

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

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

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

    值得强调的是，proc中的return从词汇封闭方法返回，即创建proc的方法，而不是调用proc的方法。这是Procs关闭属性的结果。因此以下代码不输出任何内容：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    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。正如查尔斯考德威尔在上面写的，它有一种哥特式的感觉。在我看来，return在一个在其词汇上下文中执行的块中是可以的，但在另一个上下文中执行的过程中使用时，它的直观性要差得多。

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

    相关讨论