Ciclo while in JavaScript: while, do...while e break

Quando non sai quante iterazioni ti servono

Un ciclo for dà il meglio quando conosci l'intervallo in anticipo: "fallo 10 volte", "scorri ogni indice di questo array". Un ciclo while serve per l'altro caso: continua finché qualcosa non cambia. Non sai quante iterazioni serviranno, conosci solo la condizione che ti fa fermare.

La forma è minima:

let count = 0;

while (count < 5) {
    console.log("count is", count);
    count++;
}

JavaScript valuta la condizione tra parentesi. Se è truthy, il blocco viene eseguito. Poi controlla di nuovo la condizione, e ancora, finché non diventa falsy. Dimentica il count++ e la condizione non cambia mai: benvenuto nel ciclo infinito.

Il modello mentale: controlla, esegui, ripeti

Perché un ciclo while abbia senso devono essere vere tre cose:

1. Qualcosa da cui dipende la condizione.
2. Un modo in cui il corpo può cambiare quel qualcosa.
3. Prima o poi, la condizione diventa falsa.

Se ne manca anche solo una, sei nei guai. Il bug classico è dimenticare il punto 2:

let count = 0;

while (count < 5) {
    console.log(count);
    // forgot to increment count - loops forever
}

Questo gira finché non termini il processo. Su un server il danno è reale. Chiediti sempre: cosa nel corpo farà diventare falsa la condizione?

Un caso reale: un punto di arresto sconosciuto

Ecco dove while batte for. Stai consumando elementi da qualche parte e non sai quanti sono finché non li hai esauriti:

const queue = ["email", "sms", "push", "webhook"];

while (queue.length > 0) {
    const job = queue.shift();
    console.log("elaborazione:", job);
}

console.log("coda vuota");

shift() rimuove e restituisce il primo elemento. Il ciclo gira finché la coda contiene qualcosa, ed esce da solo quando è vuota. Potresti scriverlo con un ciclo for, ma andresti contro la forma del problema: while si legge proprio come l'intenzione.

do...while: prima esegui, poi fai domande

do...while inverte l'ordine: esegue il corpo e poi controlla la condizione. Questo garantisce almeno un'iterazione:

let input;

do {
    input = Math.floor(Math.random() * 10);
    console.log("uscito", input);
} while (input !== 7);

console.log("finalmente è uscito un 7");

Il corpo viene sempre eseguito una volta, anche se la condizione è falsa fin dall'inizio. Confrontalo con il semplice while, dove una condizione falsa significa zero iterazioni.

Il caso di tutti i giorni: chiedere qualcosa all'utente, validare la risposta e chiedere di nuovo se non va bene. Vuoi sempre chiedere almeno una volta, quindi do...while è perfetto.

Nota il punto e virgola dopo la ) di chiusura: a differenza di while e for, do...while ne ha bisogno.

break: uscire in anticipo

break esce subito dal ciclo più vicino. È il modo per fermarti quando la condizione naturale non è proprio quella giusta per il lavoro:

const numbers = [3, 7, 2, 9, 4, 11, 6];
let firstBigOne = null;

let i = 0;
while (i < numbers.length) {
    if (numbers[i] > 10) {
        firstBigOne = numbers[i];
        break;
    }
    i++;
}

console.log("trovato:", firstBigOne);

Appena break viene eseguito, nel ciclo non gira più nulla: né il resto del corpo, né un altro controllo della condizione. Sei fuori.

while (true) con break

Quando la condizione di arresto è più facile da esprimere dentro il corpo che nell'intestazione, ribalta la struttura: cicla all'infinito ed esci con break quando hai finito.

let attempts = 0;

while (true) {
    attempts++;
    const roll = Math.floor(Math.random() * 6) + 1;

    if (roll === 6) {
        console.log(`uscito un 6 dopo ${attempts} tentativi`);
        break;
    }

    if (attempts >= 100) {
        console.log("mi arrendo");
        break;
    }
}

Due uscite: il successo e un limite di sicurezza. Il limite di sicurezza conta. Un while (true) senza un percorso di break garantito è un ciclo infinito pronto a succedere.

continue: passare all'iterazione successiva

continue salta al controllo successivo della condizione, saltando il resto del corpo dell'iterazione corrente:

let n = 0;

while (n < 10) {
    n++;
    if (n % 2 === 0) continue;
    console.log(n, "è dispari");
}

Un'insidia: se ciò che fa avanzare il ciclo si trova dopo il continue, hai appena costruito un ciclo infinito. Nell'esempio sopra, n++ è prima del continue, quindi siamo al sicuro. Mettilo dopo e n resta bloccato per sempre su un numero pari.

while o for: quale usare

Una regola pratica quasi meccanica:

• Contare o scorrere un intervallo noto → for. for (let i = 0; i < arr.length; i++) tiene l'inizializzazione del contatore, la condizione e l'incremento in una sola riga.
• Scorrere una collezione → for...of. Più pulito che gestire un indice.
• Ciclare finché uno stato non cambia → while. Elaborare una coda, fare polling, consumare uno stream, riprovare finché non va a buon fine.
• Eseguire sempre almeno una volta → do...while.

In teoria sono intercambiabili: qualsiasi for può essere riscritto come while e viceversa. Ma scegliere quello che rispecchia la forma del problema rende il codice autoesplicativo.

Cicli infiniti: l'unica regola

Ogni ciclo while ha bisogno di una risposta chiara a questa domanda: cosa lo fa fermare?

O la condizione nell'intestazione prima o poi diventerà falsa, o c'è un break che verrà sicuramente eseguito. Se non riesci a indicare una delle due cose, il ciclo non è ancora finito.

// Sbagliato: la condizione non cambia mai
let ready = false;
while (!ready) {
    console.log("in attesa...");
    // qui dentro niente cambia `ready`
}

// Giusto: il corpo influisce sulla condizione
let ready = false;
let checks = 0;
while (!ready) {
    checks++;
    if (checks >= 3) ready = true;
}

In un browser, un ciclo infinito blocca la scheda. In Node, tiene un core della CPU al massimo finché non termini il processo. Meglio accorgersene prima di andare in produzione.

Prossimo passo: for...of e for...in

while gestisce il caso "finché qualcosa non cambia". Per scorrere array, stringhe e oggetti elemento per elemento, JavaScript ha altre due forme di ciclo pensate proprio per questo: for...of e for...in, nella prossima pagina.