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.