034.3 Lezione 1

La struttura di controllo più semplice è data dall’istruzione if, che eseguirà l’istruzione immediatamente successiva se la condizione specificata è vera. JavaScript considera le condizioni vere se il valore valutato è diverso da zero. Qualsiasi cosa all’interno della parentesi dopo la parola if (gli spazi sono ignorati) sarà interpretata come una condizione. Nell’esempio seguente, il numero letterale 1 è la condizione:

Il numero 1 è scritto esplicitamente in questa condizione di esempio, quindi è trattato come un valore costante (rimane lo stesso durante l’esecuzione dello script) e darà sempre come risultato vero quando viene usato come espressione condizionale. La parola true (senza le doppie virgolette) potrebbe anche essere usata al posto di 1, dato che è anche trattata come un valore letterale vero dal linguaggio. L’istruzione console.log mostra i suoi argomenti nella console del browser.

Anche se sintatticamente corretto, usare espressioni costanti nelle condizioni non è molto utile. In un’applicazione reale, probabilmente vorresti testare la veridicità di una variabile:

Il valore assegnato alla variabile my_number (3) non è zero, quindi produce true. Ma questo esempio non è di uso comune, perché raramente si ha bisogno di verificare se un numero è uguale a zero. È molto più comune confrontare un valore con un altro e verificare se il risultato è vero:

L’operatore di confronto doppio-uguale (==) viene utilizzato perché l’operatore uguale (=) è già definito come operatore di assegnazione. Il valore su ciascun lato dell’operatore è chiamato operando. L’ordine degli operandi non ha importanza e qualsiasi espressione che restituisce un valore può essere un operando. Ecco un elenco di altri operatori di confronto disponibili:

Di solito, non importa se l’operando a sinistra dell’operatore è una stringa e l’operando a destra è un numero, purché JavaScript sia in grado di convertire l’espressione in un confronto significativo. Quindi la stringa contenente il carattere 1 sarà trattata come il numero 1 rispetto a una variabile numerica. Per assicurarsi che l’espressione restituisca true solo se entrambi gli operandi sono dello stesso tipo e valore, è necessario utilizzare l’operatore di identità rigorosa === invece di ==. Allo stesso modo, l’operatore stretto di non identità !== viene valutato come true se il primo operando non è dello stesso tipo e valore del secondo operatore.

Opzionalmente, la struttura di controllo if può eseguire un’istruzione alternativa quando l’espressione viene valutata come falsa:

L’istruzione else dovrebbe seguire immediatamente l’istruzione if. Finora stiamo eseguendo solo un’istruzione quando la condizione è soddisfatta. Per eseguire più di un’istruzione, devi racchiuderle tra parentesi graffe:

Un gruppo di una o più istruzioni delimitate da una coppia di parentesi graffe è noto come _ dichiarazione di blocco_. È comune usare dichiarazioni di blocco anche quando c’è una sola istruzione da eseguire, per rendere lo stile di codifica coerente in tutto lo script. Inoltre, JavaScript non richiede che le parentesi graffe o qualsiasi dichiarazione siano su linee separate, ma farlo migliora la leggibilità e rende più facile la manutenzione del codice.

Le strutture di controllo possono essere annidate l’una dentro l’altra, ma è importante non confondere le parentesi graffe di apertura e di chiusura di ogni dichiarazione di blocco:

Le espressioni valutate dall’istruzione if possono essere più elaborate di semplici confronti. Questo è il caso dell’esempio precedente, in cui l’espressione aritmetica my_number % 2 è stata impiegata all’interno delle parentesi nell’istruzione nidificata if. L’operatore % restituisce il resto dopo aver diviso il numero alla sua sinistra per il numero alla sua destra. Gli operatori aritmetici come % hanno la precedenza sugli operatori di confronto come ==, quindi il confronto utilizzerà il risultato dell’espressione aritmetica come operando sinistro.

In molte situazioni le strutture condizionali annidate possono essere combinate in una singola struttura usando gli operatori logici. Se fossimo interessati solo ai numeri pari positivi, per esempio, si potrebbe usare una singola struttura if:

Il doppio operatore && (ampersand) nell’espressione valutata è l’operatore logico AND. Valuta come vero solo se l’espressione alla sua sinistra e l’espressione alla sua destra sono vere. Se vuoi abbinare numeri che siano positivi o pari, dovresti invece usare l’operatore ||, che sta per l’operatore logico OR:

In questo esempio, solo i numeri dispari negativi non corrisponderanno ai criteri imposti dall’espressione composta. Se avete l’intento opposto, cioè di far corrispondere solo i numeri dispari negativi, aggiungi l’operatore logico NOT ! all’inizio dell’espressione:

L’aggiunta delle parentesi nell’espressione composta forza l’espressione racchiusa da esse a essere valutata per prima. Senza queste parentesi l’operatore NOT si applicherebbe solo a my_number > 0 e poi verrebbe valutata l’espressione OR. Gli operatori && e || sono conosciuti come operatori logici binari, perché richiedono due operandi. ! è conosciuto come operatore logico unario, perché richiede “un solo” operando.

