Volledigheidscontrole met never
Vang niet-afgehandelde gevallen tijdens het compileren op met never
Volledigheidscontrole met never is een gratis TypeScript Academy-les op CoddyKit. Dit is les 3 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.
Het probleem van volledigheid
Wanneer je een nieuw lid aan een unie toevoegt, is het gemakkelijk om te vergeten dit ergens af te handelen. Controle op volledigheid maakt van die vergissing een compileerfout.
type Shape =
| { kind: "circle"; radius: number }
| { kind: "square"; side: number };
// If we add "triangle" later, we want every switch to complain.Het type never
Het type never staat voor waarden die nooit kunnen voorkomen. Als elke case is afgehandeld, heeft de waarde die de standaardtak bereikt het type never.
function fail(): never {
throw new Error("unreachable");
}
// never is assignable to nothing except never itself.Toewijzen aan never in de standaardtak
Wijs de waarde in de default-tak toe aan een variabele van het type never. Als alle varianten zijn afgehandeld, wordt de toewijzing gecompileerd; anders ontstaat er een fout.
type Shape =
| { kind: "circle"; radius: number }
| { kind: "square"; side: number };
function area(s: Shape): number {
switch (s.kind) {
case "circle": return Math.PI * s.radius ** 2;
case "square": return s.side ** 2;
default:
const _exhaustive: never = s;
return _exhaustive;
}
}
console.log(area({ kind: "square", side: 3 }));Wat gebeurt er als je een case vergeet?
Als je een lid triangle toevoegt maar de bijbehorende case vergeet, is s in de standaardtak niet langer never, waardoor de toewijzing tijdens het compileren mislukt.
// type Shape = ... | { kind: "triangle"; base: number; height: number };
// Now in default, s is { kind: "triangle"; ... }
// const _exhaustive: never = s; // Error: triangle not assignable to neverDe assertNever-helper
Een herbruikbare functie assertNever centraliseert dit patroon. De functie accepteert never en gooit een fout, waarmee wordt gedocumenteerd dat de tak onbereikbaar hoort te zijn.
function assertNever(value: never): never {
throw new Error("Unhandled case: " + JSON.stringify(value));
}
console.log(typeof assertNever);assertNever in een switch gebruiken
Roep assertNever(s) aan in de standaardtak. Dit dwingt volledigheid af tijdens het compileren en geeft een duidelijke fout tijdens de uitvoering als de tak toch wordt bereikt.
function assertNever(value: never): never {
throw new Error("Unhandled: " + JSON.stringify(value));
}
type Shape =
| { kind: "circle"; radius: number }
| { kind: "square"; side: number };
function area(s: Shape): number {
switch (s.kind) {
case "circle": return Math.PI * s.radius ** 2;
case "square": return s.side ** 2;
default: return assertNever(s);
}
}
console.log(area({ kind: "circle", radius: 1 }).toFixed(2));Veiligheid tijdens compileren versus tijdens uitvoering
De controle met never vangt ontbrekende cases op voordat je de code uitvoert, en de gegooide fout beschermt je als er tijdens de uitvoering toch iets langs de typecontrole komt.
function assertNever(x: never): never {
throw new Error("Unhandled: " + String(x));
}
// Compile error if a case is missing; runtime throw as a backstop.
console.log("two layers of safety");Volledigheid zonder standaardtak
Als je functie een expliciet retourtype heeft en een switch elke case afdekt, kan TypeScript ook een ontbrekende retourwaarde signaleren. Dat is een andere vorm van volledigheidscontrole.
type Light = "red" | "yellow" | "green";
function next(l: Light): Light {
switch (l) {
case "red": return "green";
case "yellow": return "red";
case "green": return "yellow";
}
// No default needed; all cases return.
}
console.log(next("red"));Volledigheid met if/else-ketens
Hetzelfde idee werkt met if/else. Nadat elke variant is afgehandeld, ontvangt de laatste else een waarde van het type never.
function assertNever(x: never): never { throw new Error("bad"); }
type Shape =
| { kind: "circle"; radius: number }
| { kind: "square"; side: number };
function name(s: Shape): string {
if (s.kind === "circle") return "circle";
else if (s.kind === "square") return "square";
else return assertNever(s);
}
console.log(name({ kind: "square", side: 2 }));Waarom never het juiste hulpmiddel is
Omdat never aan niets kan worden toegewezen, zorgt elke overgebleven variant ervoor dat de toewijzing mislukt. Daardoor is never de perfecte detector voor niet-afgehandelde cases.
// Only never is assignable to never.
let x: never;
// x = "hi"; // Error
// Any concrete leftover type fails the same way.
console.log("never catches gaps");Volledigheid als vangnet bij refactoren
Met assertNever overal levert het toevoegen van een lid aan een unie een overzichtelijke lijst met compileerfouten op, precies op elke plek die je moet bijwerken.
function assertNever(x: never): never { throw new Error("unhandled"); }
type Status = "idle" | "busy";
function render(s: Status): string {
switch (s) {
case "idle": return "Idle";
case "busy": return "Busy";
default: return assertNever(s);
}
}
console.log(render("idle"));Korte controle: volledigheid
Test je begrip van controle op volledigheid.
Samenvatting: volledigheid met never
Je hebt geleerd om de waarde in de standaardtak toe te wijzen aan never of deze door te geven aan assertNever, zodat de compiler je dwingt elke variant af te handelen. Hierdoor worden vergeten cases compileerfouten.
function assertNever(x: never): never { throw new Error("unhandled"); }
type Shape = { kind: "circle"; radius: number } | { kind: "square"; side: number };
function f(s: Shape) {
switch (s.kind) {
case "circle": return s.radius;
case "square": return s.side;
default: return assertNever(s);
}
}
console.log(f({ kind: "circle", radius: 5 }));
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
Veelgestelde vragen
Is de les “Volledigheidscontrole met never” gratis?
Ja — de volledige tekst van “Volledigheidscontrole met never” 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 “Volledigheidscontrole met never”?
Vang niet-afgehandelde gevallen tijdens het compileren op met never 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 3 van 4.
Hoe lang duurt de les “Volledigheidscontrole met never”?
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
- Discriminated unions bouwen
- Vernauwen op basis van de discriminant
- Volledigheidscontrole met never
- State machines modelleren