01 - Variabili, tipi e cicli

Variabili, tipi e cicli

1. Il notebook e la memoria

Cos'è un programma

Un programma è un elenco di istruzioni che il computer esegue in ordine, dall'alto verso il basso, una alla volta. Ogni istruzione è piccola: ricorda un numero, somma due valori, scrivi un messaggio sullo schermo. Il computer non capisce le intenzioni. Fa esattamente quello che c'è scritto, anche quando è sbagliato.

Il primo programma di quasi tutti i corsi scrive un messaggio:

console.log("Ciao!");

console.log stampa quello che riceve tra le parentesi. Lo useremo di continuo per vedere cosa succede dentro il programma.

Le istruzioni si scrivono in un linguaggio di programmazione. In questo corso usiamo TypeScript, che è JavaScript con in più i tipi (sezione 3). JavaScript è il linguaggio dei browser, e oggi gira anche sui server.

La memoria: celle con un indirizzo

Mentre un programma gira, i dati che usa stanno nella memoria (la RAM). Nel corso la disegniamo sempre allo stesso modo: una tabella di celle. Ogni cella ha un indirizzo, cioè un numero che la identifica.

Indirizzo Contenuto
100 19
101 "Ada"
102
103

Il computer ritrova un dato solo attraverso il suo indirizzo. Ricordarsi "il voto sta nella cella 100" sarebbe scomodo, quindi i linguaggi ci fanno dare un nome alle celle. Una cella con un nome è una variabile.

Indirizzo Nome Contenuto
100 eta 19
101 nome "Ada"

Questa tabella è un modello: la memoria vera è più complicata (un numero occupa più celle, per esempio). Il modello però dà sempre la risposta giusta per i programmi del corso. I dettagli sono in La memoria - celle e indirizzi.

Come si usa JupyterHub

Gli esercizi si fanno nei notebook: pagine che alternano testo e pezzi di codice eseguibili. Girano su un server, quindi non dovete installare niente.

  1. Aprite https://its-notebook.ebattistella.com e accedete con l'account della scuola.
  2. Si apre JupyterLab, con la cartella lezioni. Dentro ci sono i notebook del corso, numerati: 01-memoria-e-variabili.ipynb, 02-tipi-e-compilatore.ipynb e così via. Doppio clic per aprirne uno.
  3. Un notebook è fatto di celle. Le celle di testo spiegano, le celle di codice si eseguono.
  4. Per eseguire una cella ci cliccate dentro e premete Shift+Invio. Il risultato compare sotto la cella, e il cursore passa alla cella successiva.
  5. Per eseguire tutto il notebook dall'inizio: menu Run → Run All Cells.
  6. A sinistra di ogni cella c'è un numero tra parentesi quadre, come [3]: è l'ordine in cui le celle sono state eseguite. [*] vuol dire che la cella sta ancora girando.

Il notebook salva da solo ogni tanto, e potete salvare quando volete con Ctrl+S. Le vostre modifiche restano vostre: se il docente pubblica un notebook nuovo, compare nella cartella senza toccare quelli che avete già.

L'ordine conta

Una cella vede le variabili create dalle celle eseguite prima, non quelle scritte sopra. Se aprite un notebook e partite dalla cella 10, le variabili delle celle 1-9 non esistono ancora. In caso di dubbio: Run All.

Quando una cella dà errore

Il kernel del corso (il programma che esegue le celle, si chiama tslab) controlla i tipi prima di eseguire. Se trova un errore, la cella non parte e sotto compare un messaggio in rosso, in inglese, con il numero di riga e di colonna:

1:5 - Type 'string' is not assignable to type 'number'.

Leggete il messaggio dall'inizio: dice dove guardare (riga 1, colonna 5) e cosa non va. Correggete e rieseguite la cella. Perché questi errori arrivano prima che il codice giri è spiegato nella sezione 3.

In fondo a ogni esercizio ci sono delle stampe di prova, con accanto nel commento il risultato giusto: eseguite la cella e confrontate.

Nel notebook: 01-memoria-e-variabili.ipynb