Sebbene la struttura if sia abbastanza versatile e sufficiente per controllare il flusso del programma, la struttura di controllo switch può essere più appropriata quando occorre valutare risultati diversi da vero o falso. Per esempio, se vogliamo intraprendere un’azione distinta per ogni elemento scelto da una lista, sarà necessario scrivere una struttura if per ogni valutazione:

In questo esempio, una variabile ausiliaria found è usata da tutte le strutture if per scoprire se si è verificata una corrispondenza. In un caso come questo, la struttura switch svolgerà lo stesso compito, ma in modo più succinto:

Ogni case annidato è chiamato clausola. Quando una clausola corrisponde all’espressione valutata, esegue le istruzioni che seguono i due punti fino all’istruzione break. L’ultima clausola non ha bisogno di un’istruzione break ed è spesso usata per impostare l’azione predefinita quando non ci sono altre corrispondenze. Come visto nell’esempio, la variabile ausiliaria non è necessaria nella struttura switch.

Se più di una clausola fa scattare la stessa azione, si possono combinare due o più condizioni case:

Negli esempi precedenti, le strutture if e switch erano ben adatte a compiti che devono essere eseguiti solo una volta dopo aver passato uno o più test condizionali. Tuttavia, ci sono situazioni in cui un compito deve essere eseguito ripetutamente — in un cosiddetto loop — finché la sua espressione condizionale continua a risultare vera. Se avete bisogno di sapere se un numero è primo, per esempio, dovrete controllare se dividendo questo numero per qualsiasi intero maggiore di 1 e minore di se stesso si ha un resto uguale a 0. Se è così, il numero ha un fattore intero e non è primo. (Questo non è un metodo rigoroso o efficiente per trovare i numeri primi, ma funziona come semplice esempio). Le strutture di controllo dei loop sono più adatte a questi casi, in particolare l’istruzione while:

La dichiarazione di blocco che segue l’istruzione while verrà eseguita ripetutamente finché la condizione factor < candidate è vera. Verrà eseguita almeno una volta, finché inizializzeremo la variabile factor con un valore inferiore a candidate. La struttura if annidata nella struttura while valuterà se il resto di candidate diviso per factor è zero. Se è così, il numero candidate non è primo e il ciclo può finire. L’istruzione break terminerà il ciclo e l’esecuzione salterà alla prima istruzione dopo il blocco while.

Nota che il risultato della condizione usata dall’istruzione while deve cambiare a ogni ciclo, altrimenti l’istruzione di blocco andrà in loop “per sempre”. Nell’esempio, incrementiamo la variabile factor — il prossimo divisore che vogliamo provare — e questo garantisce che il ciclo finisca a un certo punto.

Questa semplice implementazione di un tester di numeri primi funziona come previsto. Tuttavia, sappiamo che un numero che non è divisibile per due non sarà divisibile per nessun altro numero pari. Pertanto, potremmo semplicemente saltare i numeri pari aggiungendo un’altra istruzione if:

L’istruzione continue è simile all’istruzione break, ma invece di finire questa iterazione del ciclo, ignorerà il resto del blocco del ciclo e inizierà una nuova iterazione. Nota che la variabile factor è stata modificata prima dell’istruzione continue, altrimenti il ciclo avrebbe lo stesso risultato nella prossima iterazione. Questo esempio è troppo semplice e saltare una parte del ciclo non migliorerà realmente le sue prestazioni, ma saltare le istruzioni ridondanti è molto importante quando si scrivono applicazioni efficienti.

I cicli sono così comunemente usati che esistono in molte varianti diverse. Il ciclo for è particolarmente adatto per iterare attraverso valori sequenziali, perché ci permette di definire le regole del ciclo in una sola riga:

Questo esempio produce esattamente lo stesso risultato dell’esempio precedente while, ma la sua espressione parentetica include tre parti, separate da punto e virgola: l’inizializzazione (let factor = 2), la condizione del ciclo (factor < candidate), e l’espressione finale da valutare alla fine di ogni iterazione del ciclo (factor+`). Le istruzioni `continue` e `break` si applicano anche ai cicli `for`. L'espressione finale tra le parentesi (`factor+) sarà valutata dopo l’istruzione continue, quindi non dovrebbe essere all’interno dell’istruzione di blocco, altrimenti sarà incrementata due volte prima della prossima iterazione.

JavaScript ha tipi speciali di cicli for per lavorare con oggetti simili ad array. Potremmo, per esempio, controllare un array di variabili invece di una sola:

L’istruzione for (candidate of candidates) assegna un elemento dell’array candidates alla variabile candidate e lo usa nella dichiarazione di blocco, ripetendo il processo per ogni elemento dell’array. Non c’è bisogno di dichiarare separatamente candidate, perché il ciclo for lo definisce. Infine, lo stesso codice dell’esempio precedente è stato annidato in questa nuova istruzione a blocchi, ma questa volta testando ogni candidate nell’array.