Gestire le eccezioni in JavaScript: il blocco <strong>try...catch</strong> con il parsing sicuro dei dati JSON

Introduzione

Quando lavori con JavaScript, prima o poi ti capiterà di dover leggere dati esterni: risposta di un’API, contenuto salvato nel localStorage, file di configurazione o input proveniente da un form. In tutti questi casi, una delle operazioni più delicate è il parsing del JSON. Basta un carattere mancante, una virgola fuori posto o un formato inatteso per generare un errore e interrompere l’esecuzione del programma.

Qui entra in gioco try...catch, la struttura che ti permette di intercettare le eccezioni e gestirle in modo controllato. In questo tutorial vedremo un sotto-argomento molto pratico e spesso sottovalutato: come usare try...catch per rendere sicuro il parsing di JSON.

Questo approccio è utile in scenari reali, perché i dati non sono sempre affidabili. Un’app robusta non deve andare in crash se riceve una stringa JSON malformata: deve invece riconoscere il problema, reagire con un messaggio chiaro e, se possibile, continuare a funzionare.

Codice completo

// Esempio: parsing sicuro di una stringa JSON ricevuta da una fonte esterna

function parseJsonSicuro(testoJson) {
  try {
    // Proviamo a convertire la stringa in oggetto JavaScript
    const dati = JSON.parse(testoJson);

    // Controllo aggiuntivo: verifichiamo che l´oggetto abbia la struttura attesa
    if (!dati || typeof dati !== "object") {
      throw new Error("Il JSON non contiene un oggetto valido.");
    }

    if (typeof dati.nome !== "string") {
      throw new Error("Campo ´nome´ mancante o non valido.");
    }

    if (typeof dati.età !== "number") {
      throw new Error("Campo ´età´ mancante o non valido.");
    }

    return {
      success: true,
      data: dati
    };
  } catch (errore) {
    return {
      success: false,
      message: `Errore nel parsing del JSON: ${errore.message}`
    };
  }
}

// Simuliamo tre casi diversi
const jsonValido = ´{"nome":"Alice","età":28}´;
const jsonNonValido = ´{"nome":"Alice","età":28´; // parentesi graffa mancante
const jsonStrutturaErrata = ´{"nome":"Alice","età":"ventotto"}´;

console.log(parseJsonSicuro(jsonValido));
// { success: true, data: { nome: ´Alice´, età: 28 } }

console.log(parseJsonSicuro(jsonNonValido));
// { success: false, message: ´Errore nel parsing del JSON: Unexpected end of JSON input´ }

console.log(parseJsonSicuro(jsonStrutturaErrata));
// { success: false, message: "Errore nel parsing del JSON: Campo ´età´ mancante o non valido." }

Spiegazione

Il punto centrale di questo esempio è che JSON.parse() può generare un’eccezione se la stringa non rispetta la sintassi JSON. Senza try...catch, l’errore interromperebbe il flusso del programma. Con il blocco di cattura, invece, possiamo intercettarlo e restituire una risposta strutturata.

1. Il blocco try

All’interno di try inseriamo il codice che potrebbe fallire. Nel nostro caso:

la conversione della stringa con JSON.parse();
i controlli sulla struttura dei dati ottenuti.

Questo è importante: non bisogna limitarsi a gestire solo l’errore di parsing. Anche un JSON sintatticamente corretto può contenere dati sbagliati rispetto al formato atteso.

2. Il blocco catch

Se nel try si verifica un errore, JavaScript salta direttamente nel catch. Qui riceviamo l’oggetto errore, che contiene proprietà utili come message. Nel nostro esempio, invece di stampare solo l’errore in console, restituiamo un oggetto con:

success: false per indicare che l’operazione non è andata a buon fine;
message per fornire un messaggio leggibile.

Questa strategia è molto utile nelle funzioni di utilità, nei servizi frontend e nei moduli backend, perché rende il comportamento prevedibile per chi usa la funzione.

3. Il controllo della struttura dei dati

Un errore comune è pensare che, se il JSON viene parsato correttamente, allora i dati siano automaticamente validi. In realtà non è così. Per esempio, questa stringa è sintatticamente corretta:

{"nome":"Alice","età":"ventotto"}

Ma nel nostro caso età dovrebbe essere un numero, non una stringa. Per questo dopo il parsing facciamo controlli espliciti con typeof e, se qualcosa non torna, lanciamo manualmente un errore con throw new Error().

Questo approccio combina due livelli di protezione:

gestione delle eccezioni per gli errori tecnici di parsing;
validazione dei dati per verificare la qualità del contenuto.

4. Perché restituire un oggetto invece di lanciare sempre l’errore?

Dipende dal contesto. In alcune applicazioni è meglio rilanciare l’errore e gestirlo più in alto nella catena di chiamate. In altri casi, soprattutto in funzioni di supporto, è comodo restituire un oggetto con stato e messaggio. Questo rende l’API della funzione più semplice da usare e da testare.

Ad esempio, se stai leggendo un JSON da localStorage, potresti voler mostrare un fallback all’utente invece di bloccare tutta l’interfaccia. Se invece stai costruendo un backend, potresti voler loggare l’errore e rispondere con un codice appropriato.

Best practice

Usa try...catch solo dove serve davvero: non avvolgere tutto il codice in un grande blocco generico. Limita il try alla parte che può realmente generare eccezioni.
Valida i dati dopo il parsing: un JSON valido non garantisce dati corretti. Controlla tipi, campi obbligatori e valori ammessi.
Non ignorare gli errori: anche se gestisci l’eccezione, registra o comunica il problema in modo utile. Evita catch vuoti.
Usa messaggi chiari: l’errore deve aiutare chi sviluppa o chi usa l’app a capire cosa è andato storto.
Separa parsing e logica applicativa: una funzione che si occupa solo di leggere e validare JSON è più facile da mantenere e riusare.
Preferisci strutture di ritorno coerenti: se una funzione restituisce sempre oggetti con campi simili, il codice chiamante sarà più semplice e meno fragile.

Riepilogo

Il blocco try...catch è uno strumento fondamentale per scrivere codice JavaScript più robusto. Nel caso del parsing JSON, ti permette di gestire sia gli errori di sintassi sia quelli di validazione dei dati in modo ordinato e prevedibile.

Il flusso corretto è questo:

prova a fare il parsing con JSON.parse();
controlla che i dati abbiano la struttura attesa;
se qualcosa non va, lancia o cattura un errore;
restituisci un risultato chiaro al codice chiamante.

Questo approccio è particolarmente utile in applicazioni reali, dove i dati esterni non sono mai completamente affidabili. Imparare a gestire bene le eccezioni significa prevenire crash, migliorare l’esperienza utente e rendere il codice più professionale.

Approfondisci con risorse ufficiali

MDN Web Docs - try...catch: documentazione completa sulla gestione delle eccezioni in JavaScript.
MDN Web Docs - JSON.parse(): riferimento ufficiale per il parsing delle stringhe JSON.
ECMAScript Language Specification: specifica del linguaggio per chi vuole approfondire il comportamento delle eccezioni.
MDN Web Docs - Error: guida alle proprietà e all’uso degli oggetti errore in JavaScript.

Add as preferred source on Google