2. Variabili

Dichiarazione e assegnazione

Una variabile si crea con una dichiarazione: una parola chiave (let o const) e il nome.

let passi: number;

Questa riga chiede una cella e le dà il nome passi. : number dice che dentro ci andranno numeri (ne parliamo nella sezione 3).

Per metterci un valore si usa l'assegnazione, con il simbolo ⁠=:

passi = 4200;

⁠= non vuol dire "è uguale" come in matematica. Vuol dire "calcola quello che c'è a destra e mettilo nella cella a sinistra". Di solito dichiarazione e assegnazione si fanno insieme:

let passi: number = 4200;
console.log(passi); // 4200

Lato macchina:

Indirizzo Nome Contenuto
100 passi 4200

Se usate una variabile prima di averle dato un valore, TypeScript vi ferma:

let passi: number;
console.log(passi); // errore: Variable 'passi' is used before being assigned.

Riassegnazione

Una variabile dichiarata con let può cambiare valore quante volte serve. Il valore nuovo sostituisce il vecchio, che va perso.

let passi: number = 4200;
passi = 6800;
passi = passi + 1000;
console.log(passi); // 7800

L'ultima riga si legge da destra: prende il valore attuale di passi (6800), aggiunge 1000, e scrive 7800 nella stessa cella.

Dopo la riga Cella 100 (passi)
let passi: number = 4200; 4200
passi = 6800; 6800
passi = passi + 1000; 7800

let e const

Con const la variabile riceve un valore una volta sola e non lo cambia più. Per questo va assegnata subito.

const giorniSettimana: number = 7;
giorniSettimana = 8; // errore: Cannot assign to 'giorniSettimana' because it is a constant.

Quale usare? Partite da const. Passate a let solo se la variabile deve cambiare, come un contatore o un totale che cresce. Chi legge il codice capisce subito quali valori restano fissi.

E var?

Nel codice JavaScript vecchio trovate var, il modo originale di dichiarare variabili. Ha regole poco intuitive e oggi non si usa più. Noi useremo solo let e const.

I nomi

Le regole del linguaggio:

  • un nome contiene lettere, cifre, _ e $, ma non può iniziare con una cifra;
  • niente spazi e niente trattini: voto finale e voto-finale non sono nomi validi;
  • maiuscole e minuscole contano: voto e Voto sono due variabili diverse;
  • non si possono usare le parole del linguaggio, come let, const, if, for.

Le convenzioni del corso:

  • nomi in italiano che dicono cosa contiene la variabile: temperaturaMassima, non t o x;
  • camelCase: prima parola minuscola, le altre con l'iniziale maiuscola (numeroLibriPrestati).
const titoloLibro: string = "Il barone rampante";
let copieDisponibili: number = 3;
let inPrestito: boolean = false;
Nel notebook: 01-memoria-e-variabili.ipynb

3. Tipi e compilatore

I tipi primitivi

Ogni valore ha un tipo, che dice che genere di dato è e cosa ci si può fare. I tipi di base, detti primitivi, sono tre:

Tipo Cosa contiene Esempi
number Numeri, interi e con la virgola (che si scrive con il punto) 42, -3, 36.6
string Testo, tra virgolette doppie, singole o apici inversi "Ada", 'Milano', `ciao`
boolean Vero o falso, e niente altro true, false

Ci sono anche null e undefined, che indicano l'assenza di un valore. Li incontrerete nei messaggi di errore, ma per ora non servono.

Lato macchina, i valori primitivi stanno dentro la cella della variabile:

Indirizzo Nome Contenuto
100 temperatura 21.5
101 citta "Bologna"
102 piove false

Annotazione e inferenza

Il tipo si può scrivere dopo il nome, con i due punti. Si chiama annotazione:

const temperatura: number = 21.5;
const citta: string = "Bologna";
const piove: boolean = false;

Se il valore è già lì, TypeScript capisce il tipo da solo. Si chiama inferenza:

