There's a few moving pieces here, but the name for what's going on is the Symbol#to_proc
conversion. This is part of Ruby 1.9 and up, and is also available if you use later-ish versions of Rails.
First, in Ruby, :foo
means "the symbol foo
", so it's actually two separate operators you're looking at, not one big &:
operator.
When you say foo.map(&bar)
, you're telling Ruby, "send a message to the foo
object to invoke the map
method, with a block I already defined called bar
". If bar
is not already a Proc
object, Ruby will try to make it one.
Here, we don't actually pass a block, but instead a symbol called bar
. Because we have an implicit to_proc
conversion available on Symbol
, Ruby sees that and uses it. It turns out that this conversion looks like this:
def to_proc
proc { |obj, *args| obj.send(self, *args) }
end
This makes a proc
which invokes the method with the same name as the symbol. Putting it all together, using your original example:
array.map(&:to_i)
This invokes .map
on array, and for each element in the array, returns the result of calling to_i
on that element.
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…