Que signifie la carte(&:nom) signifie en Ruby?

Un autre cool abréviation, inconnu pour beaucoup, est

array.each(&method(:foo))

qui est une abréviation pour

array.each { |element| foo(element) }

En appelant method(:foo) nous avons pris un Method objet de self qui représente sa foo méthode, et a utilisé le & pour signifier qu'il a un to_proc méthode qui le convertit en un Proc.

Cela est très utile lorsque vous voulez faire les choses point-gratuit style. Un exemple est de vérifier s'il existe une chaîne dans un tableau qui est égal à la chaîne "foo". Il y a la méthode classique:

["bar", "baz", "foo"].any? { |str| str == "foo" }

Et il est le point moyen:

["bar", "baz", "foo"].any?(&"foo".method(:==))

Le moyen préféré doit être le plus lisible un.

Tout en notons aussi que les esperluette #to_proc la magie peut travailler avec n'importe quelle classe, et pas seulement un Symbole. De nombreux Rubyists choisir de définir #to_proc sur la classe Array:

class Array
  def to_proc
    proc { |receiver| receiver.send *self }
  end
end

# And then...

[ 'Hello', 'Goodbye' ].map &[ :+, ' world!' ]
#=> ["Hello world!", "Goodbye world!"]

Esperluette & fonctionne en envoyant to_proc message sur son opérande, qui, dans le code ci-dessus, est de la classe Array. Et depuis que j'ai défini #to_proc méthode sur le Tableau, la ligne devient:

[ 'Hello', 'Goodbye' ].map { |receiver| receiver.send( :+, ' world!' ) }

tags.map(&:name)

est Le même que

tags.map{|tag| tag.name}

&:name utilise juste le symbole comme le nom de la méthode appelée.

Deux il se passe des choses ici, et il est important de comprendre à la fois.

Comme décrit dans les autres réponses, le Symbol#to_proc méthode est appelée.

Mais la raison to_proc est appelée sur le symbole, parce que c'est passé à map comme un bloc argument. Placer & en face d'un argument lors de l'appel de méthode causes qu'il soit passé de cette façon. Cela est vrai pour toute méthode Ruby, pas seulement map avec des symboles.

def some_method(*args, &block)
  puts "args: #{args.inspect}"
  puts "block: #{block.inspect}"
end

some_method(:whatever)
# args: [:whatever]
# block: nil

some_method(&:whatever)
# args: []
# block: #<Proc:0x007fd23d010da8>

some_method(&"whatever")
# TypeError: wrong argument type String (expected Proc)
# (String doesn't respond to #to_proc)

La Symbol est converti en Proc parce qu'il est transmis sous la forme d'un bloc. On peut montrer cela en essayant de faire passer un proc à .map sans l'esperluette:

arr = %w(apple banana)
reverse_upcase = proc { |i| i.reverse.upcase }
reverse_upcase.is_a?(Proc)
=> true

arr.map(reverse_upcase)
# ArgumentError: wrong number of arguments (1 for 0)
# (map expects 0 positional arguments and one block argument)

arr.map(&reverse_upcase)
=> ["ELPPA", "ANANAB"]

Même si elle n'a pas besoin d'être converti, la méthode ne savent pas comment l'utiliser car il s'attend à un bloc argument. En passant dessus avec & donne .map le bloc qu'il attend.

Bien que nous avons beaucoup de réponses déjà, en regardant à travers un point de vue de débutant, je tiens à ajouter les informations supplémentaires suivantes:

Que signifie la carte(&:nom) signifie en Ruby?

Cela signifie, que vous êtes de passage à une autre méthode en paramètre à la fonction map.
(En réalité, vous êtes le passage d'un symbole qui est converti en un proc. Mais ce n'est pas important dans ce cas particulier).

Ce qui est important, c'est que vous avez un method nommé name qui sera utilisé par la méthode map comme argument au lieu de la traditionnelle block style.

Ici :name est le symbole du point de la méthode name de la balise object.
Quand on passe &:name à map, elle traitera de name comme un proc objet.
Pour faire court, tags.map(&:name) actes comme:

tags.map do |tag|
  tag.name
end

Fondamentalement exécuter l'appel de la méthode tag.name sur chacune des étiquettes dans le tableau.

C'est une forme simplifiée de rubis de sténographie.