const temperatura = 21.5;   // TypeScript deduce: number
let citta = "Bologna";      // TypeScript deduce: string
citta = 25;                 // errore: Type 'number' is not assignable to type 'string'.

Il tipo resta quello deciso all'inizio, anche se non l'avete scritto. Nel corso, all'inizio, lo scriviamo sempre: obbliga a decidere che genere di dato si sta maneggiando.

Con e senza tipi

JavaScript non controlla i tipi: una variabile può contenere un numero e un attimo dopo un testo. Quando mescolate tipi diversi, JavaScript non si ferma. Cerca di indovinare cosa volevate e converte i valori da solo. A volte indovina male.

In TypeScript il tipo any spegne i controlli, e fa tornare il comportamento di JavaScript:

let bottiglie: any = "5";      // un numero letto da un modulo arriva spesso come testo
console.log(bottiglie * 2);    // 10    il testo diventa numero
console.log(bottiglie + 2);    // "52"  il numero diventa testo, e i due si attaccano
console.log(bottiglie - 1);    // 4     di nuovo numero

Il programma gira senza nessun errore, e i conti sono sbagliati. Ve ne accorgete solo guardando il risultato, se lo guardate. In un'applicazione vera se ne accorge un cliente.

Con i tipi giusti lo stesso codice non parte nemmeno:

let bottiglie: number = "5";   // errore: Type 'string' is not assignable to type 'number'.
const parola: string = "ciao";
console.log(parola * 2);       // errore: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.

TypeScript ha trovato i problemi prima di eseguire, leggendo solo il codice.

Il tipo deve essere quello giusto

TypeScript permette testo + numero, perché attaccare un numero a un testo è una cosa che si fa spesso ("Tavolo " + 4). Se dichiarate bottiglie come string, bottiglie + 2 dà "52" senza errori. I tipi vi proteggono quando dicono la verità sui dati.

Il compilatore

Il programma che legge il codice TypeScript e lo controlla si chiama compilatore (tsc). Fa due cose:

  1. controlla i tipi, e se trova errori li elenca con riga e colonna;
  2. traduce il codice in JavaScript, che è il codice che poi viene eseguito.

Da qui due momenti diversi in cui può arrivare un errore:

Quando Chi lo trova Esempio
A tempo di compilazione, prima di eseguire Il compilatore, leggendo il codice Un testo messo in una variabile number
A tempo di esecuzione (runtime), mentre il programma gira Nessuno lo prevede: il programma si ferma, o va avanti con un valore sbagliato Leggere un elemento che non esiste in un elenco (sezione 6)

Un errore trovato dal compilatore costa pochi secondi: lo leggete, lo correggete. Un errore a runtime può restare nascosto per settimane, e compare quando il programma lo usa qualcun altro. Il compilatore non trova tutto, ma quello che trova non arriva mai a runtime.

Nei notebook il kernel fa la compilazione per voi a ogni Shift+Invio. Per questo una cella con un errore di tipo non viene eseguita.

TypeScript diventa JavaScript

I browser e Node.js (il programma che esegue JavaScript fuori dal browser) capiscono solo JavaScript. Quindi il compilatore trasforma TypeScript in JavaScript, e nel passaggio i tipi spariscono:

TypeScript (quello che scrivete) JavaScript (quello che gira)
let eta: number = 19; let eta = 19;
const nome: string = "Ada"; const nome = "Ada";
console.log(nome, eta); console.log(nome, eta);

Un compilatore che traduce da un linguaggio a un altro dello stesso livello si chiama transpiler. I tipi servono solo al controllo: quando il programma gira non esistono più. Il notebook 02 lo fa vedere con la funzione ts.transpile. Con le impostazioni di base ts.transpile scrive var al posto di let e const, perché produce un JavaScript compatibile con i browser più vecchi.

Le differenze tra compilatore, interprete e transpiler sono in Compilatore, interprete e transpiler.

Nel notebook: 02-tipi-e-compilatore.ipynb

4. Operazioni

Un'espressione è un pezzo di codice che produce un valore: 3 + 4, prezzo * 2, eta >= 18. Gli operatori sono i simboli che combinano i valori.

