Copiare un valore, copiare un riferimento
Copiare un valore, copiare un riferimento
Un programma tiene le temperature della settimana e ne vuole una versione corretta, con un sensore ricalibrato di un grado:
const misurate: number[] = [18, 21, 19, 23];
const corrette = misurate;
for (let i = 0; i < corrette.length; i++) {
corrette[i] = corrette[i] - 1;
}
console.log(corrette); // [ 17, 20, 18, 22 ]
console.log(misurate); // [ 17, 20, 18, 22 ] anche le misure originali sono cambiate
L'idea era tenere le misure originali e lavorare su una copia. Invece le originali sono perse. Il compilatore non segnala niente, perché il codice è corretto dal punto di vista dei tipi. Il problema sta in cosa copia =.
= copia sempre il contenuto della cella
Nel modello della memoria del corso (vedi La memoria - celle e indirizzi) ogni variabile è una cella. L'assegnazione b = a fa sempre la stessa cosa: legge il contenuto della cella di a e lo scrive nella cella di b. Cosa si copia dipende da cosa c'è nella cella.
| Tipo | Cosa c'è nella cella | Cosa copia b = a |
|---|---|---|
number, string, boolean |
Il valore | Il valore: due copie indipendenti |
| Array, oggetti, istanze di classi | Il riferimento (→ indirizzo) | Il riferimento: due frecce verso la stessa cosa |
Nell'esempio iniziale, dopo const corrette = misurate:
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | misurate |
→ 500 |
| 101 | corrette |
→ 500 |
| 500 | [18, 21, 19, 23] |
C'è un array solo. Il ciclo segue la freccia di corrette e modifica l'array alla cella 500, che è anche l'array di misurate.
La copia con lo spread
Per avere un secondo array, indipendente, bisogna crearlo. Lo spread (...) prende gli elementi di un array e li mette, uno per uno, in un array nuovo:
const misurate: number[] = [18, 21, 19, 23];
const corrette: number[] = [...misurate];
for (let i = 0; i < corrette.length; i++) {
corrette[i] = corrette[i] - 1;
}
console.log(corrette); // [ 17, 20, 18, 22 ]
console.log(misurate); // [ 18, 21, 19, 23 ]
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | misurate |
→ 500 |
| 101 | corrette |
→ 600 |
| 500 | [18, 21, 19, 23] |
|
| 600 | [17, 20, 18, 22] |
Lo spread serve anche a unire due array, o ad aggiungere elementi mentre si copia:
const mattina: string[] = ["yoga", "corsa"];
const sera: string[] = ["nuoto"];
const giornata: string[] = [...mattina, ...sera]; // [ "yoga", "corsa", "nuoto" ]
const conRiposo: string[] = [...giornata, "stretching"]; // [ "yoga", "corsa", "nuoto", "stretching" ]
Senza spread si ottiene lo stesso risultato con un ciclo che fa push di ogni elemento in un array vuoto.
Confrontare due array
Anche === lavora sul contenuto delle celle. Con due array confronta le frecce, non gli elementi:
const a: number[] = [1, 2, 3];
const b: number[] = [1, 2, 3];
const c = a;
console.log(a === b); // false: stessi elementi, ma due array diversi (due indirizzi)
console.log(a === c); // true: stessa freccia, stesso array
Per sapere se due array hanno gli stessi elementi bisogna confrontarli elemento per elemento, con un ciclo. Una scorciatoia: trasformare tutti e due gli array in testo con JSON.stringify e confrontare i testi.
Quando condividere va bene
Due variabili sullo stesso array non sono sempre un errore. A volte è proprio quello che serve: un pezzo di programma aggiunge brani alla playlist, un altro li riproduce, e tutti e due devono vedere la stessa playlist. Il problema nasce quando la condivisione non è voluta. Prima di modificare un array chiedetevi: qualcun altro ha una freccia verso questo array? Se sì, e non deve vedere le modifiche, lavorate su una copia.
Una copia "di superficie"
Lo spread copia gli elementi uno per uno, con =. Se gli elementi sono numeri o stringhe, la copia è completa. Se gli elementi sono a loro volta array (o oggetti, che vedremo nella prossima giornata), lo spread copia le loro frecce, e i pezzi interni restano condivisi:
const settimane: number[][] = [[18, 21], [19, 23]];
const copia: number[][] = [...settimane];
copia[0].push(25);
console.log(settimane[0]); // [ 18, 21, 25 ] l'array interno è lo stesso
number[][] è un array di array di numeri. Si chiama copia superficiale (shallow copy): copia il primo livello, non quelli sotto. Con gli oggetti il problema compare molto più spesso.
Gli oggetti: stessa regola
Un oggetto, come un array, sta altrove in memoria, e la variabile contiene la sua freccia. Quindi = copia la freccia:
const profilo = { nome: "Ada", citta: "Torino", eta: 19 };
const altro = profilo;
altro.citta = "Bari";
console.log(profilo.citta); // Bari
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | profilo |
→ 500 |
| 101 | altro |
→ 500 |
| 500 | { nome: "Ada", citta: "Bari", eta: 19 } |
E === confronta le frecce:
const a = { nome: "Ada", eta: 19 };
const b = { nome: "Ada", eta: 19 };
console.log(a === b); // false: due oggetti, due indirizzi
Vale anche per le istanze delle classi: new crea un'istanza altrove e restituisce l'indirizzo, e da lì in poi ogni = copia quell'indirizzo.
Copiare un oggetto con lo spread
Per gli oggetti lo spread si scrive tra graffe. { ...profilo } crea un oggetto nuovo e ci copia, una per una, le proprietà di profilo:
const profilo = { nome: "Ada", citta: "Torino", eta: 19 };
const copia = { ...profilo };
copia.citta = "Bari";
console.log(profilo.citta); // Torino
console.log(copia.citta); // Bari
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | profilo |
→ 500 |
| 101 | copia |
→ 600 |
| 500 | { nome: "Ada", citta: "Torino", eta: 19 } |
|
| 600 | { nome: "Ada", citta: "Bari", eta: 19 } |
Dopo lo spread si possono scrivere proprietà che sostituiscono quelle copiate. È il modo più comune di fare "lo stesso oggetto, con una cosa cambiata", senza toccare l'originale:
const profilo = { nome: "Ada", citta: "Torino", eta: 19 };
const dopoIlCompleanno = { ...profilo, eta: 20 };
console.log(profilo.eta); // 19
console.log(dopoIlCompleanno.eta); // 20
L'ordine conta: le proprietà scritte dopo vincono. { eta: 20, ...profilo } darebbe di nuovo eta: 19, perché lo spread arriva dopo e sovrascrive.
Copia superficiale e copia profonda
Anche tra graffe lo spread fa una copia superficiale: le proprietà che sono array o oggetti restano condivise. Con gli oggetti succede in due modi.
Un array dentro un oggetto
type Iscritto = {
nome: string;
corsi: string[];
};
const ada: Iscritto = { nome: "Ada", corsi: ["pilates", "nuoto"] };
const grace: Iscritto = { ...ada, nome: "Grace" };
grace.corsi.push("boxe");
console.log(ada.corsi); // [ 'pilates', 'nuoto', 'boxe' ] Ada si ritrova iscritta a boxe
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | ada |
→ 500 |
| 101 | grace |
→ 600 |
| 500 | { nome: "Ada", corsi: → 700 } |
|
| 600 | { nome: "Grace", corsi: → 700 } |
|
| 700 | ["pilates", "nuoto", "boxe"] |
I due oggetti sono diversi (500 e 600), ma la proprietà corsi di tutti e due punta allo stesso array, il 700. Per separarli bisogna copiare anche l'array:
type Iscritto = {
nome: string;
corsi: string[];
};
const ada: Iscritto = { nome: "Ada", corsi: ["pilates", "nuoto"] };
const grace: Iscritto = { ...ada, nome: "Grace", corsi: [...ada.corsi] };
grace.corsi.push("boxe");
console.log(ada.corsi); // [ 'pilates', 'nuoto' ]
console.log(grace.corsi); // [ 'pilates', 'nuoto', 'boxe' ]
Oggetti dentro un array
Il caso opposto è altrettanto comune. Copiare con lo spread un array di oggetti crea un array nuovo, ma con dentro le frecce agli stessi oggetti:
type Brano = {
titolo: string;
ascolti: number;
};
const playlist: Brano[] = [
{ titolo: "Imagine", ascolti: 12 },
{ titolo: "Yesterday", ascolti: 7 },
];
const copia: Brano[] = [...playlist];
copia.push({ titolo: "Wonderwall", ascolti: 0 });
copia[0].ascolti = 99;
console.log(playlist.length); // 2: l'array è davvero un altro
console.log(playlist[0].ascolti); // 99: ma il primo brano è lo stesso oggetto
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | playlist |
→ 500 |
| 101 | copia |
→ 600 |
| 500 | [→ 510, → 520] |
|
| 600 | [→ 510, → 520, → 530] |
|
| 510 | { titolo: "Imagine", ascolti: 99 } |
|
| 520 | { titolo: "Yesterday", ascolti: 7 } |
|
| 530 | { titolo: "Wonderwall", ascolti: 0 } |
Aggiungere o togliere elementi tocca solo la copia. Modificare un elemento tocca l'oggetto condiviso. Per avere anche brani indipendenti si copia ogni oggetto, con un ciclo:
type Brano = {
titolo: string;
ascolti: number;
};
const playlist: Brano[] = [
{ titolo: "Imagine", ascolti: 12 },
{ titolo: "Yesterday", ascolti: 7 },
];
const copia: Brano[] = [];
for (const brano of playlist) {
copia.push({ ...brano });
}
copia[0].ascolti = 99;
console.log(playlist[0].ascolti); // 12
La copia profonda
Una copia che duplica tutti i livelli, oggetti dentro array dentro oggetti, si chiama copia profonda (deep copy). Farla a mano, livello per livello, è noioso e facile da sbagliare. JavaScript ha una funzione già pronta, structuredClone:
type Iscritto = {
nome: string;
corsi: string[];
};
const ada: Iscritto = { nome: "Ada", corsi: ["pilates", "nuoto"] };
const copia: Iscritto = structuredClone(ada);
copia.corsi.push("boxe");
console.log(ada.corsi); // [ 'pilates', 'nuoto' ]
Funziona bene con i dati semplici: oggetti letterali, array, numeri, stringhe. Con le istanze di una classe invece produce un oggetto con le stesse proprietà ma senza i metodi, quindi lì non è la scelta giusta.
Quale usare? Lo spread quando gli oggetti hanno un livello solo, o quando volete condividere apposta i livelli sotto. structuredClone quando dovete modificare liberamente una copia di dati annidati.
Oggetti passati alle funzioni
Un parametro riceve una copia di quello che c'è nella cella dell'argomento. Per un oggetto è una copia della freccia, quindi la funzione lavora sull'oggetto di chi l'ha chiamata:
type Termostato = {
stanza: string;
gradi: number;
};
function modalitaNotte(t: Termostato): void {
t.gradi = t.gradi - 3;
}
const salotto: Termostato = { stanza: "salotto", gradi: 21 };
modalitaNotte(salotto);
console.log(salotto.gradi); // 18
A volte è quello che volete: la funzione si chiama modalitaNotte e deve cambiare il termostato. Altre volte chi chiama la funzione non se lo aspetta. Una funzione che deve solo calcolare un risultato può restituire un oggetto nuovo e lasciare stare quello ricevuto:
type Termostato = {
stanza: string;
gradi: number;
};
function versioneNotte(t: Termostato): Termostato {
return { ...t, gradi: t.gradi - 3 };
}
const salotto: Termostato = { stanza: "salotto", gradi: 21 };
const salottoNotte: Termostato = versioneNotte(salotto);
console.log(salotto.gradi); // 21
console.log(salottoNotte.gradi); // 18
Tutte e due le forme sono corrette. Conta che il nome e il tipo di ritorno dicano quale delle due fa la funzione: void e un verbo (modalitaNotte, rinnova, aggiungi) fanno pensare a una modifica; un tipo di ritorno e un nome come versioneNotte fanno pensare a un oggetto nuovo.
Come per gli array, invece, assegnare al parametro un oggetto nuovo (t = { ... }) cambia solo la freccia nella cella del parametro. Chi ha chiamato la funzione non vede niente.
In breve
| Codice | Cosa ottenete |
|---|---|
const b = a |
Due frecce verso lo stesso array o oggetto |
[...a], { ...a } |
Un array o un oggetto nuovo; quello che c'è dentro, se è un array o un oggetto, resta condiviso |
{ ...a, x: 1 } |
Un oggetto nuovo con una proprietà cambiata |
structuredClone(a) |
Una copia nuova a tutti i livelli (solo per dati semplici, non per istanze di classi) |
funzione(a) |
Il parametro riceve la freccia: la funzione può modificare a |
Se un programma modifica qualcosa che non doveva, disegnate le frecce: quasi sempre due di loro puntano alla stessa cella.