Gestione degli Errori in JavaScript. Try-Catch

Indice dei contenuti

La programmazione, indipendentemente dal linguaggio utilizzato, comprende diverse tecniche per la gestione del codice e il controllo degli eventi. In questo articolo, ci concentreremo sulla gestione degli errori e delle eccezioni, nello specifico con linguaggio JavaScript.

La gestione degli errori è un aspetto fondamentale per garantire che le applicazioni siano affidabili e prive di comportamenti inattesi. Gli errori possono verificarsi in diverse fasi dell’esecuzione del codice e possono essere causati da problemi di sintassi, errori di logica o situazioni impreviste. In questo articolo, esploreremo le tecniche di debugging e il trattamento delle eccezioni in JavaScript, al fine di identificare e gestire in modo efficace gli errori nel nostro codice.

Analisi e gestione degli errori del codice con JavaScript

Un buon programmatore dovrebbe sempre cercare di evitare comportamenti inattesi delle proprie applicazioni durante l’esecuzione, prevedendo e gestendo tutte le possibili situazioni che potrebbero verificarsi. Tuttavia, questo non è sempre possibile e a volte possono verificarsi eventi imprevisti che possono causare il crash dell’applicazione e portare al suo inutilizzo.

La gestione degli errori, attraverso il debugging e l’utilizzo delle eccezioni, aiuta a evitare queste situazioni. Questa considerazione è indipendente dal linguaggio di programmazione utilizzato, che sia appunto JavaScript o altro.

Ma procediamo con ordine, cerchiamo di capire cosa sono gli errori nel codice e come gestirli.

Leggi le nostre guide e segui il nostro corso JavaScript per approfondire questo linguaggio di programmazione

Cosa sono gli errori del codice

Gli errori del codice, anche chiamati bug, sono situazioni indesiderate che si verificano durante l’esecuzione di un programma. Questi errori possono essere causati da diversi fattori, come:

sintassi del linguaggio errata, magari la mancanza di un “punto e virgola” oppure una keyword scritta male.
errori logici, derivati da condizioni o cicli mal gestiti.
input imprevisti, causati dagli utenti con l’immissione valori di tipologia differente da quelli previsti dallo sviluppatore (ad esempio una stringa al posto di un numero intero).

Gli errori possono dunque compromettere il corretto funzionamento dell’applicazione e possono manifestarsi in diversi modi, come crash, malfunzionamenti, risultati errati o comportamenti imprevisti.

Molti ambienti di sviluppo aiutano ad identificare gli errori in fase di programmazione o durante l’esecuzione, mostrando anche un messaggio di errore che permetta al developer di correggere facilmente il bug.

I bug possono essere divisi in due categorie principali errori di runtime e errori di logica.

Errori di runtime

Gli errori di runtime si verificano durante l’esecuzione del programma e possono avere diverse cause, spesso imprevedibili per lo sviluppatore, poiché emergono durante l’uso effettivo dell’applicazione. Un semplice inserimento di un valore non previsto in un modulo da parte dell’utente può causare la comparsa di un bug.

Alcuni esempi classici:

Salvataggio di un valore di tipo “string” in una variabile di tipo “integer“
Una divisione per zero
Utilizzo di variabili non definite o con valori nulli
Accesso a risorse/file non disponibili o inesistenti.
Connessione a servizi non disponibili o inattivi.

A causa della loro imprevedibilità o inevitabilità, questi eventi possono risultare molto fastidiosi e compromettere l’esperienza dell’utente.

Errori di logica

Gli errori di logica sono bug che riguardano la logica o l’algoritmo implementato nel codice. A differenza degli errori di runtime, questi errori sono causati da problemi nella progettazione o nella scrittura del codice, e non dipendono direttamente dall’interazione dell’utente con l’applicazione.

Gli errori di logica possono essere più facilmente identificati e corretti dallo sviluppatore, poiché spesso sono il risultato di sviste nella sintassi, nella struttura del programma o nella logica implementata. Molti ambienti di sviluppo avanzati e IDE forniscono strumenti di analisi del codice e di debugging che possono aiutare a individuare e risolvere gli errori di logica prima dell’esecuzione del programma.

Istruzioni JavaScript per gestire errori

La gestione degli errori di runtime in JavaScript è fondamentale per garantire il corretto funzionamento delle nostre applicazioni. Questi errori, come abbiamo visto, si verificano durante l’esecuzione del programma a causa di situazioni impreviste.

Di conseguenza, gli utenti che utilizzano la pagina web o l’applicazione scritta in JavaScript potrebbero incontrare difficoltà nell’interagire correttamente con gli elementi presenti sulla pagina o potrebbe verificarsi un malfunzionamento di una specifica funzione.