Aritmetiche

Operatore Cosa fa Esempio Risultato
+ Somma 7 + 3 10
- Sottrazione 7 - 3 4
* Moltiplicazione 7 * 3 21
/ Divisione 7 / 2 3.5
% Resto della divisione intera 7 % 3 1
** Potenza 2 ** 3 8

La divisione non arrotonda: 7 / 2 dà 3.5, non 3 come in altri linguaggi. Il resto % ha usi concreti: un numero è pari se n % 2 === 0, e minuti % 60 dà i minuti che avanzano dopo aver contato le ore.

const minutiAllenamento: number = 135;
const ore: number = Math.floor(minutiAllenamento / 60); // 2, Math.floor toglie la parte decimale
const minuti: number = minutiAllenamento % 60;          // 15
console.log(ore, minuti); // 2 15

Dividere per zero non dà errore: il risultato è Infinity. E 0 / 0 dà NaN ("Not a Number"), un valore che vuol dire "questo conto non ha senso".

Precedenza

Come in matematica, *, / e % si calcolano prima di + e -. Le parentesi tonde cambiano l'ordine.

const votoScritto: number = 24;
const votoOrale: number = 30;
const mediaSbagliata: number = votoScritto + votoOrale / 2;   // 24 + 15 = 39
const media: number = (votoScritto + votoOrale) / 2;          // 54 / 2 = 27

Nel dubbio, mettete le parentesi. Non costano niente e chi legge non deve ricordarsi le regole.

Stringhe

Con le stringhe, + attacca i testi uno dopo l'altro. Si chiama concatenazione.

const nome: string = "Ada";
const cognome: string = "Lovelace";
const completo: string = nome + " " + cognome; // "Ada Lovelace"

