TypeScript Academy · Lektion

Vollständigkeitsprüfung mit never

Erkennen Sie unbehandelte Fälle zur Compile-Zeit mit never.

Vollständigkeitsprüfung mit never ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Das Problem der Vollständigkeit

Wenn Sie ein neues Union-Mitglied hinzufügen, vergessen Sie leicht, es an einer Stelle zu behandeln. Eine Vollständigkeitsprüfung macht dieses Versäumnis zu einem Compile-Fehler.

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

// If we add "triangle" later, we want every switch to complain.

Der Typ never

Der Typ never steht für Werte, die niemals auftreten können. Wenn jeder Fall behandelt wurde, hat der Wert, der den Standardzweig erreicht, den Typ never.

function fail(): never {
  throw new Error("unreachable");
}
// never is assignable to nothing except never itself.

Im Standardfall never zuweisen

Weisen Sie im default-Zweig den Wert einer never-Variablen zu. Wenn alle Varianten behandelt wurden, lässt sich die Zuweisung kompilieren; andernfalls tritt ein Fehler auf.

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

Was passiert, wenn Sie einen Fall vergessen?

Wenn Sie ein triangle-Mitglied hinzufügen, aber dessen Fall vergessen, ist s im Standardzweig nicht mehr never, sodass die Zuweisung zur Compile-Zeit fehlschlägt.

// type Shape = ... | { kind: "triangle"; base: number; height: number };
// Now in default, s is { kind: "triangle"; ... }
// const _exhaustive: never = s; // Error: triangle not assignable to never

Der assertNever-Hilfsfunktion

Eine wiederverwendbare Funktion assertNever kapselt dieses Muster. Sie akzeptiert never und löst einen Fehler aus, um zu dokumentieren, dass der Zweig unerreichbar sein sollte.

function assertNever(value: never): never {
  throw new Error("Unhandled case: " + JSON.stringify(value));
}
console.log(typeof assertNever);

assertNever in einer Switch-Anweisung verwenden

Rufen Sie im Standardfall assertNever(s) auf. Dadurch wird die Vollständigkeit zur Compile-Zeit erzwungen und bei einer tatsächlichen Ausführung ein eindeutiger Laufzeitfehler ausgegeben.

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

Sicherheit zur Compile-Zeit und zur Laufzeit

Die never-Prüfung erkennt fehlende Fälle, bevor Sie den Code ausführen, und der ausgelöste Fehler schützt Sie zur Laufzeit, falls etwas die Typprüfung umgeht.

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");

Vollständigkeit ohne Standardfall

Wenn Ihre Funktion einen expliziten Rückgabetyp besitzt und eine Switch-Anweisung jeden Fall abdeckt, kann TypeScript auch eine fehlende Rückgabe melden – eine weitere Form der Vollständigkeitsprüfung.

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"));

Vollständigkeit mit if/else-Ketten

Dasselbe Prinzip funktioniert mit if/else. Nachdem jede Variante behandelt wurde, erhält das abschließende else einen never-Wert.

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

Warum never das richtige Werkzeug ist

Da never keinem anderen Typ zugewiesen werden kann, führt jede verbleibende Variante zu einem Fehler bei der Zuweisung. Damit ist never der perfekte Erkennungsmechanismus für unbehandelte Fälle.

// 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");

Vollständigkeit als Sicherheitsnetz beim Refactoring

Mit assertNever an jeder relevanten Stelle erzeugt das Hinzufügen eines Union-Mitglieds eine übersichtliche Liste von Compile-Fehlern, die genau auf jede zu aktualisierende Stelle verweist.

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"));

Kurze Überprüfung: Vollständigkeit

Testen Sie Ihr Verständnis der Vollständigkeitsprüfung.

Zusammenfassung: Vollständigkeit mit never

Sie haben gelernt, den Standardwert never zuzuweisen oder an assertNever zu übergeben, damit der Compiler Sie zwingt, jede Variante zu behandeln. So werden vergessene Fälle zu Compile-Fehlern.

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

Häufig gestellte Fragen

Ist die Lektion „Vollständigkeitsprüfung mit never“ kostenlos?

Ja — der vollständige Text von „Vollständigkeitsprüfung mit never“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Vollständigkeitsprüfung mit never“?

Erkennen Sie unbehandelte Fälle zur Compile-Zeit mit never. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Vollständigkeitsprüfung mit never“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu TypeScript Academy