TypeScript Academy · Lektion

Problemet med att kasta fel

Varför undantag döljer fel för typsystemet.

Lektion 1 av 413 steg

Problemet med att kasta fel är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 1 av 4. 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 4 lektioner.

Undantag är osynliga

När en funktion använder throw framgår det inte av dess signatur. Typsystemet kan inte se vilka funktioner som kan misslyckas, så anropande kod får ingen ledtråd från kompilatorn om att fel måste hanteras.

En funktion som kastar undantag

Den här funktionen ser ut att alltid returnera ett tal, men den kan kasta ett undantag. Returtypen number döljer helt möjligheten att något går fel.

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

Anropande kod glömmer att fånga undantag

Ingenting tvingar anropande kod att omsluta anropet med try/catch. Misstaget kompileras utan problem och visar sig först som en krasch vid körning.

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

try/catch förlorar typinformationen

Även när du fångar ett fel får det fångade värdet typen unknown (eller any). Felobjektets struktur spåras inte, så hanteringen blir en gissningslek.

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

Fel som värden

Alternativet är att göra misslyckandet till ett vanligt värde som funktionen returnerar, i stället för ett undantag som den kastar. Då visar returtypen ärligt båda möjliga utfallen.

En skiss som returnerar ett värde

I stället för att kasta ett undantag returnerar du ett märkt objekt som beskriver framgång eller misslyckande. Anropande kod måste granska objektet innan värdet används.

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

Typen visar nu sanningen

En funktion som returnerar ParseResult meddelar att den kan misslyckas. Kompilatorn kräver då att anropande kod hanterar grenen för misslyckande.

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

Tvingad hantering

Eftersom värdet kan tillhöra vilken gren som helst kan du inte läsa value utan att först kontrollera ok. Kompilatorn förfinar typen först efter kontrollen.

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

Undantag har fortfarande sin plats

Verkligt oväntade och oåterställbara fel (programmeringsfel och slut på minne) kan fortfarande kasta undantag. Fel som värden är särskilt användbara för förväntade fel, som parsning och validering.

Explicit framför implicit

När du returnerar fel blir felvägen explicit i typen, synlig vid anropsstället och omöjlig att råka ignorera, till skillnad från ett dolt throw.

På väg mot Result och Option

Den här formen med märkt framgång eller misslyckande generaliseras till en återanvändbar typ av Result, medan avsaknad kontra närvaro generaliseras till Option. Båda behandlas härnäst.

Snabb kontroll

Snabb kontroll av lektionen.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Kastade fel är osynliga för typsystemet: signaturer döljer misslyckanden och anropande kod glömmer att fånga dem. När misslyckanden returneras som ett explicit värde (ett märkt objekt för framgång eller fel) blir felvägen synlig i typen och omöjlig att ignorera. Det leder vidare till typerna Result och Option.

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

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Problemet med att kasta fel” gratis?

Ja – hela texten till ”Problemet med att kasta fel” 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 4 lektioner.

Vad lär jag mig i ”Problemet med att kasta fel”?

Varför undantag döljer fel för typsystemet. 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 1 av 4.

Hur lång tid tar lektionen ”Problemet med att kasta fel”?

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

← Tillbaka till TypeScript Academy