TypeScript Academy · leksjon

Problemet med å kaste feil

Forstå hvorfor unntak skjuler feil for typesystemet.

Leksjon 1 av 413 trinn

Problemet med å kaste feil er en gratis leksjon i TypeScript Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i TypeScript Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.

Unntak er usynlige

Når en funksjon kaster et unntak, sier ikke signaturen noe om det. Typesystemet kan ikke se hvilke funksjoner som kan mislykkes, så kallere får ingen hjelp fra kompilatoren til å håndtere feil.

En funksjon som kaster unntak

Denne funksjonen ser ut som om den alltid returnerer et tall, men den kan kaste et unntak. Returtypen number skjuler feilsituasjonen fullstendig.

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

Kallere glemmer å fange feil

Ingenting tvinger kalleren til å omslutte kallet med try/catch. Feilen kompilerer uten problemer og viser seg først som et krasj under kjøring.

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

<code>try/catch</code> mister typen

Selv når feilen fanges, får den fangede verdien typen unknown (eller any). Feilens struktur spores ikke, så håndteringen blir basert på gjetting.

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

Feil som verdier

Alternativet er å gjøre feil til en vanlig verdi som funksjonen returnerer, i stedet for et unntak den kaster. Da viser returtypen ærlig begge utfallene.

En skisse som returnerer en verdi

I stedet for å kaste et unntak returneres et merket objekt som beskriver suksess eller feil. Kalleren må undersøke objektet før verdien brukes.

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

Typen forteller nå sannheten

En funksjon som returnerer ParseResult, opplyser at den kan mislykkes. Kompilatoren krever da at kalleren håndterer feilgrenen.

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

Tvungen håndtering

Fordi verdien kan tilhøre hvilken som helst av grenene, kan value ikke leses før ok er kontrollert. Kompilatoren snevrer bare inn typen etter kontrollen.

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

Unntak har fortsatt en plass

Virkelig uventede og uopprettelige feil (programmeringsfeil og minnemangel) kan fortsatt kaste unntak. Feil som verdier fungerer best for forventede feil, som parsing og validering.

Eksplisitt fremfor implisitt

Ved å returnere feil blir feilbanen eksplisitt i typen, synlig ved kallstedet og umulig å overse ved et uhell, i motsetning til en skjult throw.

På vei mot Result og Option

Denne formen med merket suksess eller feil generaliseres til en gjenbrukbar Result-type, og fravær eller tilstedeværelse generaliseres til Option. Begge deler gjennomgås i neste leksjon.

Hurtigsjekk

Hurtigsjekk av denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering

Kastede feil er usynlige for typer: signaturer skjuler feil, og kallere glemmer å fange dem. Når feil returneres som en eksplisitt verdi (et merket objekt for suksess eller feil), blir feilbanen synlig i typen og umulig å overse. Dette leder videre til Result- og Option-typer.

Gratis å komme i gang

Lær deg TypeScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 101
Leksjoner: 352

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Problemet med å kaste feil» gratis?

Ja – hele teksten i «Problemet med å kaste feil» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av TypeScript Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Problemet med å kaste feil»?

Forstå hvorfor unntak skjuler feil for typesystemet. Du øver på TypeScript Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med TypeScript Academy?

Ingen tidligere erfaring er nødvendig. TypeScript Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Problemet med å kaste feil»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne TypeScript Academy-leksjonen?

Ja. Alle TypeScript Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til TypeScript Academy