Differenza tra map e map!

Salve a tutti!
Nella mia domanda precedente sulla diff tra’ p e puts prendevo come
esempio il seguente codice:

b = [10,12,13,15]
b.map { |i| i*2}
puts b

=>10
=>12
=>13
=>15

aspettandomi poi che avrebbe stampato i valori dell’array moltiplicati
per due,come da suggerimento del testo che sto’ studiando.
Cosi’ non avviene e per ottenere il risultato voluto devo sostituire map
con map! Questo metodo, lo stesso libro lo differenzia dal precedente
dicendo che e’ distruttivo. Ora due domande:
cosa significa distruttivo ( cioe’ in che senso )? e perche’quel
risultato?
Grazie per le eventuali risposte.

map! è distruttivo nel senso che modifica i valori dell’array che chiama
map!

se fai
c=b.map{|i| i*2}
c conterrà i valori che ti aspetti; b invece rimane invariato.

È buona usanza evitare le varianti distruttivi (continua a leggere e te
lo spiegeranno per bene perché!)

:slight_smile:

David wrote:

map! � distruttivo nel senso che modifica i valori dell’array che chiama
map!

Che modifica in che modo? Li cancella? O li modifica nel senso che
voglio io?
Non capisco!!

se fai
c=b.map{|i| i*2}
c conterr� i valori che ti aspetti; b invece rimane invariato.

� buona usanza evitare le varianti distruttivi (continua a leggere e te
lo spiegeranno per bene perch�!)

:slight_smile:

Grazie!!
Ho capito allora dove sbagliavo. Io stampavo b , ma b rimane invariato.
:slight_smile:
Devo assegnare c a b e poi stampare c.

On Mon, 11 Jun 2007 11:23:30 +0200, Giovanni C. wrote:

David wrote:

map! � distruttivo nel senso che modifica i valori dell’array che chiama
map!

Che modifica in che modo? Li cancella? O li modifica nel senso che
voglio io?
Non capisco!!

He he! Sta lì bello! Passi un block a map(), quindi sei totalmente in
controllo tu di quello che succede. L’unica cosa certa è che per ogni
elemento di b verrà eseguito il codice nel block che genera un elemento
del nuovo array. Se hai chiamato map! il nuovo valore andrà a sostituire
l’elemento corrispondente di b (array di input), altrimenti, con map(),
riempie l’array nuovo che sarà restituito dopo la fine della chiamata (e
che puoi assegnare, ad esempio a c, o usare per nuove chiamate o quello
che pare a te).

domanda inerente all’argomento…
ma i metodi distruttivi ritornano nil o l’oggetto sul quale ho invocato
il
metodo?

b = a.map! { … }

b == a o b == nil ???

Il 11/06/07, David [email protected] ha scritto:

Il 11/06/07, tarini[email protected] ha scritto:

domanda inerente all’argomento…
ma i metodi distruttivi ritornano nil o l’oggetto sul quale ho invocato il
metodo?

b = a.map! { … }

b == a o b == nil ???

Dalla documentazione del core, la prima è corretta, b == a. Ma credo
basti un veloce test con irb per la conferma! :slight_smile:

Il 11/06/07, Giovanni C.[email protected] ha scritto:

Quindi mi sembra che b=!a anche se mi sembra strano ( che scopo avrebbe
? :slight_smile: ),o mi sbaglio?

Strano, perché, guardando su http://www.ruby-doc.org/core/, il metodo
map! dell’oggetto Array è così definito:

array.map! {|item| block } → array

e l’implementazione è la seguente:

static VALUE
rb_ary_collect_bang(ary)
VALUE ary;
{
long i;

rb_ary_modify(ary);
for (i = 0; i < RARRAY(ary)->len; i++) {
    rb_ary_store(ary, i, rb_yield(RARRAY(ary)->ptr[i]));
}
return ary;

}

dove, da quel che ho capito, restituisce l’array modificato, anche se
non ne sono sicuro al 100%.

Marco Dalla S. wrote:

Il 11/06/07, tarini[email protected] ha scritto:

domanda inerente all’argomento…
ma i metodi distruttivi ritornano nil o l’oggetto sul quale ho invocato il
metodo?

b = a.map! { … }

b == a o b == nil ???

Dalla documentazione del core, la prima � corretta, b == a. Ma credo
basti un veloce test con irb per la conferma! :slight_smile:

Se eseguo il codice seguente:
… inizio …
b = [10,12,13,15]
m=b.map! { |i| i*2}
puts m
… fine …
in fxri ( da console ,quindi) il risultato e’:
=> [10, 12, 13, 15]
=> [20, 24, 26, 30]
20
24
26
30
=> nil
mentre eseguita in NetBeans 6 il risultato e’:
20
24
26
30

Quindi mi sembra che b=!a anche se mi sembra strano ( che scopo avrebbe
? :slight_smile: ),o mi sbaglio?

ciao a tutti,

On 6/11/07, Giovanni C. [email protected] wrote:

Quindi mi sembra che b=!a anche se mi sembra strano ( che scopo avrebbe
? :slight_smile: ),o mi sbaglio?

non mi pare. tu stampi solo m
quindi non vedi che b e’ cambiato
(a non ho capito cosa sia).

il nil, invece e’ il risultato di puts.

Ma due prove in IRB? Non li vogliamo fare per non rovinare la
conversazione o non siamo sicuri di come fare?

bugant wrote:

ciao a tutti,

On 6/11/07, Giovanni C. [email protected] wrote:

Quindi mi sembra che b=!a anche se mi sembra strano ( che scopo avrebbe
? :slight_smile: ),o mi sbaglio?

non mi pare. tu stampi solo m
quindi non vedi che b e’ cambiato
(a non ho capito cosa sia).

il nil, invece e’ il risultato di puts.

Posted by tarini (Guest)
on 11.06.2007 11:53
(Received via mailing list)

domanda inerente all’argomento…
ma i metodi distruttivi ritornano nil o l’oggetto sul quale ho invocato
il
metodo?

b = a.map! { … }

b == a o b == nil ???

E’ per questo che compare a.
Ma m non e’ b a cui e’ applicato qualcosa? Quindi dovrebbe essere
diverso.
nil e’ il risultato di puts? Ma il risultato di puts non
e’20,24,26…ecc ?
Aiuto!!! Non ci sto’ capendo piu’ nulla … :slight_smile:

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs