TypeScript Academy · Lektion

Fullständig felhantering med diskriminerade unioner

Skriv fullständiga hanterare för diskriminerade unioner med switch+never, hjälpfunktioner och kompileringskontroller av täckningen mellan moduler.

Lektion 2 av 28 steg

Fullständig felhantering med diskriminerade unioner är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 2 av 2. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 2 lektioner.

Introduktion

Mål: Säkerställa att varje medlem i en union hanteras. Ni kommer att använda switch + never, en liten exhaustiveCheck-hjälpfunktion och se hur ni behåller täckningen mellan filer.

  • Diskriminanter (taggfält)
  • Fullständiga switch-satser
  • Standardfall som avbryter direkt

Diskriminerad union

En diskriminerad union har en gemensam tagg (här kind). Varje variant innehåller sina egna data.

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

Switch + never

default tilldelar p typen never. Om ni lägger till en ny variant senare ger kompilatorn ett fel tills ni har hanterat den.

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
    }
  }
}

Hjälpfunktionen exhaustiveCheck

Använd en liten hjälpfunktion för att göra avsikten tydlig. Parametern av typen never gör ouppfångade fall till ett typfel, inte bara ett undantag vid körning.

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)
  }
}

Täckning mellan moduler

När unioner definieras i en fil och hanteras i en annan gör en tillagd gren fortfarande att byggena misslyckas tills alla switch-satser har uppdaterats – precis det vi vill.

// 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)
  }
}

Tips och fallgropar

Tips:

  • Föredra taggar med strängliteraler (till exempel tag/kind).
  • Håll varianterna små och komponera data med nästlade objekt i stället för enorma unioner.
  • Använd aldrig default utan en never-kontroll; det döljer fall som saknas.

Kontroll av fullständighet

Snabb kontroll: Vad säkerställer fullständig hantering?

Sammanfattning

Sammanfattning: Använd en diskriminant, skriv en switch och tilldela i standardgrenen resultatet till never (eller anropa exhaustiveCheck) för att garantera full täckning när unioner utvecklas.

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
101
Lektioner
352

Vanliga frågor

Är lektionen ”Fullständig felhantering med diskriminerade unioner” gratis?

Ja – hela texten till ”Fullständig felhantering med diskriminerade unioner” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 2 lektioner.

Vad lär jag mig i ”Fullständig felhantering med diskriminerade unioner”?

Skriv fullständiga hanterare för diskriminerade unioner med switch+never, hjälpfunktioner och kompileringskontroller av täckningen mellan moduler. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?

Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 2.

Hur lång tid tar lektionen ”Fullständig felhantering med diskriminerade unioner”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?

Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Result/Either-liknande typer
  2. Fullständig felhantering med diskriminerade unioner
← Tillbaka till TypeScript Academy