0Pricing
TypeScript Academy · Lezione

Gestione esaustiva degli errori con unioni discriminate

Scriva gestori esaustivi per le unioni discriminate usando switch+never, utility helper e controlli della copertura in fase di compilazione tra i moduli.

Gestione esaustiva degli errori con unioni discriminate è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 2 di 2. 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 2 lezioni in totale.

Introduzione

Obiettivo: garantire la gestione di ogni membro della union. Userà switch + never, una piccola utility exhaustiveCheck e vedrà come mantenere la copertura tra i file.

  • Discriminanti (campi tag)
  • switch esaustivi
  • Valori predefiniti fail-fast

Discriminated union

Una discriminated union ha un tag condiviso (qui kind). Ogni variante contiene i propri dati.

export type Payment =
  | { kind: "Card"; last4: string }
  | { kind: "Cash" }
  | { kind: "Wire"; iban: string }

Switch + never

Il ramo default assegna p a never. Se in seguito aggiunge una nuova variante, il compilatore segnala un errore finché non la gestisce.

export function describe(p: Payment): string {
  switch (p.kind) {
    case "Card": return `Card ••••${p.last4}`
    case "Cash": return "Cash"
    case "Wire": return `Wire ${p.iban}`
    default: {
      const _exhaustive: never = p
      return _exhaustive
    }
  }
}

Helper exhaustiveCheck

Usi un piccolo helper per rendere evidente l'intento. Il parametro never trasforma i casi non gestiti in un errore di tipo, non soltanto in un'eccezione a runtime.

export function exhaustiveCheck(x: never): never {
  throw new Error(`Unhandled case: ${JSON.stringify(x)}`)
}

export function pay(p: Payment): string {
  switch (p.kind) {
    case "Card": return "charged card"
    case "Cash": return "took cash"
    case "Wire": return "initiated wire"
    default: return exhaustiveCheck(p)
  }
}

Copertura tra moduli

Quando le union sono definite in un file e gestite in un altro, l'aggiunta di un ramo continua a interrompere le build finché tutti gli switch non vengono aggiornati: è esattamente ciò che vogliamo.

// errors.ts
export type AppError =
  | { tag: "Auth"; reason: "Unauthorized" | "Forbidden" }
  | { tag: "NotFound"; resource: string }
  | { tag: "Conflict"; resource: string }

// handler.ts
import type { AppError } from "./errors"
import { exhaustiveCheck } from "./exhaustive"

export function toStatus(e: AppError): number {
  switch (e.tag) {
    case "Auth": return e.reason === "Unauthorized" ? 401 : 403
    case "NotFound": return 404
    case "Conflict": return 409
    default: return exhaustiveCheck(e)
  }
}

Suggerimenti e insidie

Suggerimenti:

  • Preferisca i tag string literal (ad esempio tag/kind).
  • Mantenga piccole le varianti; componga i dati tramite oggetti annidati invece di creare union enormi.
  • Non usi mai default senza una guardia never: nasconde i casi mancanti.

Verifica dell'esaustività

Verifica rapida: che cosa impone la gestione esaustiva?

Riepilogo

Riepilogo: usi un discriminante, scriva uno switch e nel ramo default assegni il valore a never (oppure chiami exhaustiveCheck) per garantire la copertura completa mentre le union evolvono.

Domande Frequenti

La lezione «Gestione esaustiva degli errori con unioni discriminate» è gratuita?

Sì — il testo completo di «Gestione esaustiva degli errori con unioni discriminate» è 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 2 lezioni in totale.

Cosa imparerò in «Gestione esaustiva degli errori con unioni discriminate»?

Scriva gestori esaustivi per le unioni discriminate usando switch+never, utility helper e controlli della copertura in fase di compilazione tra i moduli. 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 2 di 2.

Quanto tempo richiede la lezione «Gestione esaustiva degli errori con unioni discriminate»?

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

  1. Tipi in stile Result/Either
  2. Gestione esaustiva degli errori con unioni discriminate
← Torna a TypeScript Academy