Cosa significa map (&: name) in Ruby?

Ho trovato questo codice in un RailsCast :

def tag_names
  @tag_names || tags.map(&:name).join(' ')
end

Cosa significa " (&:name)in" map(&:name)?

È una scorciatoia per tags.map(&:name.to_proc).join(' ')

Se fooè un oggetto con un to_procmetodo, puoi passarlo a un metodo as &foo, che lo chiamerà foo.to_proce lo utilizzerà come blocco del metodo.

Il Symbol#to_procmetodo è stato originariamente aggiunto da ActiveSupport ma è stato integrato in Ruby 1.8.7. Questa è la sua implementazione:

class Symbol
  def to_proc
    Proc.new do |obj, *args|
      obj.send self, *args
    end
  end
end

Un'altra scorciatoia interessante, sconosciuta a molti, è

array.each(&method(:foo))

che è una scorciatoia per

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

Chiamando method(:foo)abbiamo preso un Methodoggetto selfche rappresenta il suo foometodo e abbiamo usato il &per indicare che ha un to_proc metodo che lo converte in a Proc.

Questo è molto utile quando vuoi fare cose senza stile. Un esempio è verificare se esiste una stringa in un array uguale alla stringa "foo". C'è il modo convenzionale:

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

E c'è il modo senza punti:

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

Il modo preferito dovrebbe essere quello più leggibile.

È equivalente a

def tag_names
  @tag_names || tags.map { |tag| tag.name }.join(' ')
end

Mentre notiamo anche che la #to_procmagia e commerciale può funzionare con qualsiasi classe, non solo con Symbol. Molti rubyisti scelgono di definire #to_procsulla classe Array:

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

# And then...

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

La e commerciale &funziona inviando un to_procmessaggio sul suo operando, che, nel codice sopra, è di classe Array. E poiché ho definito il #to_procmetodo su Array, la linea diventa:

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

È una scorciatoia per tags.map { |tag| tag.name }.join(' ')

tags.map(&:name)

equivale a

tags.map{|tag| tag.name}

&:name usa solo il simbolo come nome del metodo da chiamare.

La risposta di Josh Lee è quasi corretta, tranne per il fatto che il codice Ruby equivalente avrebbe dovuto essere il seguente.

class Symbol
  def to_proc
    Proc.new do |receiver|
      receiver.send self
    end
  end
end

non

class Symbol
  def to_proc
    Proc.new do |obj, *args|
      obj.send self, *args
    end
  end
end

Con questo codice, quando print [[1,'a'],[2,'b'],[3,'c']].map(&:first)viene eseguito, Ruby divide il primo input [1,'a']in 1 e 'a' per dare obj1 e args*'a' per causare un errore poiché l'oggetto Fixnum 1 non ha il metodo self (che è: primo).

Quando [[1,'a'],[2,'b'],[3,'c']].map(&:first)viene eseguito;

1. :firstè un oggetto Symbol, quindi quando &:firstviene assegnato a un metodo map come parametro, viene richiamato Symbol # to_proc.

2. map invia il messaggio di chiamata a: first.to_proc con il parametro [1,'a'], ad es., :first.to_proc.call([1,'a'])viene eseguito.

3. La procedura to_proc nella classe Symbol invia un messaggio di invio a un oggetto array ( [1,'a']) con il parametro (: primo), ad es. [1,'a'].send(:first)viene eseguito.

4. scorre il resto degli elementi [[1,'a'],[2,'b'],[3,'c']]nell'oggetto.

È lo stesso dell'esecuzione [[1,'a'],[2,'b'],[3,'c']].map(|e| e.first)dell'espressione.

Qui stanno accadendo due cose ed è importante capirle entrambe.

Come descritto in altre risposte, Symbol#to_procviene chiamato il metodo.

Ma la ragione per cui to_procviene chiamato il simbolo è perché viene passato mapcome argomento a blocchi. Posizionare &davanti a un argomento in una chiamata di metodo fa sì che venga passato in questo modo. Questo vale per qualsiasi metodo Ruby, non solo mapcon i simboli.

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 Symbolviene convertito in un Procperché è passato come un blocco. Possiamo dimostrarlo provando a passare un proc a .mapsenza la e commerciale:

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"]

Anche se non ha bisogno di essere convertito, il metodo non saprà come usarlo perché si aspetta un argomento a blocchi. Passandolo con si &ottiene .mapil blocco che si aspetta.

(&: name) è l'abbreviazione di (&: name.to_proc) è uguale a tags.map{ |t| t.name }.join(' ')

to_proc è effettivamente implementato in C

mappa (e: nome) accetta un oggetto enumerabile (tag nel tuo caso) ed esegue il metodo name per ogni elemento / tag, producendo ogni valore restituito dal metodo.

È una scorciatoia per

array.map { |element| element.name }

che restituisce la matrice dei nomi degli elementi (tag)

Fondamentalmente esegue la chiamata del metodo tag.name su ogni tag dell'array.

È una scorciatoia rubino semplificata.

Anche se abbiamo già ottime risposte, guardando nella prospettiva di un principiante, vorrei aggiungere ulteriori informazioni:

Cosa significa map (&: name) in Ruby?

Questo significa che stai passando un altro metodo come parametro alla funzione mappa. (In realtà stai passando un simbolo che viene convertito in un proc. Ma questo non è così importante in questo caso particolare).

L'importante è che tu abbia un methodnome nameche verrà usato dal metodo map come argomento invece che dallo blockstile tradizionale .

Innanzitutto, &:nameè una scorciatoia per &:name.to_proc, dove :name.to_procrestituisce un Proc(qualcosa di simile, ma non identico a un lambda) che quando chiamato con un oggetto come (primo) argomento, chiama ilname metodo su quell'oggetto.

In secondo luogo, mentre &in def foo(&block) ... endconverte un blocco passato a fooa Proc, fa il contrario quando applicato a a Proc.

Pertanto, &:name.to_procè un blocco che accetta un oggetto come argomento e chiama il namemetodo su di esso, ad es { |o| o.name }.

Ecco :nameil simbolo che indica il metodo namedell'oggetto tag. Quando passiamo &:namea map, verrà trattato namecome un oggetto proc. In breve, tags.map(&:name)agisce come:

tags.map do |tag|
  tag.name
end

significa

array.each(&:to_sym.to_proc)

È lo stesso di seguito:

def tag_names
  if @tag_names
    @tag_names
  else
    tags.map{ |t| t.name }.join(' ')
end