Differenza tra mappa e raccolta in Ruby?

Ho cercato su Google questo e ho avuto opinioni discordanti / contraddittorie - c'è davvero differenza tra fare un mape fare collectun array su Ruby / Rails?

I documenti non sembrano suggerire alcuno, ma ci sono forse differenze nel metodo o nelle prestazioni?

Non c'è differenza, infatti mapè implementato in C come rb_ary_collecte enum_collect(es. C'è una differenza tra mapsu un array e su qualsiasi altro enum, ma nessuna differenza tra mape collect).

Perché entrambi maped collectesistono in Ruby? La mapfunzione ha molte convenzioni di denominazione in diverse lingue. Wikipedia fornisce una panoramica :

La funzione di mappa ha avuto origine in linguaggi di programmazione funzionale ma oggi è supportata (o può essere definita) anche in molti linguaggi procedurali, orientati agli oggetti e multi-paradigma: nella libreria di modelli standard di C ++, è chiamata transform, in C # (3.0) Libreria LINQ, viene fornita come metodo di estensione chiamato Select. Map è anche un'operazione di uso frequente in linguaggi di alto livello come Perl, Python e Ruby; l'operazione viene chiamata mapin tutte e tre queste lingue. Un collectalias per la mappa è fornito anche in Ruby (da Smalltalk) [enfasi mia]. Common Lisp fornisce una famiglia di funzioni simili a mappe; viene chiamato quello corrispondente al comportamento qui descritto mapcar(-car che indica l'accesso usando l'operazione CAR).

Ruby fornisce un alias ai programmatori del mondo Smalltalk per sentirsi più a casa.

Perché esiste un'implementazione diversa per array ed enum? Un enum è una struttura di iterazione generalizzata, il che significa che non c'è modo in cui Ruby possa prevedere quale possa essere il prossimo elemento (puoi definire enumerazioni infinite, vedi Prime per un esempio). Pertanto deve chiamare una funzione per ottenere ogni elemento successivo (in genere questo sarà il eachmetodo).

Gli array sono la raccolta più comune, quindi è ragionevole ottimizzarne le prestazioni. Dato che Ruby sa molto su come funzionano le matrici, non deve chiamare eachma può usare solo una semplice manipolazione del puntatore che è significativamente più veloce.

Ottimizzazioni simili esistono per numerosi metodi di array come zipo count.

Mi è stato detto che sono uguali.

In realtà sono documentati nello stesso posto sotto ruby-doc.org:

http://www.ruby-doc.org/core/classes/Array.html#M000249

• ary.collect {| item | blocco} → new_ary
• ary.map {| item | blocco} → new_ary
• ary.collect → an_enumerator
• ary.map → an_enumerator

Invoca il blocco una volta per ogni elemento di sé. Crea un nuovo array contenente i valori restituiti dal blocco. Vedi anche Enumerable # collect.
Se non viene fornito alcun blocco, viene invece restituito un enumeratore.

a = [ "a", "b", "c", "d" ]
a.collect {|x| x + "!" }   #=> ["a!", "b!", "c!", "d!"]
a                          #=> ["a", "b", "c", "d"]

Ho fatto un test di riferimento per provare a rispondere a questa domanda, quindi ho trovato questo post, quindi ecco i miei risultati (che differiscono leggermente dalle altre risposte)

Ecco il codice di riferimento:

require 'benchmark'

h = { abc: 'hello', 'another_key' => 123, 4567 => 'third' }
a = 1..10
many = 500_000

Benchmark.bm do |b|
  GC.start

  b.report("hash keys collect") do
    many.times do
      h.keys.collect(&:to_s)
    end
  end

  GC.start

  b.report("hash keys map") do
    many.times do
      h.keys.map(&:to_s)
    end
  end

  GC.start

  b.report("array collect") do
    many.times do
      a.collect(&:to_s)
    end
  end

  GC.start

  b.report("array map") do
    many.times do
      a.map(&:to_s)
    end
  end
end

E i risultati che ho ottenuto sono stati:

                   user     system      total        real
hash keys collect  0.540000   0.000000   0.540000 (  0.570994)
hash keys map      0.500000   0.010000   0.510000 (  0.517126)
array collect      1.670000   0.020000   1.690000 (  1.731233)
array map          1.680000   0.020000   1.700000 (  1.744398) 

Forse un alias non è gratuito?

I metodi collecte collect!sono alias di mape map!, quindi possono essere usati in modo intercambiabile. Ecco un modo semplice per confermare che:

Array.instance_method(:map) == Array.instance_method(:collect)
 => true

Ruby alias il metodo Array # map to Array # collect; possono essere usati in modo intercambiabile. (Ruby Monk)

In altre parole, lo stesso codice sorgente:

               static VALUE
rb_ary_collect(VALUE ary)
{
long i;
VALUE collect;

RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);
collect = rb_ary_new2(RARRAY_LEN(ary));
for (i = 0; i < RARRAY_LEN(ary); i++) {
    rb_ary_push(collect, rb_yield(RARRAY_AREF(ary, i)));
}
return collect;
}

http://ruby-doc.org/core-2.2.0/Array.html#method-i-map