02 - Funzioni e oggetti
Funzioni e oggetti
1. Funzioni
Perché servono
Nella prima giornata i programmi erano una fila di istruzioni, dall'alto verso il basso. Funziona finché il programma è corto. Poi capita di dover fare la stessa cosa in tre punti diversi:
const votiMatematica: number[] = [7, 8, 6];
let totaleMatematica: number = 0;
for (const v of votiMatematica) {
totaleMatematica += v;
}
console.log(totaleMatematica / votiMatematica.length);
const votiStoria: number[] = [9, 7];
let totaleStoria: number = 0;
for (const v of votiStoria) {
totaleStoria += v;
}
console.log(totaleStoria / votiStoria.length);
Il calcolo della media è scritto due volte, identico. Se ci accorgete di un errore, va corretto in due punti, e prima o poi uno lo dimenticate. Una funzione è un blocco di codice con un nome: lo scrivete una volta e lo usate tutte le volte che serve.
function media(voti: number[]): number {
let totale: number = 0;
for (const v of voti) {
totale += v;
}
return totale / voti.length;
}
console.log(media([7, 8, 6])); // 7
console.log(media([9, 7])); // 8
Le funzioni servono anche quando il codice non si ripete. Dare un nome a un pezzo di lavoro rende il programma più facile da leggere: media(voti) dice cosa succede, il ciclo dice solo come.
Una funzione l'avete già usata dal primo giorno: console.log è una funzione che qualcun altro ha scritto per voi. Math.floor anche.
Dichiarare una funzione
function saluta(): void {
console.log("Buongiorno!");
}
| Pezzo | Cosa vuol dire |
|---|---|
function |
La parola chiave che crea una funzione |
saluta |
Il nome. Stesse regole dei nomi delle variabili; di solito è un verbo, perché una funzione fa qualcosa |
() |
Le tonde con i parametri (qui nessuno) |
: void |
Il tipo del valore restituito. void vuol dire "non restituisce niente" |
{ ... } |
Il corpo: le istruzioni che la funzione esegue |
Dichiarare la funzione non la esegue: il corpo parte solo quando qualcuno la chiama.
Chiamare una funzione
Per eseguirla si scrive il nome seguito dalle tonde. Si chiama chiamata (o invocazione):
function saluta(): void {
console.log("Buongiorno!");
}
saluta(); // Buongiorno!
saluta(); // Buongiorno!
Quando il programma arriva a una chiamata, salta dentro la funzione, esegue il corpo, e poi torna esattamente al punto da cui era partito, alla riga dopo. Senza le tonde la funzione non parte: saluta da solo è il nome della funzione, saluta() è l'ordine di eseguirla.
Parametri
Una funzione che fa sempre la stessa identica cosa serve a poco. I parametri sono le variabili che la funzione riceve da chi la chiama. Si scrivono tra le tonde, ciascuno con il suo tipo:
function salutaPersona(nome: string, ora: number): void {
if (ora < 13) {
console.log(`Buongiorno, ${nome}!`);
} else {
console.log(`Buonasera, ${nome}!`);
}
}
salutaPersona("Ada", 9); // Buongiorno, Ada!
salutaPersona("Linus", 18); // Buonasera, Linus!
I valori scritti nella chiamata ("Ada", 9) si chiamano argomenti. Al momento della chiamata il primo argomento va nel primo parametro, il secondo nel secondo, e così via: conta l'ordine, non il nome.
In JavaScript potete chiamare una funzione con argomenti in più o in meno, e il programma va avanti con valori mancanti. TypeScript controlla che numero e tipo degli argomenti siano quelli dichiarati:
function salutaPersona(nome: string, ora: number): void {
console.log(`Ciao ${nome}, sono le ${ora}`);
}
salutaPersona("Ada"); // errore: Expected 2 arguments, but got 1.
salutaPersona(9, "Ada"); // errore: Argument of type 'number' is not assignable to parameter of type 'string'.
Il secondo caso, due argomenti scambiati, è uno sbaglio frequente: il compilatore lo trova prima dell'esecuzione.
Restituire un valore con return
Molte funzioni calcolano qualcosa e devono consegnarlo a chi le ha chiamate. Si usa return, seguito dal valore. Il tipo dopo le tonde dice che genere di valore esce:
function celsiusInFahrenheit(celsius: number): number {
return celsius * 9 / 5 + 32;
}
const oggi: number = celsiusInFahrenheit(25);
console.log(oggi); // 77
console.log(celsiusInFahrenheit(-10)); // 14
La chiamata celsiusInFahrenheit(25) è un'espressione: il programma la esegue e al suo posto mette il valore restituito, 77. Per questo si può assegnare a una variabile, passare a console.log, o usare dentro un'altra espressione.
return fa due cose: consegna il valore e termina la funzione. Le istruzioni dopo il return non si eseguono. Questo torna utile per uscire appena si conosce la risposta:
function giudizio(voto: number): string {
if (voto >= 9) {
return "ottimo";
}
if (voto >= 6) {
return "sufficiente";
}
return "insufficiente";
}
console.log(giudizio(9.5)); // ottimo
console.log(giudizio(7)); // sufficiente
console.log(giudizio(4)); // insufficiente
Con 9.5 la funzione esce al primo return e non arriva mai al secondo if. Non servono else.
Il compilatore controlla anche il ritorno. Se il tipo dichiarato è number, ogni strada dentro la funzione deve finire con un return che dà un numero:
// errore sul tipo di ritorno: Function lacks ending return statement and return type does not include 'undefined'.
function prezzoBiglietto(eta: number): number {
if (eta < 12) {
return 5;
}
if (eta >= 65) {
return 6;
}
}
Con eta uguale a 30 nessun return scatta, e la funzione non restituirebbe niente. Il compilatore se ne accorge e chiede di coprire anche quel caso.
void: nessun valore
Una funzione che fa qualcosa (stampa, modifica un array) ma non calcola un risultato ha tipo di ritorno void. Dentro può usare return; da solo, senza valore, per uscire prima:
function stampaMeteo(citta: string, temperatura: number): void {
if (temperatura < -50 || temperatura > 60) {
console.log("Dato non valido");
return;
}
console.log(`${citta}: ${temperatura} gradi`);
}
stampaMeteo("Torino", 14); // Torino: 14 gradi
stampaMeteo("Torino", 999); // Dato non valido
Il risultato di una funzione void non si può usare come valore:
function stampaMeteo(citta: string): void {
console.log(citta);
}
const t: number = stampaMeteo("Torino"); // errore: Type 'void' is not assignable to type 'number'.
Una funzione che fa console.log(risultato) invece di return risultato sembra giusta, perché il numero compare sullo schermo. Ma chi la chiama non riceve niente, e non può usare quel numero in un altro calcolo. Le funzioni che calcolano restituiscono; stampa chi le chiama.
Parametri opzionali e valori di default
Un parametro con ? dopo il nome è opzionale: chi chiama può ometterlo. Dentro la funzione, se manca, vale undefined, e bisogna controllarlo:
function etichetta(nome: string, soprannome?: string): string {
if (soprannome === undefined) {
return nome;
}
return `${nome} detto ${soprannome}`;
}
console.log(etichetta("Marco")); // Marco
console.log(etichetta("Marco", "Bolt")); // Marco detto Bolt
Spesso, quando un argomento manca, c'è un valore ovvio da usare. Allora si scrive direttamente il valore di default con =:
function minutiCottura(grammi: number, minutiPerEtto: number = 2): number {
return (grammi / 100) * minutiPerEtto;
}
console.log(minutiCottura(500)); // 10, usa il default 2
console.log(minutiCottura(500, 3)); // 15
I parametri opzionali e quelli con default vanno in fondo, dopo quelli obbligatori. Il motivo è l'ordine: gli argomenti si assegnano da sinistra, e il compilatore deve sapere quale manca.
Scope: dove si vede una variabile
Una variabile dichiarata dentro una funzione esiste solo lì dentro. Si chiama variabile locale. Fuori dalla funzione il suo nome non esiste:
function totaleCalorie(pasti: number[]): number {
let somma: number = 0;
for (const c of pasti) {
somma += c;
}
return somma;
}
console.log(totaleCalorie([450, 700, 620])); // 1770
console.log(somma); // errore: Cannot find name 'somma'.
Anche i parametri sono variabili locali. La zona di codice in cui un nome è visibile si chiama scope (in italiano "ambito"). La regola vale per ogni blocco tra graffe: una variabile dichiarata con let o const dentro un if o un for sparisce alla graffa che chiude il blocco.
Funziona anche al contrario. Una funzione vede le variabili dichiarate fuori, nel programma principale:
const sogliaCaldo: number = 30;
function eCaldo(temperatura: number): boolean {
return temperatura > sogliaCaldo;
}
console.log(eCaldo(33)); // true
Si può fare, ma con giudizio. Una funzione che usa solo i suoi parametri si capisce leggendo lei sola, e si prova facilmente. Una funzione che legge, o peggio modifica, variabili di fuori dipende da cosa è successo prima nel programma. Quando potete, passate quello che serve come parametro.
Due funzioni diverse possono avere variabili locali con lo stesso nome senza disturbarsi: ognuna ha le sue.
Funzioni che chiamano funzioni
Il corpo di una funzione può chiamare altre funzioni. È così che si costruiscono i programmi: pezzi piccoli, ognuno con un compito, combinati in pezzi più grandi.
function media(voti: number[]): number {
let totale: number = 0;
for (const v of voti) {
totale += v;
}
return totale / voti.length;
}
function giudizio(voto: number): string {
if (voto >= 9) {
return "ottimo";
}
if (voto >= 6) {
return "sufficiente";
}
return "insufficiente";
}
function pagella(materia: string, voti: number[]): string {
const m: number = media(voti);
return `${materia}: ${m.toFixed(1)} (${giudizio(m)})`;
}
console.log(pagella("Matematica", [7, 8, 6])); // Matematica: 7.0 (sufficiente)
console.log(pagella("Storia", [9, 10, 9])); // Storia: 9.3 (ottimo)
pagella si ferma sulla riga di media(voti) finché media non restituisce il risultato, poi prosegue e fa lo stesso con giudizio.
Lato macchina: il parametro riceve una copia
Quando chiamate una funzione, il programma crea le celle dei suoi parametri e ci copia dentro gli argomenti. È la stessa copia di let b = a, con le stesse conseguenze.
Con un numero, il parametro riceve una copia del valore:
function aggiungiBonus(punti: number): number {
punti = punti + 10;
return punti;
}
const mieiPunti: number = 50;
const conBonus: number = aggiungiBonus(mieiPunti);
console.log(mieiPunti); // 50
console.log(conBonus); // 60
Durante la chiamata, subito dopo punti = punti + 10:
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | mieiPunti |
50 |
| 101 | conBonus |
(non ancora assegnato) |
| 110 | punti (di aggiungiBonus) |
60 |
La funzione ha cambiato la sua cella, la 110. La cella 100 non l'ha mai toccata. Quando la funzione finisce, la cella 110 sparisce, e il valore restituito finisce in conBonus.
Con un array, nella cella dell'argomento c'è un indirizzo, quindi il parametro riceve una copia dell'indirizzo:
function aggiungiBrano(playlist: string[], brano: string): void {
playlist.push(brano);
}
const preferiti: string[] = ["Imagine", "Yesterday"];
aggiungiBrano(preferiti, "Wonderwall");
console.log(preferiti); // [ 'Imagine', 'Yesterday', 'Wonderwall' ]
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | preferiti |
→ 500 |
| 110 | playlist (di aggiungiBrano) |
→ 500 |
| 111 | brano (di aggiungiBrano) |
"Wonderwall" |
| 500 | ["Imagine", "Yesterday", "Wonderwall"] |
Due frecce, un array solo. La funzione segue la sua freccia e modifica l'array alla cella 500, che è anche quello di preferiti. A volte è proprio quello che volete, come qui. Altre volte è un effetto non voluto: una funzione che riceve un array e lo modifica cambia anche l'array di chi l'ha chiamata.
C'è però una cosa che la funzione non può fare: far puntare la variabile del chiamante a un altro array.
function svuota(playlist: string[]): void {
playlist = [];
}
const preferiti: string[] = ["Imagine", "Yesterday"];
svuota(preferiti);
console.log(preferiti); // [ 'Imagine', 'Yesterday' ]
playlist = [] crea un array nuovo, per esempio alla cella 600, e cambia la freccia nella cella 110. La cella 100 resta → 500.
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | preferiti |
→ 500 |
| 110 | playlist (di svuota) |
→ 600 |
| 500 | ["Imagine", "Yesterday"] |
|
| 600 | [] |
Riassunto:
| Cosa fa la funzione col parametro | Numero, stringa, boolean | Array (e, tra poco, oggetti) |
|---|---|---|
Lo modifica dentro (push, [0] = ...) |
Non si può: non ha un "dentro" | Il chiamante vede la modifica |
Gli assegna un valore nuovo (p = ...) |
Il chiamante non vede niente | Il chiamante non vede niente |
Se una funzione deve lavorare su un array senza toccare l'originale, se ne fa una copia con [...array] e lavora su quella.
Esistono altre forme per scrivere una funzione (le funzioni anonime e le arrow function, con la freccia =>). Fanno la stessa cosa con una sintassi diversa: le vedrete più avanti.
07-funzioni.ipynb2. Bonus: stack e heap
Cosa succede in memoria quando si chiama una funzione. Non serve per gli esercizi, e il resto della giornata si capisce anche senza.
Lo stack: una pila di fogli
Nella sezione 1 i parametri e le variabili locali comparivano durante la chiamata e sparivano alla fine. Il programma li tiene in una zona della memoria che si chiama stack ("pila").
Ogni chiamata mette in cima alla pila un foglio nuovo, con i parametri, le variabili locali e il punto del codice a cui tornare. Si lavora sempre sul foglio in cima. Al return il foglio si butta, con tutto quello che c'era scritto, e si riprende dal foglio sotto. In fondo alla pila c'è sempre il foglio del programma principale.
Una chiamata dentro l'altra
function somma(numeri: number[]): number {
let totale: number = 0;
for (const n of numeri) {
totale += n;
}
return totale;
}
function media(voti: number[]): number {
const totale: number = somma(voti);
return totale / voti.length;
}
const mieiVoti: number[] = [7, 8, 6];
const risultato: number = media(mieiVoti);
console.log(risultato); // 7
Il programma chiama media, che chiama somma. Questa è la memoria durante l'ultimo giro del ciclo in somma, quando la pila è più alta:
| Zona | Foglio | Indirizzo | Nome | Contenuto |
|---|---|---|---|---|
| stack | somma (in cima) |
122 | n |
6 |
| stack | somma (in cima) |
121 | totale |
21 |
| stack | somma (in cima) |
120 | numeri |
→ 500 |
| stack | media |
111 | totale |
(in attesa di somma) |
| stack | media |
110 | voti |
→ 500 |
| stack | programma | 101 | risultato |
(in attesa di media) |
| stack | programma | 100 | mieiVoti |
→ 500 |
| heap | 500 | [7, 8, 6] |
Tre cose da notare:
- ci sono due variabili
totale, una per foglio. Sono celle diverse e non si disturbano; - tre frecce puntano allo stesso array: nessuna funzione ha copiato l'array, ognuna ha ricevuto una copia dell'indirizzo;
- l'array non sta nello stack. Sta in un'altra zona, lo heap.
Quando somma arriva al return, consegna 21 e il suo foglio si butta: le celle 120, 121 e 122 non esistono più. media scrive 21 nella sua cella 111, calcola 21 / 3 e restituisce 7. Il suo foglio si butta a sua volta, e il programma scrive 7 in risultato.
Lo heap: dove vivono array e oggetti
Lo heap ("mucchio") è la zona "altrove" che nella prima giornata abbiamo disegnato dagli indirizzi 500 in su. Lì il programma mette gli array, e tra poco gli oggetti. Lo heap non segue l'ordine delle chiamate: un array creato dentro una funzione resta nello heap anche dopo il return, finché qualche freccia lo raggiunge.
Perché un oggetto creato in una funzione sopravvive
function creaScaletta(): string[] {
const scaletta: string[] = ["riscaldamento", "squat", "stretching"];
return scaletta;
}
const allenamento: string[] = creaScaletta();
console.log(allenamento); // [ 'riscaldamento', 'squat', 'stretching' ]
La variabile scaletta è locale: sta sul foglio di creaScaletta e sparisce al return. Eppure l'array arriva intatto. Il motivo è che return scaletta restituisce il contenuto della cella, cioè la freccia → 500. Il foglio si butta, la freccia viene copiata in allenamento, e l'array nello heap è ancora lì:
| Momento | Stack | Heap |
|---|---|---|
Dentro creaScaletta, prima del return |
scaletta → 500 |
500: ["riscaldamento", "squat", "stretching"] |
Dopo il return |
allenamento → 500 |
500: lo stesso array |
Muore la variabile, non l'array. Quando nessuna freccia raggiunge più un array, il programma lo considera spazzatura e prima o poi libera quello spazio. Lo fa da solo, con un meccanismo che si chiama garbage collector.
Curiosità: lo stack overflow
La pila ha un'altezza massima. Una funzione può chiamare sé stessa (si chiama ricorsione), e se non c'è un caso in cui smette, i fogli si accumulano senza fine:
function contoAllaRovescia(n: number): void {
console.log(n);
contoAllaRovescia(n - 1); // manca il caso in cui fermarsi, per esempio n === 0
}
contoAllaRovescia(10);
Il compilatore non vede niente di strano. Quando il programma gira stampa 10, 9, 8 e così via sotto lo zero, poi dopo qualche migliaio di fogli si ferma con questo errore a runtime:
RangeError: Maximum call stack size exceeded
"Lo stack ha superato la dimensione massima": in inglese si dice stack overflow, ed è anche il nome del sito di domande e risposte più usato dai programmatori.
Più dettagli, e la stessa funzione scritta bene, in Stack e heap.
07-funzioni.ipynb, la parte bonus in fondo3. Oggetti
Più dati che stanno insieme
Un libro della biblioteca ha un titolo, un autore, un numero di pagine, e può essere in prestito o no. Con quello che sapete finora servono quattro variabili:
const titolo: string = "Il barone rampante";
const autore: string = "Italo Calvino";
const pagine: number = 288;
const inPrestito: boolean = false;
Con cento libri diventano quattrocento variabili, e niente nel codice dice che titolo e autore parlano dello stesso libro. Un oggetto mette insieme dati che descrivono la stessa cosa.
L'oggetto letterale
const libro = {
titolo: "Il barone rampante",
autore: "Italo Calvino",
pagine: 288,
inPrestito: false,
};
Tra graffe ci sono le proprietà, separate da virgole. Ogni proprietà ha un nome, i due punti e un valore. Si chiama oggetto letterale perché lo scrivete così com'è, valore per valore, come [7, 8, 6] per un array.
Leggere e modificare le proprietà
Si usa il punto: oggetto.proprietà.
const libro = {
titolo: "Il barone rampante",
autore: "Italo Calvino",
pagine: 288,
inPrestito: false,
};
console.log(libro.titolo); // Il barone rampante
console.log(`${libro.autore}, ${libro.pagine} pagine`); // Italo Calvino, 288 pagine
libro.inPrestito = true;
console.log(libro.inPrestito); // true
Il punto l'avete già visto: voti.length, voti.push(30). Anche array e stringhe hanno proprietà.
Rispetto all'array cambia il modo di trovare un dato: nell'array per posizione (voti[0]), nell'oggetto per nome (libro.titolo). Usate un array per un elenco di cose dello stesso genere, un oggetto per le caratteristiche di una cosa sola.
TypeScript controlla anche le proprietà. Una proprietà che non esiste è un errore:
const libro = {
titolo: "Il barone rampante",
pagine: 288,
};
console.log(libro.autore); // errore: Property 'autore' does not exist on type '{ titolo: string; pagine: number; }'.
libro.pagine = "tante"; // errore: Type 'string' is not assignable to type 'number'.
Dare un nome alla forma con type
Il messaggio di errore qui sopra mostra il tipo dell'oggetto, { titolo: string; pagine: number; }: TypeScript l'ha dedotto dai valori. Quando gli oggetti con la stessa forma sono tanti, conviene dare un nome a quella forma, con type:
type Libro = {
titolo: string;
autore: string;
pagine: number;
inPrestito: boolean;
};
const barone: Libro = {
titolo: "Il barone rampante",
autore: "Italo Calvino",
pagine: 288,
inPrestito: false,
};
type Libro non crea nessun libro: descrive com'è fatto un libro. Per convenzione il nome inizia con la maiuscola. Da qui in avanti Libro si usa come number o string, e il compilatore controlla che ogni oggetto dichiarato Libro abbia tutte le proprietà giuste, e nessuna in più:
type Libro = {
titolo: string;
autore: string;
pagine: number;
inPrestito: boolean;
};
const dune: Libro = {
titolo: "Dune",
autore: "Frank Herbert",
inPrestito: false,
}; // errore: Property 'pagine' is missing in type '{ titolo: string; autore: string; inPrestito: false; }' but required in type 'Libro'.
const emma: Libro = {
titolo: "Emma",
autore: "Jane Austen",
pagine: 474,
inPrestito: false,
copertina: "rigida", // errore: Object literal may only specify known properties, and 'copertina' does not exist in type 'Libro'.
};
Proprietà opzionali
Come per i parametri, ? rende una proprietà facoltativa:
type Allenamento = {
attivita: string;
minuti: number;
calorie?: number;
};
const lunedi: Allenamento = { attivita: "corsa", minuti: 40, calorie: 380 };
const martedi: Allenamento = { attivita: "yoga", minuti: 60 };
Una proprietà opzionale può valere undefined, e il compilatore vi obbliga a tenerne conto:
type Allenamento = {
attivita: string;
minuti: number;
calorie?: number;
};
const martedi: Allenamento = { attivita: "yoga", minuti: 60 };
console.log(martedi.calorie.toFixed(0)); // errore: 'martedi.calorie' is possibly 'undefined'.
if (martedi.calorie !== undefined) {
console.log(martedi.calorie.toFixed(0)); // qui va bene: il compilatore sa che c'è
}
Array di oggetti
Un array può contenere oggetti. Il tipo si scrive Libro[], "array di libri", e si scorre con for...of come qualsiasi array:
type Libro = {
titolo: string;
autore: string;
pagine: number;
inPrestito: boolean;
};
const scaffale: Libro[] = [
{ titolo: "Il barone rampante", autore: "Italo Calvino", pagine: 288, inPrestito: false },
{ titolo: "Dune", autore: "Frank Herbert", pagine: 600, inPrestito: true },
{ titolo: "Emma", autore: "Jane Austen", pagine: 474, inPrestito: false },
];
let disponibili: number = 0;
for (const libro of scaffale) {
if (!libro.inPrestito) {
disponibili++;
console.log(`${libro.titolo} di ${libro.autore}`);
}
}
console.log(`Libri disponibili: ${disponibili}`); // Libri disponibili: 2
A ogni iterazione libro è un oggetto intero, e con il punto si leggono le sue proprietà. Gli schemi della prima giornata (somma, conteggio, massimo, filtro) funzionano uguali: qui c'è un conteggio. Questa forma, un array di oggetti, è quella che troverete più spesso nei dati veri: un elenco di studenti, di prodotti, di messaggi, di eventi in calendario.
Oggetti e funzioni
Un oggetto si passa a una funzione come qualsiasi altro valore, e una funzione può restituire un oggetto:
type Ricetta = {
nome: string;
porzioni: number;
minuti: number;
};
function descrivi(ricetta: Ricetta): string {
return `${ricetta.nome}: ${ricetta.porzioni} porzioni, ${ricetta.minuti} minuti`;
}
function creaRicetta(nome: string, porzioni: number, minuti: number): Ricetta {
return { nome: nome, porzioni: porzioni, minuti: minuti };
}
const carbonara: Ricetta = creaRicetta("Carbonara", 4, 25);
console.log(descrivi(carbonara)); // Carbonara: 4 porzioni, 25 minuti
Quando il nome della proprietà e quello della variabile coincidono, come in { nome: nome }, si può scrivere solo { nome }. Quindi la riga del return si accorcia in return { nome, porzioni, minuti };.
Lato macchina: l'oggetto sta altrove
Un oggetto si comporta come un array: sta altrove in memoria, e la variabile contiene il suo indirizzo.
const meteo = { citta: "Napoli", temperatura: 22, pioggia: false };
const giorno: number = 12;
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | meteo |
→ 500 |
| 101 | giorno |
12 |
| 500 | { citta: "Napoli", temperatura: 22, pioggia: false } |
meteo.temperatura vuol dire: leggi la cella 100, segui la freccia fino a 500, prendi la proprietà temperatura.
Tutto quello che avete visto per gli array vale anche qui.
const b = a copia la freccia, non l'oggetto:
const lunedi = { citta: "Napoli", temperatura: 22 };
const martedi = lunedi;
martedi.temperatura = 18;
console.log(lunedi.temperatura); // 18 anche lunedi è cambiato
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | lunedi |
→ 500 |
| 101 | martedi |
→ 500 |
| 500 | { citta: "Napoli", temperatura: 18 } |
=== tra due oggetti confronta le frecce, non le proprietà:
const a = { citta: "Napoli", temperatura: 22 };
const b = { citta: "Napoli", temperatura: 22 };
const c = a;
console.log(a === b); // false: stesse proprietà, ma due oggetti diversi (500 e 600)
console.log(a === c); // true: stessa freccia
Per copiare un oggetto si usa lo spread, questa volta tra graffe: { ...a } crea un oggetto nuovo con le stesse proprietà. Si possono anche cambiare alcune proprietà mentre si copia:
const lunedi = { citta: "Napoli", temperatura: 22 };
const martedi = { ...lunedi, temperatura: 18 };
console.log(lunedi.temperatura); // 22
console.log(martedi.temperatura); // 18
console.log(martedi.citta); // Napoli
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | lunedi |
→ 500 |
| 101 | martedi |
→ 600 |
| 500 | { citta: "Napoli", temperatura: 22 } |
|
| 600 | { citta: "Napoli", temperatura: 18 } |
{ ...a } copia le proprietà una per una, con =. Se una proprietà è a sua volta un array o un oggetto, si copia la sua freccia, e quella parte resta condivisa:
const ada = { nome: "Ada", corsi: ["pilates", "nuoto"] };
const copia = { ...ada };
copia.corsi.push("yoga");
console.log(ada.corsi); // [ 'pilates', 'nuoto', 'yoga' ] l'array dei corsi è lo stesso
Si chiama copia superficiale. Come fare una copia completa, e altri casi, in Copiare un valore, copiare un riferimento.
Anche il passaggio a una funzione funziona come per gli array: il parametro riceve una copia dell'indirizzo, e la funzione può modificare l'oggetto del chiamante.
type Prestito = {
titolo: string;
giorniRimasti: number;
};
function rinnova(prestito: Prestito): void {
prestito.giorniRimasti += 30;
}
const mioPrestito: Prestito = { titolo: "Dune", giorniRimasti: 3 };
rinnova(mioPrestito);
console.log(mioPrestito.giorniRimasti); // 33
E const con un oggetto blocca la freccia, non le proprietà:
const sveglia = { ora: 7, minuti: 30, attiva: true };
sveglia.minuti = 45; // va bene: cambia l'oggetto alla cella 500
sveglia = { ora: 8, minuti: 0, attiva: true }; // errore: Cannot assign to 'sveglia' because it is a constant.
08-oggetti.ipynb4. Classi e istanze
Dall'oggetto letterale alla classe
Prendete un contapassi: ogni persona ha il suo, con un nome, un obiettivo giornaliero e i passi fatti finora.
type Contapassi = {
persona: string;
obiettivo: number;
passi: number;
};
function cammina(contapassi: Contapassi, quanti: number): void {
contapassi.passi += quanti;
}
function obiettivoRaggiunto(contapassi: Contapassi): boolean {
return contapassi.passi >= contapassi.obiettivo;
}
const ada: Contapassi = { persona: "Ada", obiettivo: 8000, passi: 0 };
cammina(ada, 5000);
cammina(ada, 3500);
console.log(obiettivoRaggiunto(ada)); // true
Funziona, ma i dati stanno da una parte e le operazioni da un'altra. Niente lega cammina al tipo Contapassi, se non il parametro. E per creare un contapassi nuovo bisogna riscrivere ogni volta tutte le proprietà, ricordandosi che passi parte da 0.
Una classe mette insieme in un posto solo tre cose: la forma dei dati, il modo di crearli e le operazioni che li usano.
Classe e istanze
La classe non è un contapassi: descrive com'è fatto un contapassi, come type, e in più sa crearlo. Gli oggetti creati da una classe si chiamano istanze. Ogni istanza ha le proprietà descritte dalla classe, con i suoi valori: il contapassi di Ada e quello di Linus vengono dalla stessa classe, ma i passi di Ada sono solo di Ada.
La classe
class Contapassi {
persona: string;
obiettivo: number;
passi: number;
constructor(persona: string, obiettivo: number) {
this.persona = persona;
this.obiettivo = obiettivo;
this.passi = 0;
}
cammina(quanti: number): void {
this.passi += quanti;
}
obiettivoRaggiunto(): boolean {
return this.passi >= this.obiettivo;
}
}
Pezzo per pezzo:
| Pezzo | Cosa vuol dire |
|---|---|
class Contapassi |
Crea una classe di nome Contapassi. Il nome inizia con la maiuscola |
persona: string; |
Una proprietà, con il suo tipo. Ogni istanza avrà la sua persona |
constructor(...) |
Il costruttore: la funzione che prepara un'istanza nuova |
this.persona = persona; |
Copia il parametro persona nella proprietà persona dell'istanza |
cammina(quanti: number): void |
Un metodo: una funzione che appartiene alla classe |
Un metodo si scrive come una funzione, senza la parola function.
Il costruttore
Il costruttore si esegue una volta sola per ogni istanza, nel momento in cui nasce. Il suo compito è dare un valore a tutte le proprietà. Riceve dei parametri come una funzione normale, e non ha tipo di ritorno.
Qui persona e obiettivo arrivano da fuori, perché cambiano da persona a persona. passi invece parte sempre da 0, quindi il costruttore non lo chiede. Quando una proprietà parte sempre dallo stesso valore, si può scrivere direttamente accanto alla dichiarazione:
class Contapassi {
persona: string;
obiettivo: number;
passi: number = 0;
constructor(persona: string, obiettivo: number) {
this.persona = persona;
this.obiettivo = obiettivo;
}
}
Se una proprietà resta senza valore, il compilatore protesta:
class Contapassi {
persona: string;
passi: number; // errore: Property 'passi' has no initializer and is not definitely assigned in the constructor.
constructor(persona: string) {
this.persona = persona;
}
}
this
Dentro la classe, this vuol dire "l'istanza su cui sto lavorando". this.passi è la proprietà passi di questa istanza, non di un'altra.
Nel costruttore ci sono due cose con lo stesso nome: il parametro persona e la proprietà this.persona. Sono diverse. Il parametro è una variabile locale del costruttore, e sparisce quando il costruttore finisce. La proprietà resta nell'istanza. this.persona = persona copia la prima nella seconda.
this non funzionaDentro un metodo, per leggere una proprietà bisogna sempre scrivere this.. Se scrivete solo passi += quanti, il compilatore cerca una variabile passi e non la trova: Cannot find name 'passi'. Did you mean the instance member 'this.passi'?
new: creare un'istanza
Per creare un'istanza si scrive new seguito dal nome della classe e dagli argomenti del costruttore:
class Contapassi {
persona: string;
obiettivo: number;
passi: number = 0;
constructor(persona: string, obiettivo: number) {
this.persona = persona;
this.obiettivo = obiettivo;
}
cammina(quanti: number): void {
this.passi += quanti;
}
obiettivoRaggiunto(): boolean {
return this.passi >= this.obiettivo;
}
rapporto(): string {
const percentuale: number = Math.round((this.passi / this.obiettivo) * 100);
return `${this.persona}: ${this.passi} passi su ${this.obiettivo} (${percentuale}%)`;
}
}
const ada = new Contapassi("Ada", 8000);
ada.cammina(5000);
ada.cammina(3500);
console.log(ada.obiettivoRaggiunto()); // true
console.log(ada.rapporto()); // Ada: 8500 passi su 8000 (106%)
new Contapassi("Ada", 8000) crea un'istanza nuova, esegue il costruttore con quei due argomenti e restituisce l'istanza. Il nome della classe fa anche da tipo: ada è di tipo Contapassi, e potete scrivere const ada: Contapassi = new Contapassi("Ada", 8000);.
I metodi si chiamano con il punto, come push sugli array: ada.cammina(5000). Anche le proprietà si leggono con il punto: ada.passi.
Più istanze
Ogni istanza ha le sue proprietà:
class Contapassi {
persona: string;
obiettivo: number;
passi: number = 0;
constructor(persona: string, obiettivo: number) {
this.persona = persona;
this.obiettivo = obiettivo;
}
cammina(quanti: number): void {
this.passi += quanti;
}
}
const ada = new Contapassi("Ada", 8000);
const linus = new Contapassi("Linus", 10000);
ada.cammina(3000);
linus.cammina(7000);
ada.cammina(1000);
console.log(ada.passi); // 4000
console.log(linus.passi); // 7000
Le istanze si possono mettere in un array, come gli oggetti letterali:
// la classe Contapassi è quella completa, con obiettivoRaggiunto (sezione "new: creare un'istanza")
const gruppo: Contapassi[] = [
new Contapassi("Ada", 8000),
new Contapassi("Linus", 10000),
new Contapassi("Grace", 6000),
];
gruppo[0].cammina(9000);
gruppo[2].cammina(6500);
for (const c of gruppo) {
const esito: string = c.obiettivoRaggiunto() ? "raggiunto" : "non ancora";
console.log(`${c.persona}: ${esito}`);
}
// Ada: raggiunto
// Linus: non ancora
// Grace: raggiunto
Lato macchina: new e this
new fa tre cose: riserva spazio altrove per un'istanza nuova, esegue il costruttore su quello spazio, e restituisce l'indirizzo. Un'istanza in memoria si comporta come un oggetto letterale.
// la classe Contapassi è quella della sezione "Più istanze"
const ada = new Contapassi("Ada", 8000);
const linus = new Contapassi("Linus", 10000);
ada.cammina(3000);
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | ada |
→ 500 |
| 101 | linus |
→ 600 |
| 500 | Contapassi { persona: "Ada", obiettivo: 8000, passi: 3000 } |
|
| 600 | Contapassi { persona: "Linus", obiettivo: 10000, passi: 0 } |
Due new, due spazi separati. Per questo i passi di Ada non finiscono nel contapassi di Linus.
Il codice dei metodi non si copia in ogni istanza: sta una volta sola, con la classe, e tutte le istanze lo usano. Come fa allora cammina a sapere quali passi aumentare? Quando scrivete ada.cammina(3000), il programma esegue il metodo con this uguale a quello che sta prima del punto. ada contiene → 500, quindi dentro il metodo this vale → 500, e this.passi += quanti modifica la cella 500. Con linus.cammina(...), this sarebbe → 600.
Anche qui const b = a copia la freccia:
// sempre la classe Contapassi di prima
const ada = new Contapassi("Ada", 8000);
const stessoDiAda = ada;
stessoDiAda.passi = 1200;
console.log(ada.passi); // 1200: è la stessa istanza
09-classi-e-istanze.ipynb5. Incapsulamento
Il problema: chiunque può cambiare tutto
Un salvadanaio digitale tiene i risparmi di una persona. Le regole: si possono mettere soldi, se ne possono togliere quanti ce ne sono, e il saldo non va mai sotto zero.
class Salvadanaio {
proprietario: string;
saldo: number = 0;
constructor(proprietario: string) {
this.proprietario = proprietario;
}
deposita(euro: number): void {
if (euro <= 0) {
return;
}
this.saldo += euro;
}
preleva(euro: number): boolean {
if (euro <= 0 || euro > this.saldo) {
return false;
}
this.saldo -= euro;
return true;
}
}
const mio = new Salvadanaio("Ada");
mio.deposita(50);
console.log(mio.preleva(80)); // false: non ci sono abbastanza soldi
mio.saldo = -300; // nessuno lo impedisce
mio.proprietario = "Linus"; // nemmeno questo
console.log(mio.saldo); // -300
I metodi fanno rispettare le regole. Ma chi usa la classe può saltarli e scrivere direttamente nella proprietà. In un programma di dieci righe ve ne accorgete. In uno di diecimila, scritto da cinque persone, prima o poi qualcuno scrive saldo = ... da qualche parte, e il saldo negativo compare senza che nessuno sappia da dove.
L'incapsulamento è l'idea di chiudere i dati dentro la classe e lasciare a chi la usa solo i metodi. Così ogni modifica passa dai controlli dei metodi.
private
Una proprietà private si può usare solo dentro la classe, nei suoi metodi. Da fuori il compilatore la blocca:
class Salvadanaio {
proprietario: string;
private saldo: number = 0;
constructor(proprietario: string) {
this.proprietario = proprietario;
}
deposita(euro: number): void {
if (euro <= 0) {
return;
}
this.saldo += euro;
}
}
const mio = new Salvadanaio("Ada");
mio.deposita(50); // va bene: dentro deposita, this.saldo si può usare
mio.saldo = -300; // errore: Property 'saldo' is private and only accessible within class 'Salvadanaio'.
console.log(mio.saldo); // errore: Property 'saldo' is private and only accessible within class 'Salvadanaio'.
Le proprietà e i metodi senza private si dicono pubblici: si usano da qualsiasi punto del programma. Si può scrivere esplicitamente public, ma è il comportamento di base.
Anche un metodo può essere private: è un pezzo di lavoro che serve alla classe ma che da fuori non deve chiamare nessuno.
private esiste solo per il compilatoreCome i tipi, private sparisce quando TypeScript diventa JavaScript. Protegge dagli errori di chi scrive il codice, non da qualcuno che vuole forzare il programma mentre gira. JavaScript ha un suo modo di rendere privata una proprietà anche a runtime, con il cancelletto (#saldo). Nel corso usiamo private, che è più leggibile.
Metodi che fanno rispettare le regole
Con il saldo privato, l'unico modo di cambiarlo è passare dai metodi. E i metodi possono controllare tutto quello che serve:
class Salvadanaio {
proprietario: string;
private saldo: number = 0;
private movimenti: number = 0;
constructor(proprietario: string) {
this.proprietario = proprietario;
}
deposita(euro: number): void {
if (euro <= 0) {
console.log("Importo non valido");
return;
}
this.saldo += euro;
this.movimenti++;
}
preleva(euro: number): boolean {
if (euro <= 0 || euro > this.saldo) {
return false;
}
this.saldo -= euro;
this.movimenti++;
return true;
}
}
const mio = new Salvadanaio("Ada");
mio.deposita(50);
mio.deposita(-20); // Importo non valido
console.log(mio.preleva(80)); // false
console.log(mio.preleva(30)); // true
Adesso il saldo non può andare sotto zero, in nessun caso: l'unico codice che lo modifica è dentro la classe, e lo controllate tutto in un colpo d'occhio. Se un giorno cambia una regola (un limite ai prelievi, un costo per ogni movimento), si cambia in un posto solo.
get: leggere senza poter scrivere
Così però il saldo non si può nemmeno leggere da fuori, e un salvadanaio di cui non si sa quanto contiene serve a poco. Un getter è un metodo speciale, scritto con get, che si usa come se fosse una proprietà:
class Salvadanaio {
proprietario: string;
private _saldo: number = 0;
constructor(proprietario: string) {
this.proprietario = proprietario;
}
deposita(euro: number): void {
if (euro > 0) {
this._saldo += euro;
}
}
get saldo(): number {
return this._saldo;
}
}
const mio = new Salvadanaio("Ada");
mio.deposita(50);
console.log(mio.saldo); // 50, senza tonde: si legge come una proprietà
mio.saldo = 1000; // errore: Cannot assign to 'saldo' because it is a read-only property.
La proprietà privata si chiama _saldo perché il nome saldo ora è del getter, e due cose nella stessa classe non possono avere lo stesso nome. Il trattino basso davanti è una convenzione diffusa per "la proprietà privata che sta dietro a un getter".
Un getter può anche calcolare qualcosa invece di restituire una proprietà così com'è:
class Salvadanaio {
private _saldo: number = 0;
private obiettivo: number;
constructor(obiettivo: number) {
this.obiettivo = obiettivo;
}
deposita(euro: number): void {
if (euro > 0) {
this._saldo += euro;
}
}
get mancano(): number {
return Math.max(this.obiettivo - this._saldo, 0);
}
}
const perLaBici = new Salvadanaio(300);
perLaBici.deposita(120);
console.log(perLaBici.mancano); // 180
readonly: un valore che non cambia più
Il proprietario di un salvadanaio si decide quando lo si crea, e poi non cambia. Per questi casi c'è readonly: la proprietà riceve il valore nel costruttore (o nella dichiarazione) e dopo non si può più riassegnare, né da fuori né da dentro la classe. A differenza di private, si può leggere da fuori:
class Salvadanaio {
readonly proprietario: string;
private _saldo: number = 0;
constructor(proprietario: string) {
this.proprietario = proprietario;
}
get saldo(): number {
return this._saldo;
}
}
const mio = new Salvadanaio("Ada");
console.log(mio.proprietario); // Ada
mio.proprietario = "Linus"; // errore: Cannot assign to 'proprietario' because it is a read-only property.
readonly fa per una proprietà quello che const fa per una variabile. Vale lo stesso avvertimento: se la proprietà contiene un array o un oggetto, readonly blocca la freccia, non il contenuto.
Riassunto delle tre parole:
| Si legge da fuori | Si scrive da fuori | Si scrive dentro la classe | |
|---|---|---|---|
| (niente, pubblica) | Sì | Sì | Sì |
readonly |
Sì | No | Solo nel costruttore |
private |
No | No | Sì |
private + get |
Sì, attraverso il getter | No | Sì |
La scorciatoia dei parametri del costruttore
Molti costruttori non fanno altro che copiare i parametri nelle proprietà, this.x = x per ciascuna. TypeScript ha una scorciatoia: se davanti a un parametro del costruttore scrivete public, private o readonly, quel parametro diventa anche una proprietà, e la copia la fa lui.
Queste due classi sono identiche:
class Tessera {
readonly numero: number;
readonly intestatario: string;
private prestitiAttivi: number;
constructor(numero: number, intestatario: string, prestitiAttivi: number) {
this.numero = numero;
this.intestatario = intestatario;
this.prestitiAttivi = prestitiAttivi;
}
puoPrendereUnLibro(): boolean {
return this.prestitiAttivi < 3;
}
}
class Tessera {
constructor(
readonly numero: number,
readonly intestatario: string,
private prestitiAttivi: number,
) {}
puoPrendereUnLibro(): boolean {
return this.prestitiAttivi < 3;
}
}
const tessera = new Tessera(1042, "Grace Hopper", 1);
console.log(tessera.intestatario); // Grace Hopper
console.log(tessera.puoPrendereUnLibro()); // true
Il corpo del costruttore resta vuoto, {}, perché non c'è più niente da copiare a mano. La scorciatoia è molto diffusa nel codice TypeScript, quindi va saputa leggere. Per scrivere, all'inizio conviene la forma lunga, che mostra ogni passaggio.
09-classi-e-istanze.ipynb6. Riepilogo
- Una funzione è un blocco di codice con un nome: si scrive una volta e si chiama quante volte serve. I parametri hanno un tipo, e il tipo di ritorno dice cosa esce con
return;voidvuol dire che non esce niente. Le funzioni che calcolano restituiscono, non stampano. returnconsegna il valore e termina la funzione. I parametri con?sono opzionali, quelli con=hanno un default, e stanno in fondo.- Le variabili dichiarate dentro una funzione o un blocco esistono solo lì. Quando potete, passate i dati come parametri invece di leggerli da fuori.
- Un parametro riceve una copia di quello che c'è nella cella dell'argomento: per un numero una copia del valore, per un array o un oggetto una copia dell'indirizzo. Per questo una funzione può modificare l'array o l'oggetto di chi la chiama.
- Un oggetto raccoglie le proprietà di una cosa sola, e
typedà un nome alla sua forma. Come gli array, gli oggetti stanno altrove:const b = acopia la freccia,===confronta le frecce,{ ...a }fa una copia di superficie. - Una classe descrive la forma dei dati, il modo di crearli e le operazioni; le istanze sono gli oggetti creati da lei.
newcrea un'istanza altrove, esegue ilconstructore restituisce l'indirizzo; dentro i metodithisè l'istanza su cui è stato chiamato il metodo. - Incapsulare vuol dire chiudere i dati con
privatee lasciare fuori solo i metodi, che fanno rispettare le regole.getfa leggere senza far scrivere,readonlyblocca una proprietà dopo il costruttore.