Quando i pezzi sono tanti, i + diventano scomodi. Le template string usano gli apici inversi (`) e mettono le espressioni dentro ${ }:

const brano: string = "Bohemian Rhapsody";
const durataSecondi: number = 354;
const messaggio: string = `${brano} dura ${Math.floor(durataSecondi / 60)} minuti e ${durataSecondi % 60} secondi`;
console.log(messaggio); // Bohemian Rhapsody dura 5 minuti e 54 secondi

L'apice inverso sulla tastiera italiana: AltGr+' su Linux, Alt+96 sul tastierino numerico su Windows, Option+\ su Mac.

Una stringa conosce la sua lunghezza:

const password: string = "girasole";
console.log(password.length); // 8

Incremento e assegnazioni composte

Aggiornare una variabile partendo dal suo valore è così comune che ci sono forme brevi:

Forma breve Equivale a
x += 5 x = x + 5
x -= 5 x = x - 5
x *= 2 x = x * 2
x++ x = x + 1
x-- x = x - 1
let postiLiberi: number = 40;
postiLiberi -= 3;      // 37, una prenotazione da 3
postiLiberi--;         // 36, una da 1
postiLiberi *= 2;      // 72, aperta la seconda sala
console.log(postiLiberi); // 72

+= funziona anche con le stringhe: frase += "!" attacca un punto esclamativo in fondo.

Confronti

Un confronto produce un boolean: true o false.

Operatore Significato Esempio Risultato
⁠=== Uguale 5 === 5 true
!== Diverso 5 !== 3 true
< Minore 3 < 5 true
> Maggiore 3 > 5 false
<= Minore o uguale 5 <= 5 true
>= Maggiore o uguale 4 >= 5 false
const etaMinima: number = 18;
const eta: number = 17;
const puoGuidare: boolean = eta >= etaMinima;
console.log(puoGuidare); // false
⁠= assegna, ⁠=== confronta

Un ⁠= solo mette un valore in una variabile. Per chiedere "sono uguali?" servono tre ⁠=. Esiste anche ⁠== con due, che prima di confrontare converte i valori come visto con any: in JavaScript 5 == "5" dà true. Usate sempre ⁠=== e !==. TypeScript di solito segnala come errore il confronto tra un numero e un testo.

Le stringhe si confrontano lettera per lettera: "ciao" === "ciao" è true, "Ciao" === "ciao" è false.

Operatori logici

Combinano dei boolean:

Operatore Nome È true quando
&& E (AND) Entrambi sono true
\|\| O (OR) Almeno uno è true
! NON (NOT) Il valore è false (lo rovescia)
a b a && b a \|\| b !a
true true true true false
true false false true false
false true false true true
false false false false true
const temperatura: number = 24;
const piove: boolean = false;
const giornataDaParco: boolean = temperatura > 20 && !piove;          // true
const servoOmbrello: boolean = piove || temperatura > 32;             // false

I decimali non sono esatti

console.log(0.1 + 0.2);          // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3);  // false

Non è un errore di TypeScript. Il computer conserva i numeri con la virgola con un numero limitato di cifre, e alcuni valori semplici per noi, come 0.1, per lui non sono esatti. La conseguenza pratica: non confrontate mai due numeri decimali con ⁠===. Per mostrarli arrotondati c'è toFixed:

const totale: number = 0.1 + 0.2;
console.log(totale.toFixed(2)); // "0.30", attenzione: toFixed restituisce una stringa

Il perché, e come si confrontano i decimali, sta in Perché 0.1 + 0.2 non fa 0.3.

Nel notebook: 03-operazioni.ipynb

5. Condizioni

Finora i programmi eseguivano tutte le istruzioni, in ordine. Con le condizioni il programma sceglie quali eseguire.

if

const temperatura: number = 38.2;
if (temperatura >= 37.5) {
  console.log("Hai la febbre: resta a casa.");
}
console.log("Controllo finito.");

Tra le tonde c'è la condizione, un'espressione boolean. Se è true, il programma esegue il blocco tra le graffe. Se è false, lo salta e prosegue dopo. L'ultima riga si esegue in ogni caso.

else ed else if

else dice cosa fare quando la condizione è falsa:

const votoEsame: number = 16;
if (votoEsame >= 18) {
  console.log("Promosso");
} else {
  console.log("Da ripetere");
}

Quando i casi sono più di due, si mettono in fila con else if. Il programma prova le condizioni dall'alto ed esegue solo il primo blocco con la condizione vera. Gli altri li salta, anche se sarebbero veri.

const temperatura: number = 12;
let consiglio: string;
if (temperatura < 5) {
  consiglio = "cappotto e sciarpa";
} else if (temperatura < 15) {
  consiglio = "giacca";
} else if (temperatura < 25) {
  consiglio = "felpa";
} else {
  consiglio = "maglietta";
}
console.log(consiglio); // "giacca"

Con 12 gradi anche temperatura < 25 è vera, ma il programma non ci arriva: si è fermato a temperatura < 15. Per questo l'ordine delle condizioni conta.

Le graffe

Se il blocco ha una riga sola, JavaScript accetta anche if (x > 0) console.log("ok"); senza graffe. Mettetele sempre: quando aggiungete una seconda riga, senza graffe quella riga resta fuori dall'if e si esegue sempre.

Condizioni composte

Con &&, || e ! una condizione può controllare più cose insieme:

const eta: number = 16;
const accompagnato: boolean = true;
if (eta >= 18 || accompagnato) {
  console.log("Puoi entrare al concerto.");
}

const giorno: string = "domenica";
const festivo: boolean = false;
if (giorno !== "domenica" && !festivo) {
  console.log("La biblioteca è aperta.");
} else {
  console.log("La biblioteca è chiusa.");
}

L'operatore ternario

Quando un if/else serve solo a scegliere tra due valori, si può scrivere in una riga:

const punti: number = 72;
const esito: string = punti >= 60 ? "superato" : "non superato";
console.log(`Test ${esito}`); // Test superato

Si legge: "condizione ? valore se vera : valore se falsa". Usatelo per scelte semplici. Se dentro c'è un altro ternario, tornate all'if.

switch

Quando confrontate la stessa variabile con tanti valori precisi, lo switch è più leggibile di una fila di else if:

const giorno: string = "mercoledì";
let corso: string;
switch (giorno) {
  case "lunedì":
  case "giovedì":
    corso = "pilates";
    break;
  case "mercoledì":
    corso = "spinning";
    break;
  case "sabato":
    corso = "yoga";
    break;
  default:
    corso = "sala pesi libera";
}
console.log(corso); // "spinning"
  • Ogni case confronta giorno con un valore, usando ⁠===.
  • break esce dallo switch. Senza break il programma continua nel case successivo, che di solito è un errore.
  • Due case uno sotto l'altro senza niente in mezzo condividono lo stesso codice (lunedì e giovedì).
  • default è il caso "nessuno dei precedenti", come l'else finale.

Lo switch confronta solo valori esatti. Per intervalli (temperatura < 15) serve l'if.

Nel notebook: 04-condizioni.ipynb

6. Array

Creare un array

Un array è un elenco ordinato di valori, tra quadre e separati da virgole:

const voti: number[] = [28, 30, 25, 27];
const playlist: string[] = ["Imagine", "Yesterday", "Wonderwall"];
const vuoto: number[] = [];

Il tipo number[] si legge "array di numeri". TypeScript controlla che dentro ci siano solo numeri:

const voti: number[] = [28, 30, "trenta"]; // errore: Type 'string' is not assignable to type 'number'.

L'indice e la lunghezza

Ogni elemento ha una posizione, l'indice, che parte da 0:

Indice 0 1 2 3
voti 28 30 25 27
const voti: number[] = [28, 30, 25, 27];
console.log(voti[0]);      // 28, il primo
console.log(voti[3]);      // 27, l'ultimo
console.log(voti.length);  // 4, quanti elementi ci sono
console.log(voti[voti.length - 1]); // 27, l'ultimo, qualunque sia la lunghezza
voti[2] = 26;              // cambia il terzo elemento
console.log(voti);         // [ 28, 30, 26, 27 ]

L'ultimo indice è sempre length - 1. Con 4 elementi gli indici vanno da 0 a 3.

Fuori dall'array

voti[10] non dà errore di compilazione: il compilatore non sa quanti elementi avrà l'array quando il programma gira. A runtime il risultato è undefined, "niente". È il primo esempio di errore che il compilatore non vede. Se poi usate quel valore, il programma si ferma:

const voti: number[] = [28, 30];
console.log(voti[10]);            // undefined
console.log(voti[10].toFixed(1)); // errore a runtime: Cannot read properties of undefined

I metodi più usati

Un metodo è un'operazione che appartiene a un valore e si chiama con il punto: voti.push(30).

Metodo Cosa fa Restituisce
push(x) Aggiunge x in fondo La nuova lunghezza
pop() Toglie l'ultimo elemento L'elemento tolto
includes(x) Controlla se x c'è true o false
indexOf(x) Cerca x L'indice della prima volta che compare, o -1 se non c'è
const scaffale: string[] = ["Dune", "Emma"];
scaffale.push("Ulisse");                  // ["Dune", "Emma", "Ulisse"]
const tolto = scaffale.pop();             // tolto vale "Ulisse", restano ["Dune", "Emma"]
console.log(scaffale.includes("Emma"));   // true
console.log(scaffale.indexOf("Emma"));    // 1
console.log(scaffale.indexOf("Ulisse"));  // -1

Lato macchina: l'array sta altrove

Un array può avere 3 elementi o 3000, e può crescere con push. Non entra in una cella. Per questo sta altrove in memoria, e la variabile contiene solo il suo indirizzo. Un indirizzo usato così si chiama riferimento.

const temperature: number[] = [18, 21, 19];
const giorni: number = 3;
Indirizzo Nome Contenuto
100 temperature → 500
101 giorni 3
500 [18, 21, 19]

La freccia → 500 vuol dire "l'array vero è alla cella 500". Quando scrivete temperature[1], il programma legge la cella 100, trova l'indirizzo 500, va lì e prende il secondo elemento.

const b = a copia l'indirizzo

Questa è la conseguenza più importante, e la fonte di molti errori:

const originale: number[] = [18, 21, 19];
const altra = originale;
altra.push(25);
console.log(originale); // [ 18, 21, 19, 25 ]  anche originale è cambiato

const altra = originale copia il contenuto della cella 100. Il contenuto è un indirizzo, quindi ora due variabili puntano allo stesso array:

Indirizzo Nome Contenuto
100 originale → 500
101 altra → 500
500 [18, 21, 19, 25]

C'è un array solo, con due nomi. Con i numeri non succede, perché il numero sta dentro la cella e si copia il numero:

let a: number = 10;
let b = a;
b = 99;
console.log(a); // 10

const con un array

const spesa: string[] = ["pane", "latte"];
spesa.push("uova");     // va bene
spesa[0] = "focaccia";  // va bene
spesa = ["mele"];       // errore: Cannot assign to 'spesa' because it is a constant.

const blocca il contenuto della cella di spesa, cioè la freccia → 500. Non blocca l'array alla cella 500, che si può modificare. Quello che non si può fare è far puntare spesa a un altro array.

Copiare un array

Per avere un secondo array indipendente si usa lo spread, i tre puntini:

const originale: number[] = [18, 21, 19];
const copia: number[] = [...originale];
copia.push(25);
console.log(originale); // [ 18, 21, 19 ]
console.log(copia);     // [ 18, 21, 19, 25 ]

[...originale] crea un array nuovo e ci mette dentro, uno per uno, gli elementi di originale:

Indirizzo Nome Contenuto
100 originale → 500
101 copia → 600
500 [18, 21, 19]
600 [18, 21, 19, 25]

Più esempi, e cosa cambia con gli oggetti, in Copiare un valore, copiare un riferimento.

Nel notebook: 05-array.ipynb

7. Cicli

Un ciclo ripete un blocco di istruzioni. Ogni ripetizione si chiama iterazione.

while

while ripete il blocco finché la condizione è vera:

let risparmi: number = 0;
let settimana: number = 0;
while (risparmi < 100) {
  risparmi += 15;
  settimana++;
}
console.log(`Servono ${settimana} settimane, risparmi ${risparmi} euro`); // Servono 7 settimane, risparmi 105 euro

Prima di ogni iterazione il programma controlla la condizione. Se è falsa fin dall'inizio, il blocco non si esegue mai. Usate while quando non sapete in anticipo quante volte ripetere.

for

Quando il numero di ripetizioni è noto, si usa il for. Tra le tonde ha tre parti separate da ;:

for (let i = 0; i < 4; i++) {
  console.log(`Serie numero ${i + 1}`);
}
Parte Codice Quando si esegue
Inizio let i = 0 Una volta sola, prima di tutto
Condizione i < 4 Prima di ogni iterazione: se è falsa, il ciclo finisce
Aggiornamento i++ Dopo ogni iterazione

Passo passo:

Iterazione i all'inizio i < 4 Cosa stampa i dopo i++
1 0 true Serie numero 1 1
2 1 true Serie numero 2 2
3 2 true Serie numero 3 3
4 3 true Serie numero 4 4
4 false (il ciclo finisce)

Il blocco si esegue 4 volte, con i che vale 0, 1, 2, 3. Il nome i (da "indice") è una convenzione.

Il for serve soprattutto a scorrere un array, perché i può fare da indice:

const passiSettimana: number[] = [4200, 8100, 6500, 10200, 3900];
for (let i = 0; i < passiSettimana.length; i++) {
  console.log(`Giorno ${i + 1}: ${passiSettimana[i]} passi`);
}

La condizione è i < passiSettimana.length, con < e non <=: con 5 elementi l'ultimo indice è 4.

for...of

Se l'indice non serve, for...of dà direttamente gli elementi, uno per iterazione:

const playlist: string[] = ["Imagine", "Yesterday", "Wonderwall"];
for (const brano of playlist) {
  console.log(`In riproduzione: ${brano}`);
}

Niente indice, niente length, niente rischio di uscire dall'array. Quando vi serve solo il valore, preferitelo. Se vi serve la posizione (il giorno 1, il giorno 2) usate il for classico.

Schemi tipici

Quasi tutti i cicli su un array seguono uno di questi quattro schemi.

Somma. Una variabile parte da 0 e a ogni iterazione aggiunge l'elemento:

const minutiCorsa: number[] = [30, 45, 25, 50];
let totale: number = 0;
for (const minuti of minutiCorsa) {
  totale += minuti;
}
console.log(totale);                        // 150
console.log(totale / minutiCorsa.length);   // 37.5, la media

Conteggio. Un contatore parte da 0 e cresce solo quando l'elemento rispetta una condizione:

const temperature: number[] = [12, 25, 31, 28, 19, 33];
let giorniCaldi: number = 0;
for (const t of temperature) {
  if (t > 27) {
    giorniCaldi++;
  }
}
console.log(giorniCaldi); // 3

Massimo. Si parte dal primo elemento e si tiene il più grande visto finora:

const punteggi: number[] = [71, 88, 64, 92, 79];
let massimo: number = punteggi[0];
for (const p of punteggi) {
  if (p > massimo) {
    massimo = p;
  }
}
console.log(massimo); // 92

Si parte da punteggi[0] e non da 0: se i valori fossero tutti negativi, partendo da 0 il massimo sarebbe sbagliato.

Filtro. Si costruisce un array nuovo con i soli elementi che rispettano la condizione:

const durate: number[] = [210, 354, 185, 412, 240];
const braniLunghi: number[] = [];
for (const d of durate) {
  if (d > 300) {
    braniLunghi.push(d);
  }
}
console.log(braniLunghi); // [ 354, 412 ]

break

break esce subito dal ciclo, senza finire le iterazioni. Serve quando avete trovato quello che cercavate:

const libriInPrestito: string[] = ["Dune", "Emma", "Ulisse", "Lolita"];
const cercato: string = "Emma";
let trovatoAllaPosizione: number = -1;
for (let i = 0; i < libriInPrestito.length; i++) {
  if (libriInPrestito[i] === cercato) {
    trovatoAllaPosizione = i;
    break;
  }
}
console.log(trovatoAllaPosizione); // 1

Esiste anche continue, che salta il resto dell'iterazione corrente e passa alla successiva.

Il ciclo infinito

Se la condizione non diventa mai falsa, il ciclo non finisce:

let tentativi: number = 0;
while (tentativi < 3) {
  console.log(`Tentativo di connessione ${tentativi + 1}`);
  // manca tentativi++: tentativi resta 0 per sempre
}

Nel notebook ve ne accorgete perché la cella resta su [*] e non finisce mai. Fermatela dal menu Kernel → Interrupt Kernel (o con il quadratino ■ nella barra in alto). Se non risponde, Kernel → Restart Kernel: il kernel riparte da zero e perde tutte le variabili, quindi poi rieseguite le celle che servono (Run All).

Ogni ciclo deve cambiare a ogni iterazione qualcosa da cui dipende la condizione, altrimenti la condizione non diventa mai falsa.

Nel notebook: 06-cicli.ipynb

8. Riepilogo

  • Un programma è un elenco di istruzioni eseguite in ordine. I dati stanno in memoria, in celle con un indirizzo, e una variabile è una cella con un nome.
  • ⁠= assegna, ⁠=== confronta. Partite da const, usate let solo per ciò che cambia.
  • Ogni valore ha un tipo. TypeScript controlla i tipi prima di eseguire, poi traduce in JavaScript e i tipi spariscono.
  • I numeri decimali non sono esatti: niente ⁠=== tra decimali.
  • if/else if/else esegue il primo blocco con la condizione vera. switch confronta una variabile con valori precisi, e ogni case vuole il suo break.
  • Un array sta altrove in memoria e la variabile ne contiene l'indirizzo: const b = a non copia l'array, [...a] sì.
  • Per scorrere un array: for...of quando serve solo il valore, for con l'indice quando serve la posizione. Somma, conteggio, massimo e filtro coprono quasi tutti i casi.