Fortunatamente, i moderni browser web offrono strumenti di debugging che sono un valido alleato per gli sviluppatori. Attraverso la console di debug integrata nel browser, è possibile identificare i problemi, visualizzare gli errori e tracciare il flusso di esecuzione del codice. La console di debug fornisce informazioni dettagliate sugli errori, inclusi messaggi di errore, stack trace e il punto esatto in cui si è verificato l’errore. Questo consente agli sviluppatori di individuare e risolvere gli errori di runtime in modo efficace.

Per gestire questi bug con JavaScript possiamo utilizzare le seguenti tecniche:

Try-Catch

Try-catch è un’istruzione per gestire gli errori di runtime in JavaScript (ma usata anche in altri linguaggi di programmazione).

Questo statement è molto facile da usare e integrare anche in codice già esistente, poiché basta racchiudere il codice “incriminato” che potrebbe generare un errore nel blocco try e utilizzare il blocco catch per gestire l’errore qualora si verificasse. La sintassi è la seguente:

try {
  // script o funzione da eseguire

} catch (error) {
  // script da eseguire in caso di errore del precedente

  // log del messaggio di errore derivato
  console.error(error);
}

Un esempio pratico in JavaScript potrebbe essere:

try {
  var num1 = 4;
  var num2 = 6;
  var num3 = 8;
  // num4 mancante!

  console.log(num1 + num2)
  console.log(num3 + num4)

} catch (err) {
  console.warn("Errore somma dei numeri. Continuo l'esecuzione");
  console.error(err);
}

In questo esempio, la variabile num4 è inesistente, dunque durante l’esecuzione del primo blocco (try{..}), l’esecuzione si bloccherà dopo la prima somma, passando direttamente al blocco catch{} con il messaggio di avviso sulla console di debug, restituendo i seguenti log:

-> 10 (somma della prima operazione num1 + num2)
-> Errore somma dei numeri. Continuo l'esecuzione
-> ReferenceError: num4 is not defined

Finally

Il blocco finally è un’istruzione aggiuntiva che può essere utilizzata insieme al blocco try-catch per eseguire del codice che deve essere eseguito indipendentemente dal fatto che si verifichi un’eccezione o meno. Ad esempio:

try {
  // Codice da eseguire
} catch (err) {

  // Gestione dell'eventuale errore

} finally {
  // Codice da eseguire comunque vada la precedente istruzione
}

Throw

Throw è un’istruzione utilizzata per generare eccezioni agli errori nel proprio codice. Viene utilizzata quando si prevede che qualcosa possa andare storto all’interno di una funzione. Invece di interrompere semplicemente l’esecuzione della funzione e restituire un valore nullo o indesiderato, l’istruzione throw consente di generare un’eccezione specifica.

Quando viene eseguita l’istruzione throw, viene creato un oggetto di errore che può contenere informazioni dettagliate sull’errore che si è verificato. Questo oggetto di errore può includere un messaggio di errore personalizzato e altre proprietà che possono essere utili per comprendere e risolvere l’errore.

function somma(a, b) {
  if (b <= 0 || a <= 0) {
    throw new Error('I numeri devono essere maggiori di zero');
  }
  return a + b;
}

try {
  let result = somma(8, 0);   // genera l'errore precedentemente scritto
  console.log(result);

} catch (err) {

  // restituisce il messaggio di errore
  console.log(err);
}

Utilizzo della console di debug

La console di debug dei browser è uno strumento essenziale per individuare e risolvere problemi di logica durante lo sviluppo di applicazioni JavaScript. Grazie a questo strumento, è possibile identificare e correggere i bug del codice in modo rapido ed efficiente.

chrome console debug per log e errori javascript

Durante lo sviluppo web, è possibile aprire la console di debug nel browser, come Chrome, Edge o Firefox per visualizzare i log generati durante l’utilizzo della pagina web. Questo include anche i messaggi che segnalano eventuali errori di sintassi o problemi logici nel codice JavaScript.

Utilizzando la console di debug, gli sviluppatori possono analizzare i messaggi di log e le tracce di esecuzione per comprendere meglio il flusso del programma e individuare le aree del codice che richiedono attenzione e correzione. Questo strumento si rivela particolarmente utile nel processo di debugging, in quanto consente di rilevare i problemi di logica e di risolverli in modo rapido ed efficace, garantendo che l’applicazione funzioni come previsto e offra un’esperienza utente ottimale.

Iscriviti alla nostra Newsletter qui e seguici su Facebook per aggiornamenti!

Articoli recenti: