blocks|key|1245546|text|block只是一个局部变量，&block是对传递给该方法的块的引用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1245547|def+foo(block+=+nil)
++p+block
end

foo+#+=>+nil
foo("test")+#+=>+test
foo+{+puts+"this+block+will+not+be+called"+}+#+=>+nil

def+foo(&block)
++p+block
end

foo+#+=>+nil
foo("test")+#+=>+ArgumentError:+wrong+number+of+arguments+(1+for+0)
foo+{+puts+"This+block+won't+get+called,+but+you'll+se+it+referenced+as+a+proc."+}
#+=>+#<Proc:0x0000000100124ea8@untitled:20>|code-block|syntax|javascript|1245548|还可以在调用方法时使用&block将proc作为块传递给方法，这样就可以像使用块一样使用procs。|1245549|my_proc+=+proc+{%7Ci%7C+i.upcase+}

p+["foo",+"bar",+"baz"].map(&my_proc)
#+=>+["FOO",+"BAR",+"BAZ"]

p+["foo",+"bar",+"baz"].map(my_proc)
#+=>+ArgumentError:+wrong+number+of+arguments+(1+for+0)|1245550|变量名block并没有什么特别的含义。如果你愿意，你可以使用&strawberries，“&”是这里的关键。|1245551|您可能会发现this+article很有帮助。|1245552|entityMap|0|LINK|mutability|MUTABLE|url|http://augustl.com/blog/2008/procs_blocks_and_anonymous_functions^0|0|5|E|6|0|0|B|6|0|0|3|5|U|D|0|6|C|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1F|8|@]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|S|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

<code>block</code> is just a local variable, <code>&amp;block</code> is a reference to the block passed to the method.

<pre><code>def foo(block = nil)
 p block
end

foo # =&gt; nil
foo("test") # =&gt; test
foo { puts "this block will not be called" } # =&gt; nil

def foo(&amp;block)
 p block
end

foo # =&gt; nil
foo("test") # =&gt; ArgumentError: wrong number of arguments (1 for 0)
foo { puts "This block won't get called, but you'll se it referenced as a proc." }
# =&gt; #&lt;Proc:0x0000000100124ea8@untitled:20&gt;
</code></pre>

You can also use <code>&amp;block</code> when calling methods to pass a proc as a block to a method, so that you can use procs just as you use blocks.

<pre><code>my_proc = proc {|i| i.upcase }

p ["foo", "bar", "baz"].map(&amp;my_proc)
# =&gt; ["FOO", "BAR", "BAZ"]

p ["foo", "bar", "baz"].map(my_proc)
# =&gt; ArgumentError: wrong number of arguments (1 for 0)
</code></pre>

The variable name <code>block</code> doesn't mean anything special. You can use <code>&amp;strawberries</code> if you like, the ampersand is the key here.

You might find <a href="http://augustl.com/blog/2008/procs_blocks_and_anonymous_functions" rel="noreferrer">this article</a> helpful.

blocks|key|1245602|text|在参数列表中，&whatever获取传递给方法的块，并将其包装在Proc对象中。Proc存储在一个名为whatever的变量中(当然，它可以是您在与号后面键入的任何名称-通常是“块”)。在方法调用之后，&whatever语法将进程转换为块。所以如果你像这样定义一个方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1245603|def+thing(&block)
++thing2+&block
end|code-block|syntax|javascript|1245604|您正在定义一个方法，该方法接受一个块，然后使用该块调用另一个方法。|1245605|entityMap^0|7|9|1F|8|2T|9|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

In an argument list, <code>&amp;whatever</code> takes the block that was passed to the method and wraps it in a Proc object. The Proc is stored in a variable called <code>whatever</code> (where that can be whatever name you typed after the ampersand, of course — usually it's "block"). After a method call, the <code>&amp;whatever</code> syntax turns a Proc into a block. So if you define a method like so:

<pre><code>def thing(&amp;block)
 thing2 &amp;block
end
</code></pre>

You're defining a method that takes a block and then calls another method with that block.

blocks|key|1460362|text|如果不设置&+before块，Ruby将无法识别它与传递给函数的“块”的关系。这里有一些例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1460363|def+f(x,+block);+end
f(3)+{+2%2B2+}++++#+gives+an+error,+because+"block"+is+a
++++++++++++++++#+regular+second+argument+(which+is+missing)

def+g(x,+&block);+end
g(3)+{+2%2B2+}++++#+legal

def+h(x);+end
h(3)+{+2%2B2+}++++#+legal|code-block|syntax|javascript|1460364|为了以后在函数中使用：|1460365|def+x(&block)+++#+x+is+a+0+param+function
++y(block)++++++#+y+is+a+1+param+function+(taking+one+"Proc")
++z(&block)+++++#+z+is+a+0+param+function+(like+x)+with+the+block+x+received
end|1460366|所以，如果你调用z(&block)，它是(差一点！)与调用z+{+yield+}相同:只需将块传递给下一个函数。|offset|length|style|CODE|1460367|entityMap^0|0|0|0|0|8|9|T|B|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

If you don't set the &amp; before block, Ruby won't recognize it's relationship to the "block" you pass to the function. Here some examples.

<pre><code>def f(x, block); end
f(3) { 2+2 } # gives an error, because "block" is a
 # regular second argument (which is missing)

def g(x, &amp;block); end
g(3) { 2+2 } # legal

def h(x); end
h(3) { 2+2 } # legal
</code></pre>

For later use in a function:

<pre><code>def x(&amp;block) # x is a 0 param function
 y(block) # y is a 1 param function (taking one "Proc")
 z(&amp;block) # z is a 0 param function (like x) with the block x received
end
</code></pre>

So, if you call <code>z(&amp;block)</code> it's (nearly!!) the same as calling <code>z { yield }</code>: You just pass the block to the next function.

Why sometimes I should use block and other times &amp;block inside functions that accept blocks?

Difference between block and &block in Ruby

为什么有时我应该在接受块的函数中使用block和其他时候&block？

问Ruby中block与&block的区别
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby中block与&block的区别EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby中block与&block的区别
EN