TypeScript Academy · Les

Het probleem met errors gooien

Waarom excepties fouten aan het typesysteem onttrekken

Les 1 van 413 stappen

Het probleem met errors gooien is een gratis TypeScript Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject TypeScript Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus TypeScript Academy bevat in totaal 4 lessen.

Uitzonderingen zijn onzichtbaar

Wanneer een functie throw gebruikt, vermeldt de signatuur dat niet. Het typesysteem kan niet zien welke functies kunnen mislukken, dus de compiler geeft aanroepers geen hint om fouten af te handelen.

Een functie die een uitzondering gooit

Deze functie lijkt altijd een getal terug te geven, maar kan een uitzondering gooien. Het retourtype number verbergt het foutscenario volledig.

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

Aanroepers vergeten fouten op te vangen

Niets verplicht de aanroeper om de aanroep in try/catch te plaatsen. De fout compileert zonder problemen en wordt pas tijdens de uitvoering zichtbaar als crash.

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

try/catch verliest het type

Zelfs wanneer je de fout opvangt, krijgt de opgevangen waarde het type unknown (of any). De structuur van de fout wordt niet bijgehouden, waardoor de afhandeling giswerk wordt.

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

Fouten als waarden

Het alternatief is om een fout een gewone waarde te maken die de functie teruggeeft, in plaats van een uitzondering die de functie gooit. Het retourtype toont dan eerlijk beide uitkomsten.

Een schets die een waarde teruggeeft

Geef in plaats van een uitzondering te gooien een object met een label terug dat succes of een fout beschrijft. De aanroeper moet dit eerst controleren voordat de waarde wordt gebruikt.

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

Het type vertelt nu de waarheid

Een functie die ParseResult teruggeeft, maakt duidelijk dat ze kan mislukken. De compiler verplicht de aanroeper vervolgens de fouttak af te handelen.

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

Afhandeling afdwingen

Omdat de waarde tot beide takken kan behoren, kun je value niet lezen zonder eerst ok te controleren. De compiler vernauwt het type pas na die controle.

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

Uitzonderingen hebben nog steeds hun plaats

Echt onverwachte, onherstelbare fouten (programmeursfouten, geheugenuitputting) kunnen nog steeds een uitzondering gooien. Fouten als waarden komen goed tot hun recht bij verwachte fouten, zoals parserings- en validatiefouten.

Expliciet boven impliciet

Door fouten terug te geven, wordt het foutpad expliciet in het type, zichtbaar op de plaats van de aanroep en onmogelijk om per ongeluk te negeren, in tegenstelling tot een verborgen throw.

Op weg naar Result en Option

Deze vorm met een succes- of foutlabel wordt een herbruikbaar type Result, en aanwezigheid tegenover afwezigheid wordt een type Option. Beide komen hierna aan bod.

Korte controle

Korte controle van deze les.

Beantwoord dit in de interactieve les

Samenvatting

Gegooide fouten zijn onzichtbaar voor typen: signaturen verbergen fouten en aanroepers vergeten ze op te vangen. Door fouten als een expliciete waarde terug te geven (een object met een succes- of foutlabel) wordt het foutpad zichtbaar in het type en onmogelijk om te negeren. Zo kom je uit bij de typen Result en Option.

Gratis beginnen

Leer TypeScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 101
Lessen: 352

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Het probleem met errors gooien” gratis?

Ja — de volledige tekst van “Het probleem met errors gooien” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus TypeScript Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus TypeScript Academy bevat in totaal 4 lessen.

Wat leer ik in “Het probleem met errors gooien”?

Waarom excepties fouten aan het typesysteem onttrekken Je oefent met TypeScript Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met TypeScript Academy te beginnen?

Ervaring vooraf is niet nodig. TypeScript Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Het probleem met errors gooien”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over TypeScript Academy?

Ja. Elke les over TypeScript Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar TypeScript Academy