JavaScript - Gestione degli Errori ed Eccezioni

Ciao a tutti, futuri maghi di JavaScript! ? Benvenuti nel nostro emozionante viaggio nel mondo della gestione degli errori in JavaScript. Come il vostro amico insegnante di informatica del vicinato, sono qui per guidarvi in questa avventura. Allacciate le cinture e tuffiamoci!

Cos'è un Errore?

Immaginate di stare cuocendo una torta ? e accidentalmente usate il sale invece dello zucchero. Questo è un errore! In programmazione, gli errori sono simili - sono problemi imprevisti che si verificano quando il nostro codice viene eseguito. Questi possono essere errori di battitura, errori logici o persino problemi con i dati con cui stiamo lavorando.

Ecco un semplice esempio di un errore in JavaScript:

console.log(Hello, World!);

Se eseguite questo codice, otterrete un errore perché abbiamo dimenticato di mettere virgolette attorno al nostro testo. JavaScript si aspetta che le stringhe siano tra virgolette.

Cos'è la Gestione degli Errori?

La gestione degli errori è come avere una rete di sicurezza quando si cammina su una corda tesa. È un modo per gestire elegantemente gli errori nel nostro codice, prevenendo il crash di tutto il nostro programma quando qualcosa va storto.

La Dichiarazione try...catch...finally

La dichiarazione try...catch...finally è il nostro strumento principale per gestire gli errori in JavaScript. È come una squadra di supereroi che arriva per salvare la giornata! ?‍♀️?‍♂️?‍♀️

Ecco come funziona:

try {
// Codice che potrebbe causare un errore
let result = 10 / 0;
console.log(result);
} catch (error) {
// Codice per gestire l'errore
console.log("Ops! Si è verificato un errore:", error.message);
} finally {
// Codice che sempre si esegue, indipendentemente dagli errori
console.log("Questo si esegue sempre!");
}

In questo esempio:

• Il blocco try contiene il codice che potrebbe causare un errore (la divisione per zero).
• Se si verifica un errore, il blocco catch lo cattura e lo gestisce elegantemente.
• Il blocco finally sempre si esegue, indipendentemente dalla presenza di errori.

La Dichiarazione throw

A volte, vogliamo creare i nostri errori personalizzati. È qui che entra in gioco la dichiarazione throw. È come essere l'arbitro in una partita e chiamare un fallo! ?

Ecco un esempio:

function checkAge(age) {
if (age < 0) {
throw new Error("L'età non può essere negativa!");
}
console.log("L'età è valida:", age);
}

try {
checkAge(-5);
} catch (error) {
console.log("Catturato un errore:", error.message);
}

In questo codice, stiamo lanciando un errore personalizzato quando qualcuno tenta di usare un'età negativa. Il blocco catch poi gestisce questo errore.

La Proprietà dell'Handler di Evento onerror

L'handler di evento onerror è come avere un guardiano attento per l'intera applicazione JavaScript. Cattura errori che si verificano ovunque nel codice.

Ecco come potete usarlo:

window.onerror = function(message, source, lineno, colno, error) {
console.log("Si è verificato un errore:");
console.log("Messaggio:", message);
console.log("Sorgente:", source);
console.log("Riga:", lineno);
console.log("Colonna:", colno);
console.log("Oggetto Errore:", error);
return true;
};

// Questo attiverà l'handler di onerror
nonExistentFunction();

Questo codice imposta un handler di errore globale che catturerà qualsiasi errore non catturato nella vostra applicazione.

Riferimento all'Oggetto Errore JavaScript

JavaScript fornisce diversi tipi di errori predefiniti. Vediamo alcuni di loro in una comoda tabella:

Tipo di Errore	Descrizione
Error	Il tipo di errore generico
SyntaxError	Si verifica quando c'è un errore di sintassi nel codice
ReferenceError	Si verifica quando si fa riferimento a una variabile inesistente
TypeError	Si verifica quando un valore non è del tipo atteso
RangeError	Si verifica quando un numero è fuori dal range consentito
URIError	Si verifica quando si utilizzano funzioni URI errate
EvalError	Si verifica in relazione alla funzione eval()

Ecco un esempio di come questi errori potrebbero verificarsi:

try {
// SyntaxError
eval("Hello World");

// ReferenceError
console.log(undefinedVariable);

// TypeError
null.f();

// RangeError
let arr = new Array(-1);

// URIError
decodeURIComponent("%");

} catch (error) {
console.log(error.name + ": " + error.message);
}

Ogni una di queste righe lancerà un tipo diverso di errore, che il nostro blocco catch gestirà.

Ecco fatto, miei cari studenti! Abbiamo viaggiato attraverso il paese della gestione degli errori in JavaScript. Ricordate, gli errori non sono i vostri nemici - sono preziose feedback che vi aiutano a migliorare il vostro codice. Abbracciateli, imparate da loro, e presto gestirete gli errori come un professionista! ?

Continuate a programmare, continuate a imparare, e non dimenticate di divertirvi lungo il percorso! Ci vediamo nella prossima lezione! ?

Credits: Image by storyset