Gestione degli errori in JavaScript

Questo articolo spiega la gestione degli errori in JavaScript.

YouTube Video

Gestione degli errori in JavaScript

La gestione degli errori in JavaScript è una funzione importante per intercettare e gestire adeguatamente gli errori quando un programma incontra problemi imprevisti. Principalmente, è comune utilizzare la sintassi try...catch per intercettare e gestire gli errori. Inoltre, quando si utilizzano Promises o operazioni asincrone, la gestione degli errori può essere eseguita anche con async/await o Promise.prototype.catch.

Sintassi try...catch

try...catch è utilizzato per intercettare e gestire gli errori quando si verificano all'interno di un blocco di codice.

 1try {
 2    // Code that may throw an error
 3    let result = riskyFunction();
 4    console.log(result);
 5} catch (error) {
 6    // Catch and handle the error
 7    console.error("An error occurred:", error.message);
 8} finally {
 9    // Code that will always execute
10    console.log("Error handling has completed.");
11}

• Se si verifica un errore all'interno di un blocco try, l'esecuzione del programma viene interrotta ed eseguito il blocco catch.
• Il blocco finally viene sempre eseguito, indipendentemente dalla presenza o meno di un errore. È utile per rilasciare risorse e per elaborazioni finali, tra le altre cose.

Generare Errori (throw)

In JavaScript, è possibile attivare esplicitamente un errore utilizzando la parola chiave throw. Viene utilizzato per generare messaggi di errore personalizzati o errori personalizzati.

 1function checkAge(age) {
 2    if (age < 18) {
 3        throw new Error("You are under 18 years old.");
 4    }
 5    return "Age verification completed.";
 6}
 7
 8try {
 9    let result = checkAge(15);
10    console.log(result);
11} catch (error) {
12    console.error(error.message);  // Displays "You are under 18 years old."
13}

Gestione degli Errori nelle Operazioni Asincrone (Promise e async/await)

Quando si eseguono operazioni asincrone, la gestione degli errori è leggermente diversa. Quando si utilizzano Promises, gli errori vengono intercettati con il metodo catch.

1let promise = new Promise((resolve, reject) => {
2    // Asynchronous operation
3    setTimeout(() => reject(new Error("An issue has occurred!")), 1000);
4});
5
6promise
7    .then(result => console.log(result))
8    .catch(error => console.error(error.message));  // Displays "An issue has occurred!"

Quando si eseguono operazioni asincrone utilizzando async/await, è possibile gestire gli errori con try...catch.

 1async function fetchData() {
 2    try {
 3        let response = await fetch('https://api.example.com/data');
 4        let data = await response.json();
 5        console.log(data);
 6    } catch (error) {
 7        console.error("An error occurred while fetching data:", error.message);
 8    }
 9}
10
11fetchData();

Riepilogo

• È possibile intercettare gli errori sincroni utilizzando la sintassi try...catch.
• È possibile generare i propri errori utilizzando throw.
• Gli errori nelle operazioni asincrone possono essere gestiti utilizzando il metodo catch di Promise, oppure con async/await e try...catch.

Utilizzando questi metodi, è possibile garantire che il programma funzioni correttamente anche in caso di errori.

Error

La classe Error viene utilizzata per la gestione degli errori. Offre la possibilità di creare errori e fornire messaggi di errore e tracce dello stack.

1try {
2    throw new Error("Something went wrong");
3} catch (e) {
4    console.log(e.message); // Something went wrong
5}

Uso di base

Un oggetto Error può essere creato esplicitamente quando si verifica un errore. Si crea un'istanza con new Error() e si passa un messaggio di errore.

1const error = new Error("Something went wrong");
2console.log(error.message);  // "Something went wrong"
3console.log(error.name);     // "Error"
4console.log(error.stack);    // Stack trace (information about where the error occurred)

Lanciare errori con throw

In JavaScript, è possibile lanciare un errore utilizzando la parola chiave throw. Questo viene usato per interrompere l'elaborazione in situazioni specifiche e trasferire il controllo a un gestore di errori.

