Introduzione
I cicli sono uno degli strumenti più importanti in JavaScript quando devi ripetere un’operazione più volte. Servono per elaborare liste di dati, controllare stati, leggere input, attendere una condizione e molto altro. Tra i cicli più usati troviamo for, while e do...while.
In questo tutorial scegliamo un sotto-argomento molto pratico: gestire una sequenza di input utente con validazione. È un caso reale che capita spesso in applicazioni web, form, console app o script di automazione. L’obiettivo è capire quando usare ciascun ciclo, come evitare errori comuni e come scrivere codice leggibile e robusto.
Vedremo un esempio completo in JavaScript che simula una piccola procedura interattiva: chiedere all’utente un numero valido, ripetere la richiesta finché l’input non è corretto, e poi usare un ciclo for per calcolare una sequenza di valori.
Codice completo
// Simulazione di input utente in un contesto browser.
// In una vera pagina web potresti sostituire prompt() con un campo input HTML.
function chiediNumeroValido(messaggio) {
let input;
let numero;
// do...while: esegue almeno una volta il blocco
do {
input = prompt(messaggio);
// Se l´utente preme Annulla, prompt restituisce null
if (input === null) {
alert("Operazione annullata dall´utente.");
return null;
}
numero = Number(input);
} while (Number.isNaN(numero) || numero < 0);
return numero;
}
function generaTabellaMoltiplicativa(base, limite) {
console.log(`Tabella del ${base} fino a ${limite}`);
// for: perfetto quando sai quante volte ripetere il ciclo
for (let i = 1; i <= limite; i++) {
const risultato = base * i;
console.log(`${base} x ${i} = ${risultato}`);
}
}
function eseguiProgramma() {
const numero = chiediNumeroValido("Inserisci un numero intero positivo:");
if (numero === null) {
return;
}
// while: utile quando vuoi ripetere finché una condizione resta vera
let tentativi = 3;
while (tentativi > 0) {
console.log(`Controllo in corso... tentativi rimasti: ${tentativi}`);
tentativi--;
}
// for: usato qui per una ripetizione deterministica
generaTabellaMoltiplicativa(numero, 10);
}
eseguiProgramma();Spiegazione
Il codice sopra mostra tre situazioni diverse, ognuna adatta a un tipo di ciclo specifico.
1. do...while per validare un input almeno una volta
La funzione chiediNumeroValido usa do...while perché vogliamo che la richiesta venga mostrata almeno una volta, anche se il primo input fosse già corretto. Questo è ideale per i casi in cui devi eseguire un’azione iniziale prima di controllare la condizione di uscita.
Nel nostro caso:
- l’utente inserisce un valore tramite prompt();
- se preme Annulla, il programma termina restituendo null;
- il valore viene convertito con Number();
- il ciclo continua se il risultato è NaN oppure se il numero è negativo.
Questo approccio è utile per evitare input non validi senza dover duplicare controlli in più punti del codice.
2. while per una condizione che può cambiare durante l’esecuzione
La sezione con while simula un controllo con un numero limitato di tentativi. Il ciclo continua finché tentativi > 0.
Il punto importante è che la condizione viene verificata prima di ogni iterazione. Questo significa che, se la condizione fosse già falsa all’inizio, il blocco non verrebbe eseguito nemmeno una volta.
Nel nostro esempio decrementiamo tentativi a ogni giro. Questo è fondamentale: senza una modifica della variabile di controllo, il ciclo rischierebbe di diventare infinito.
3. for per iterazioni con numero noto di ripetizioni
La funzione generaTabellaMoltiplicativa usa il ciclo for perché sappiamo esattamente quante volte ripetere l’operazione: da 1 fino a limite.
Il ciclo for è spesso la scelta migliore quando:
- conosci il numero di iterazioni;
- devi scorrere un intervallo numerico;
- hai bisogno di un contatore esplicito.
La struttura classica è molto leggibile:
- inizializzazione:
let i = 1 - condizione:
i <= limite - aggiornamento:
i++
Quando scegliere un ciclo invece di un altro
Una regola pratica utile è questa:
- for: quando conosci già il numero di ripetizioni;
- while: quando dipendi da una condizione che può cambiare durante l’esecuzione;
- do...while: quando vuoi eseguire il blocco almeno una volta prima del controllo.
Questa distinzione ti aiuta a scrivere codice più pulito e a evitare soluzioni forzate o poco leggibili.
Best practice
- Evita cicli infiniti: assicurati sempre che la variabile di controllo cambi in modo prevedibile.
- Scegli il ciclo più adatto: non usare for solo per abitudine se while o do...while esprimono meglio la logica.
- Valida sempre gli input: soprattutto quando i dati arrivano dall’utente, da API o da form HTML.
- Usa nomi chiari: variabili come tentativi, limite o numero rendono il codice più leggibile.
- Separa le responsabilità: una funzione per chiedere l’input, una per elaborarlo, una per stampare il risultato.
- Gestisci i casi limite: per esempio input vuoto, null, valori negativi o non numerici.
Un errore comune è mescolare logica di validazione e logica di business nello stesso blocco. Separarle rende il codice più facile da testare e mantenere.
Riepilogo
In questo tutorial abbiamo visto un uso pratico dei cicli in JavaScript attraverso la gestione di input e ripetizioni controllate. Il ciclo do...while è ideale quando devi eseguire almeno una volta un’azione, while funziona bene quando la ripetizione dipende da una condizione dinamica, mentre for è perfetto per iterazioni con numero noto di passaggi.
La scelta del ciclo giusto non è solo una questione di sintassi: migliora la leggibilità, riduce i bug e rende il codice più vicino alla logica del problema reale che vuoi risolvere.
Se impari a usare bene questi tre cicli, avrai una base solida per affrontare script, algoritmi e interazioni più complesse in JavaScript.
Approfondisci con risorse ufficiali
- MDN - for: documentazione completa sul ciclo
fore le sue varianti. - MDN - while: guida ufficiale all’uso del ciclo
while. - MDN - do...while: spiegazione dettagliata del ciclo
do...while. - MDN - Number(): conversione dei valori in numeri e gestione dei casi non validi.
- MDN - Number.isNaN(): controllo affidabile per verificare se un valore è
NaN.