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.
- Aprite https://its-notebook.ebattistella.com e accedete con l'account della scuola.
- Si apre JupyterLab, con la cartella
lezioni. Dentro ci sono i notebook del corso, numerati:01-memoria-e-variabili.ipynb,02-tipi-e-compilatore.ipynbe così via. Doppio clic per aprirne uno. - Un notebook è fatto di celle. Le celle di testo spiegano, le celle di codice si eseguono.
- Per eseguire una cella ci cliccate dentro e premete Shift+Invio. Il risultato compare sotto la cella, e il cursore passa alla cella successiva.
- Per eseguire tutto il notebook dall'inizio: menu Run → Run All Cells.
- 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à.
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.
01-memoria-e-variabili.ipynb2. 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.
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 finaleevoto-finalenon sono nomi validi; - maiuscole e minuscole contano:
votoeVotosono 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, nontox; - 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;
01-memoria-e-variabili.ipynb3. 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.
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:
- controlla i tipi, e se trova errori li elenca con riga e colonna;
- 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.
02-tipi-e-compilatore.ipynb4. 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, === confrontaUn = 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.
03-operazioni.ipynb5. 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.
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
caseconfrontagiornocon un valore, usando===. breakesce dalloswitch. Senzabreakil programma continua nelcasesuccessivo, che di solito è un errore.- Due
caseuno sotto l'altro senza niente in mezzo condividono lo stesso codice (lunedì e giovedì). defaultè il caso "nessuno dei precedenti", come l'elsefinale.
Lo switch confronta solo valori esatti. Per intervalli (temperatura < 15) serve l'if.
04-condizioni.ipynb6. 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.
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.
05-array.ipynb7. 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.
06-cicli.ipynb8. 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 daconst, usateletsolo 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/elseesegue il primo blocco con la condizione vera.switchconfronta una variabile con valori precisi, e ognicasevuole il suobreak.- Un array sta altrove in memoria e la variabile ne contiene l'indirizzo:
const b = anon copia l'array,[...a]sì. - Per scorrere un array:
for...ofquando serve solo il valore,forcon l'indice quando serve la posizione. Somma, conteggio, massimo e filtro coprono quasi tutti i casi.