Ruby中用于＆procs和调用方法的目的＆（＆符号）

Question

我注意到很多处理Ruby Procs的例子中都有以下&符号。

# Ruby Example 
shout = Proc.new { puts 'Yolo!' } 

def shout_n_times(n, &callback) 
    n.times do 
    callback.call 
    end 
end 

shout_n_times(3, &shout) 
# prints 'Yolo!' 3 times 

我的问题是什么&符号背后的功能目的是什么？看来，如果我写完全相同的代码，而无需&，它按预期工作：

# Same code as previous without & 
shout = Proc.new { puts 'Yolo!' } 

def shout_n_times(n, callback) 
    n.times do 
    callback.call 
    end 
end 

shout_n_times(3, shout) 
# prints 'Yolo!' 3 times 

Answer 1

This article提供了一个很好的概述的差异。

为了总结文章，Ruby允许隐式和显式块。而且，Ruby有block，proc和lambda。

当你调用

def foo(block) 
end 

block是方法的只是一个简单的说法。参数在变量block中被引用，并且您如何与它进行交互取决于您传递的对象的类型。

def foo(one, block, two) 
    p one 
    p block.call 
    p two 
end 

foo(1, 2, 3) 
1 
NoMethodError: undefined method `call' for 2:Fixnum 
    from (irb):3:in `foo' 
    from (irb):6 
    from /Users/weppos/.rvm/rubies/ruby-2.1.5/bin/irb:11:in `<main>' 

foo(1, Proc.new { 1 + 1 }, 3) 
1 
2 
3 

但是，当你在方法定义使用符号&，块总是有不同的含义。你是明确定义一个方法来接受一个块。而其他规则将适用（例如每个方法不超过一个块）。

def foo(one, two, &block) 
    p one 
    p block.call 
    p two 
end 

首先，作为一个块，方法签名现在接受“两个参数和一个块”，而不是“三个参数”。

foo(1, 2, Proc.new { "from the proc" }) 
ArgumentError: wrong number of arguments (3 for 2) 
    from (irb):7:in `foo' 
    from (irb):12 
    from /Users/weppos/.rvm/rubies/ruby-2.1.5/bin/irb:11:in `<main>' 

这意味着，你必须强制第三个参数是传递参数与和符号的块。

foo(1, 2, &Proc.new { "from the proc" }) 
1 
"from the proc" 
2 

但是，这是一种非常不常见的语法。在Ruby中，与块的方法是使用{}

foo(1, 2) { "from the block" } 
1 
"from the block" 
2 

或do end一般调用。

foo(1, 2) do 
    "from the block" 
end 
1 
"from the block" 
2 

让我们跳回到方法定义。我之前提到过，下面的代码是显式模块声明。

def foo(one, two, &block) 
    block.call 
end 

方法可以隐式接受一个块。用yield调用隐式块。

def foo(one, two) 
    p yield 
end 

foo(1, 2) { "from the block" } 

您可以检查块是使用block_given?

def foo(one, two) 
    if block_given? 
    p yield 
    else 
    p "No block given" 
    end 
end 

foo(1, 2) { "from the block" } 
=> "from the block" 

foo(1, 2) 
=> "No block given" 

，如果你申报“块”作为一个简单的参数（因此无符号），这些块相关的功能将不可用过去了，因为这只是一个非常方法的论点。

Answer 2

那么，当你有一个块，如果块之前申请&，它成为Proc对象，反之亦然。

_unary &_：它与转换块之间的东西有关。如果你没有采取任何其他措施，请记住，当你在Ruby中看到一个单一的“&”时，你正在考虑把某些东西变成块，或者把某个东西变成块。

在第一个示例中，在此行shout_n_times(3, &shout)中，您正在将shoot变量引用的Proc对象转换为block。然后在方法参数列表中，将其转换回Proc对象。

在你的第二个例子中，它起作用，因为你直接传递一个Proc对象作为方法参数，然后调用#call就可以了。

Answer 3

不同的是，在你的第一个例子：

# Ruby Example 
shout = Proc.new { puts 'Yolo!' } 

def shout_n_times(n, &callback) 
    n.times do 
    callback.call 
    end 
end 

shout_n_times(3, &shout) 

...您的方法调用语法允许改写这样的方法定义：

shout = Proc.new { puts 'Yolo!' } 

def shout_n_times(n) 
    n.times do 
    yield 
    end 
end 

shout_n_times(3, &shout) 

--output:-- 
Yolo! 
Yolo! 
Yolo! 

这两句话：

shout = Proc.new { puts 'Yolo!' } 
... 
shout_n_times(3, &shout) 

...相当于：

shout_n_times(3) do 
    puts 'Yolo!' 
end 

与写作产量（）shout_n_times（）的方法定义内调用的方法调用后指定的块：

method call +--start of block specified after the method call 
     |   |  
     V   V 
shout_n_times(3) do 
    puts 'Yolo!' 
end 
^ 
| 
+--end of block 

你看，一块是一样的方法，和块作为方法调用中不可见的参数传递后，写入该块。在方法定义中，编写方法定义的人可以使用yield（）来执行块。 Ruby的块只不过是一种特殊的语法，它允许你将一个方法作为参数传递给另一个方法。

Answer 4

作为补充，我自己记住&作为block和Proc之间的转换符号。

要转换block到Proc

def foo(&p) 
    puts p.class 
end 

foo {} # => Proc 

要将Proc转换为block

def bar 
    yield "hello" 
end 
p = Proc.new {|a| puts a } 

bar &p # => hello