TypeScript Academy · Lezione

Il problema del lancio degli errori

Scopra perché le eccezioni nascondono i fallimenti al sistema dei tipi.

Il problema del lancio degli errori è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Le eccezioni sono invisibili

Quando una funzione esegue throw, la sua firma non lo indica. Il sistema dei tipi non può sapere quali funzioni possano fallire, quindi chi le chiama non riceve dal compilatore alcun suggerimento a gestire gli errori.

Una funzione che genera eccezioni

Questa funzione sembra restituire sempre un numero, ma può generare un'eccezione. Il tipo restituito number nasconde completamente il caso di errore.

function parsePort(s: string): number {
  const n = Number(s);
  if (Number.isNaN(n)) throw new Error("bad port");
  return n;
}
console.log(parsePort("8080")); // 8080

Chi chiama dimentica di catturare l'errore

Nulla obbliga chi chiama la funzione a racchiudere la chiamata in try/catch. L'errore viene compilato senza problemi e si manifesta solo come un arresto anomalo a runtime.

const port = parsePort("oops");
// No compile error; throws at runtime, possibly crashing the app.

try/catch perde il tipo

Anche quando si cattura l'errore, il valore catturato ha tipo unknown (o any). La struttura dell'errore non viene tracciata, quindi la sua gestione si basa su supposizioni.

try {
  parsePort("x");
} catch (e) {
  // e: unknown -> you must narrow it manually
}

Gli errori come valori

L'alternativa consiste nel rendere il fallimento un normale valore restituito dalla funzione, invece di un'eccezione generata. In questo modo il tipo restituito mostra con chiarezza entrambi gli esiti.

Schema di un valore restituito

Invece di generare un'eccezione, restituisca un oggetto con tag che descriva il successo o il fallimento. Chi chiama la funzione deve esaminarlo prima di utilizzare il valore.

type ParseResult =
  | { ok: true; value: number }
  | { ok: false; error: string };

Ora il tipo dice la verità

Una funzione che restituisce ParseResult dichiara esplicitamente che può fallire. Il compilatore richiede quindi a chi chiama la funzione di gestire il ramo del fallimento.

function parsePort(s: string): ParseResult {
  const n = Number(s);
  return Number.isNaN(n)
    ? { ok: false, error: "bad port" }
    : { ok: true, value: n };
}

Gestione obbligatoria

Poiché il valore potrebbe appartenere a uno dei due rami, non è possibile leggere value senza aver prima controllato ok. Il compilatore restringe il tipo solo dopo il controllo.

const r = parsePort("oops");
if (r.ok) console.log(r.value);
else console.log("failed:", r.error);

Le eccezioni hanno ancora il loro posto

I fallimenti davvero imprevisti e irrecuperabili (bug del programmatore, memoria esaurita) possono ancora generare eccezioni. Gli errori come valori sono ideali per i fallimenti previsti, come quelli di parsing e validazione.

Esplicito anziché implicito

Restituire gli errori rende il percorso del fallimento esplicito nel tipo, visibile nel punto della chiamata e impossibile da ignorare accidentalmente, a differenza di un throw nascosto.

Verso Result e Option

Questa struttura con tag per successo o fallimento si generalizza in un tipo riutilizzabile Result, mentre la distinzione tra assenza e presenza si generalizza in Option. Entrambi saranno trattati nella prossima sezione.

Verifica rapida

Verifica rapida su questa lezione.

Riepilogo

Gli errori generati sono invisibili ai tipi: le firme nascondono il fallimento e chi chiama dimentica di catturarlo. Restituire il fallimento come valore esplicito (un oggetto con tag per successo o errore) rende il percorso del fallimento visibile nel tipo e impossibile da ignorare, conducendo ai tipi Result e Option.

Domande Frequenti

La lezione «Il problema del lancio degli errori» è gratuita?

Sì — il testo completo di «Il problema del lancio degli errori» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Il problema del lancio degli errori»?

Scopra perché le eccezioni nascondono i fallimenti al sistema dei tipi. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Il problema del lancio degli errori»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?

Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a TypeScript Academy