10.1 Blocco try...catch
La gestione delle eccezioni è un aspetto importante della programmazione che aiuta a migliorare la robustezza e l'affidabilità del codice. In JavaScript, per gestire le eccezioni si usano le parole chiave try, catch, finally e throw. Nella lezione vedremo queste parole chiave, la loro sintassi e alcuni esempi di utilizzo.
1. Blocco try...catch
La costruzione try...catch è usata per gestire gli errori che si verificano nel blocco di codice try. Se nel blocco try si verifica un errore, il controllo viene passato al blocco catch, dove l'errore può essere gestito.
Sintassi:
try {
// Codice che può generare un'eccezione
} catch (error) {
// Codice per gestire l'eccezione
}
In questo esempio, anche se la divisione per zero non genera un errore in JavaScript, se fosse un altro errore (ad esempio l'accesso a una variabile non definita), il blocco catch lo gestirebbe:
try {
let result = 10 / 0;
console.log(result);
} catch (error) {
console.error('An error occurred:', error);
}
10.2. Blocco finally
Il blocco finally è usato per eseguire il codice che deve essere eseguito indipendentemente dal fatto che si sia verificata un'eccezione nel blocco try o meno. Il blocco finally segue il blocco catch.
Sintassi:
try {
// Codice che può generare un'eccezione
} catch (error) {
// Codice per gestire l'eccezione
} finally {
// Codice che verrà eseguito in ogni caso
}
In questo esempio il messaggio This will always execute. verrà visualizzato indipendentemente dal fatto che sia stato generato un errore o meno:
try {
let result = 10 / 0;
console.log(result);
} catch (error) {
console.error('An error occurred:', error);
} finally {
console.log('This will always execute.');
}
10. 3. Operatore throw
L'operatore throw è utilizzato per lanciare esplicitamente delle eccezioni. Con esso puoi lanciare errori personalizzati.
Sintassi:
throw expression;
Dove:
expression: qualsiasi espressione o oggetto che verrà lanciato come eccezione
Esempio di utilizzo
In questo esempio viene lanciato un errore se si tenta di dividere per zero, e il blocco catch gestisce l'errore:
function divide(a, b) {
if (b === 0) {
throw new Error('Division by zero is not allowed.');
}
return a / b;
}
try {
let result = divide(10, 0);
console.log(result);
} catch (error) {
console.error('An error occurred:', error.message);
}
10.4 Esempi avanzati e utilizzo
Esempio 1: Eccezioni multiple
A volte nel blocco try possono verificarsi diversi tipi di errori. Puoi gestirli in modi diversi, usando le proprietà dell'oggetto errore.
In questo esempio gestiamo l'errore di sintassi JSON separatamente dagli altri possibili errori:
try {
JSON.parse('{ malformed JSON string }');
} catch (error) {
if (error instanceof SyntaxError) {
console.error('JSON Syntax Error:', error.message);
} else {
console.error('Unexpected Error:', error);
}
} finally {
console.log('Parsing attempt finished.');
}
Esempio 2: Blocchi try...catch annidati
È possibile utilizzare blocchi try...catch annidati per una gestione degli errori più fine.
In questo esempio l'errore che si verifica nel primo blocco try è gestito dal blocco catch interno, che poi rilancia l'errore per essere gestito dal blocco catch esterno:
try {
try {
let result = divide(10, 0);
console.log(result);
} catch (innerError) {
console.error('Inner catch:', innerError.message);
throw innerError;
}
} catch (outerError) {
console.error('Outer catch:', outerError.message);
} finally {
console.log('Nested try...catch finished.');
}
function divide(a, b) {
if (b === 0) {
throw new Error('Division by zero is not allowed.');
}
return a / b;
}
Esempio 3: Utilizzo di finally per liberare risorse
Il blocco finally è utile per liberare risorse, come la chiusura di file o terminare connessioni di rete.
In questo esempio il file verrà sempre chiuso, indipendentemente dal fatto che si sia verificato un errore durante la sua lettura o meno:
function readFile(filePath) {
let file;
try {
file = openFile(filePath); // Funzione che apre il file
// Operazioni sul file
} catch (error) {
console.error('Error reading file:', error.message);
} finally {
if (file) {
closeFile(file); // Funzione che chiude il file
}
console.log('File processing finished.');
}
}
function openFile(path) {
// Logica di apertura del file
}
function closeFile(file) {
// Logica di chiusura del file
}
readFile('path/to/file.txt');
La gestione delle eccezioni in JavaScript usando try, catch, finally e throw consente di creare applicazioni più robusti e affidabili. Comprendere e usare correttamente queste costruzioni aiuta a gestire efficacemente gli errori, liberare risorse e migliorare l'esperienza dell'utente.
GO TO FULL VERSION