1function doSomething() {
2    throw new Error("This function is not yet implemented");
3}
4
5try {
6    doSomething();
7} catch (e) {
8    console.error(e.message);  // "This function is not yet implemented"
9}

Gli errori lanciati con throw possono essere catturati utilizzando la sintassi try...catch.

Creare errori personalizzati

In JavaScript, è possibile creare errori personalizzati estendendo la classe Error. Ciò consente di creare errori su misura per situazioni specifiche.

 1class CustomError extends Error {
 2    constructor(message) {
 3        super(message);  // Call the parent class constructor
 4        this.name = "CustomError";  // Set the error name
 5    }
 6}
 7
 8try {
 9    throw new CustomError("A custom error has occurred");
10} catch (e) {
11    console.error(e.name);    // "CustomError"
12    console.error(e.message); // "A custom error has occurred"
13}

Classi di errori integrate

JavaScript dispone di diverse classi di errori integrate che estendono la classe Error. Queste vengono utilizzate per rappresentare errori specifici.

• ReferenceError: Si verifica quando si fa riferimento a una variabile che non esiste.
• TypeError: Si verifica quando il tipo di un valore è diverso da quello previsto.
• RangeError: Si verifica quando un numero è al di fuori del range consentito.
• SyntaxError: Si verifica quando viene eseguito codice non sintatticamente corretto.
• EvalError: Errori relativi all'uso della funzione eval(). Attualmente è usato raramente.
• URIError: Si verifica quando viene utilizzato un URI non valido (errori di codifica o decodifica).

Esempio: ReferenceError

Ecco un esempio di ReferenceError.

1try {
2    console.log(undefinedVariable);  // Undefined variable
3} catch (e) {
4    console.error(e.name);    // "ReferenceError"
5    console.error(e.message); // "undefinedVariable is not defined"
6}

Esempio: TypeError

Ecco un esempio di TypeError.

1try {
2    null.f();  // Attempting to call a function on null
3} catch (e) {
4    console.error(e.name);    // "TypeError"
5    console.error(e.message); // "Cannot read properties of null (reading 'f')"
6}

Blocco finally

Nella sintassi try...catch, utilizza il blocco finally per le operazioni che vuoi eseguire indipendentemente dal fatto che si verifichi o meno un errore.

1try {
2    throw new Error("An issue has occurred");
3} catch (e) {
4    console.error(e.message);  // "An issue has occurred"
5} finally {
6    console.log("Performing cleanup");
7}

In questo esempio, le operazioni nel blocco finally vengono eseguite anche se viene generato un errore.

Proprietà dell'oggetto Error

L'oggetto Error ha le seguenti proprietà.

• message: Questo è il messaggio di errore.
• name: Il nome dell'errore, che di default è "Error".
• stack: Una traccia dello stack che mostra dove si è verificato l'errore, utile per il debugging.

Vantaggi della gestione delle eccezioni

Implementando correttamente la gestione degli errori, è possibile evitare che l'applicazione si arresti a causa di comportamenti imprevisti. Utilizzando in modo appropriato la sintassi try...catch e gli oggetti errore, si può scrivere un codice più robusto.

 1function divide(a, b) {
 2    if (b === 0) {
 3        throw new Error("Cannot divide by zero");
 4    }
 5    return a / b;
 6}
 7
 8try {
 9    console.log(divide(4, 0));  // An error will occur
10} catch (e) {
11    console.error(e.message);   // "Cannot divide by zero"
12}

Riepilogo

• La classe Error è usata per rappresentare una causa di errore e per gestire gli errori.
• Usa la sintassi try...catch...finally per gestire gli errori ed evitare un arresto inaspettato dell'applicazione.
• È anche possibile estendere la classe Error per creare errori personalizzati.
• È possibile gestire vari tipi di errori utilizzando classi di errore predefinite come TypeError e ReferenceError.

Puoi seguire l'articolo sopra utilizzando Visual Studio Code sul nostro canale YouTube. Controlla anche il nostro canale YouTube.

YouTube Video