Introduzione
Quando si scrive un programma JavaScript, non tutto va sempre secondo i piani. Un utente può inserire un valore non valido, un file può contenere dati malformati oppure una funzione può ricevere un parametro inatteso. Se questi casi non vengono gestiti, l’esecuzione del programma può interrompersi improvvisamente.
La gestione degli errori permette di riconoscere le situazioni problematiche, fornire messaggi comprensibili e mantenere il controllo sul flusso dell’applicazione. In JavaScript gli strumenti principali sono try, catch, finally e throw.
Il blocco try contiene il codice che potrebbe generare un errore. Il blocco catch viene eseguito quando si verifica un problema, mentre finally viene eseguito sempre, sia in caso di successo sia in caso di errore. Con throw è possibile generare manualmente un errore quando una condizione non è rispettata.
Codice completo
function analizzaProfilo(dati) {
try {
// Controlliamo che sia stato ricevuto un oggetto
if (typeof dati !== "object" || dati === null) {
throw new TypeError("Il profilo deve essere un oggetto.");
}
// Verifichiamo la presenza del nome
if (typeof dati.nome !== "string" || dati.nome.trim() === "") {
throw new Error("Il nome è obbligatorio.");
}
// Verifichiamo che l´età sia un numero valido
if (!Number.isInteger(dati.eta) || dati.eta < 0) {
throw new RangeError("L´età deve essere un numero intero positivo.");
}
// Simuliamo la conversione di un dato JSON
const preferenze = JSON.parse(dati.preferenze);
return {
successo: true,
messaggio: `Profilo di ${dati.nome} analizzato correttamente.`,
preferenze
};
} catch (errore) {
// Registriamo l´errore per il debugging
console.error("Errore tecnico:", errore);
// Restituiamo un messaggio adatto all´utente
return {
successo: false,
messaggio: "Impossibile analizzare il profilo.",
dettaglio: errore.message
};
} finally {
// Questa parte viene eseguita sempre
console.log("Analisi terminata.");
}
}
const profiloValido = {
nome: "Giulia",
eta: 27,
preferenze: ´{"tema":"scuro","notifiche":true}´
};
const profiloNonValido = {
nome: "",
eta: -4,
preferenze: "testo non valido"
};
console.log(analizzaProfilo(profiloValido));
console.log(analizzaProfilo(profiloNonValido));Spiegazione
Il blocco try
Nel codice, il blocco try contiene tutte le operazioni che possono fallire: i controlli sui dati e la conversione con JSON.parse(). Se tutte le istruzioni vengono completate senza problemi, la funzione restituisce un oggetto con successo: true.
Generare errori con throw
La parola chiave throw interrompe immediatamente l’esecuzione del blocco try e trasferisce il controllo al blocco catch. È utile per trasformare una condizione non valida in un errore esplicito.
JavaScript offre diversi costruttori di errore. Error rappresenta un errore generico, TypeError indica un tipo di dato scorretto e RangeError segnala un valore fuori dall’intervallo consentito. Usare il tipo appropriato rende più semplice capire il problema durante il debugging.
Gestire l’errore con catch
Il parametro errore del blocco catch contiene informazioni utili, tra cui il messaggio associato all’errore nella proprietà message. La proprietà name indica invece il tipo, per esempio "TypeError".
Nel codice, console.error() stampa i dettagli tecnici nella console del browser. All’utente viene restituito un messaggio più semplice, evitando di mostrare informazioni interne non necessarie.
Il blocco finally
Il blocco finally viene eseguito in ogni caso. È adatto per operazioni di conclusione, come nascondere un indicatore di caricamento, chiudere una risorsa o registrare la fine di un’operazione. Non dovrebbe però essere usato per nascondere gli errori o sostituire una corretta gestione del flusso.
Best practice
- Valida i dati all’ingresso: controlla i parametri prima di usarli nelle operazioni principali.
- Usa messaggi chiari: un messaggio come “L’età deve essere un numero intero positivo” è più utile di un generico “Errore”.
- Non catturare tutto indiscriminatamente: limita il blocco try alle istruzioni realmente rischiose, così è più facile individuare l’origine del problema.
- Non ignorare gli errori: un blocco catch vuoto nasconde informazioni importanti e rende il debugging molto più difficile.
- Separa log tecnico e messaggio utente: nella console puoi conservare dettagli completi, mentre nell’interfaccia devi mostrare comunicazioni semplici e sicure.
- Usa errori specifici: preferisci TypeError o RangeError quando descrivono meglio il problema.
- Non usare eccezioni per il flusso normale: throw è utile per condizioni anomale, non per sostituire ogni normale controllo
if. - Non esporre dati sensibili: evita di mostrare all’utente stack trace, percorsi interni o dettagli relativi a credenziali e configurazioni.
Durante lo sviluppo, la console del browser è uno strumento fondamentale. Oltre a console.error(), possono essere utili console.warn() per gli avvisi e i breakpoint degli strumenti per sviluppatori, che permettono di osservare valori e istruzioni passo dopo passo.
Riepilogo
La gestione degli errori è una parte essenziale della programmazione JavaScript. try racchiude il codice rischioso, catch gestisce l’errore, finally esegue le operazioni finali e throw permette di segnalare condizioni non valide.
Un’applicazione affidabile non presume che i dati siano sempre corretti: li controlla, comunica i problemi in modo comprensibile e conserva informazioni tecniche utili al programmatore. Applicare questi principi fin dall’inizio rende il codice più semplice da mantenere e più sicuro da utilizzare.
Approfondisci con risorse ufficiali
- MDN Web Docs: guida alla gestione delle eccezioni in JavaScript.
- MDN Web Docs: documentazione sui costruttori
Error,TypeErroreRangeError. - ECMAScript Language Specification: riferimento formale al comportamento delle eccezioni nel linguaggio JavaScript.
- Chrome DevTools Documentation: strumenti per console, breakpoint e debugging del codice.