TypeScript Academy · Lektion

Der Typ never und unmögliche Zustände

Modellieren Sie nicht erreichbaren Code und unmögliche Werte mit never.

Der Typ never und unmögliche Zustände ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Der never-Typ

never ist der leere Typ – er steht für Werte, die niemals auftreten können. Kein Wert kann never zugewiesen werden, außer never selbst. Damit werden Situationen gekennzeichnet, die unmöglich sein sollten.

// You cannot create a value of type never
function crash(): never {
  throw new Error('boom');
}
try { crash(); } catch (e) { console.log('caught'); }

Funktionen, die nie zurückkehren

Eine Funktion, die immer throw ausführt, kehrt nie normal zurück und hat daher den Rückgabetyp never. Das teilt den Aufrufern und dem Compiler mit, dass die Ausführung hier endet.

function fail(message: string): never {
  throw new Error(message);
}
try { fail('invalid'); } catch (e) { console.log('handled'); }

Endlosschleifen liefern never zurück

Eine Funktion mit einer Endlosschleife kehrt ebenfalls nie zurück und wird daher auch als never typisiert. Der Compiler erkennt, dass der Kontrollfluss danach nicht fortgesetzt werden kann.

function listen(): never {
  while (true) {
    // forever
    break; // (break added so the demo terminates)
  }
  throw new Error('stopped');
}
console.log('listen has return type never');

never und void

Verwechseln Sie never nicht mit void. Eine void-Funktion kehrt zurück, liefert aber lediglich keinen nützlichen Wert. Eine never-Funktion kehrt überhaupt nicht zurück – sie löst einen Fehler aus oder läuft endlos.

function logIt(): void {
  console.log('done'); // returns normally
}
function abort(): never {
  throw new Error('stop'); // never returns
}
logIt();
try { abort(); } catch (e) { console.log('ok'); }

never bei Vollständigkeitsprüfungen

Die praktischste Verwendung von never ist die Vollständigkeitsprüfung. Weisen Sie die Variable im Standardzweig eines switch einer never-Variablen zu. Wenn alle Fälle verarbeitet sind, hat die Variable bereits den Typ never und der Code wird kompiliert.

type Shape = 'circle' | 'square';

function area(s: Shape): string {
  switch (s) {
    case 'circle': return 'pi r^2';
    case 'square': return 'a^2';
    default:
      const _check: never = s; // ok: all handled
      return _check;
  }
}
console.log(area('square'));

Fehlende Fälle erkennen

Wenn jemand ein neues Union-Mitglied hinzufügt, aber einen Fall vergisst, hat der übrig gebliebene Wert nicht mehr den Typ never und die Zuweisung wird nicht kompiliert. Die never-Prüfung macht aus einer stillen Lücke einen deutlich sichtbaren Fehler.

type Shape = 'circle' | 'square' | 'triangle';
// If 'triangle' case is missing, assigning s to never
// would error: 'triangle' is not assignable to never.
console.log('Add a case for every member');

never in unmöglichen Union-Zweigen

Wenn durch Eingrenzung jede Möglichkeit ausgeschlossen wird, ist der verbleibende Typ never. Der Compiler weiß, dass dieser Zweig nicht erreichbar ist, und kann dadurch logische Fehler aufdecken.

function check(x: string | number): void {
  if (typeof x === 'string') {
    console.log('string');
  } else if (typeof x === 'number') {
    console.log('number');
  } else {
    // x is never here
    console.log('unreachable');
  }
}
check('hi');

never als unterster Typ

never ist der unterste Typ: Er kann jedem anderen Typ zugewiesen werden, weil ein nicht möglicher Wert zwangsläufig mit allem kompatibel ist. Deshalb kann ein throw an jeder Ausdrucksposition stehen.

function getOrThrow(v: string | null): string {
  return v ?? fail();
}
function fail(): never {
  throw new Error('missing');
}
console.log(getOrThrow('value'));

Unions zu never filtern

In bedingten und gemappten Typen wirkt never wie „entferne dies“. Eine Union mit never verändert nichts: T | never ist einfach T. Dadurch eignet sich never besonders zum Filtern.

type Keep<T> = T extends string ? T : never;
type R = Keep<'a' | 1 | 'b'>; // 'a' | 'b'
const x: R = 'a';
console.log(x);

Unmögliche Zustände modellieren

Verwenden Sie never in Objektstrukturen, um unzulässige Kombinationen nicht darstellbar zu machen. Ein „loading“-Zustand kann hier keine Daten enthalten, weil der Typ dies verbietet.

type State =
  | { status: 'loading'; data?: never }
  | { status: 'ready'; data: number };

const s: State = { status: 'ready', data: 7 };
console.log(s);

never verbessert die Sicherheit beim Refactoring

Da never-Vollständigkeitsprüfungen fehlschlagen, wenn ein Fall fehlt, machen sie Refactorings sicherer: Erweitern Sie eine Union, zeigt der Compiler auf jede Stelle, die aktualisiert werden muss.

type Cmd = 'start' | 'stop';
function run(c: Cmd): string {
  if (c === 'start') return 'starting';
  if (c === 'stop') return 'stopping';
  const _x: never = c;
  return _x;
}
console.log(run('start'));

Kurzer Test

Testen Sie Ihr Verständnis des never-Typs.

Zusammenfassung: never

Sie haben gelernt, dass never:

der leere Typ ist – kein Wert kann vom Typ never sein.
der Rückgabetyp von Funktionen ist, die einen Fehler auslösen oder endlos laufen.
Exhaustiveness-Checks in Standardfällen von switch ermöglicht.
in unmöglichen Narrowing-Zweigen auftritt und Vereinigungen in der Typenlogik filtert.

Als Nächstes sehen wir uns void an und wie es sich davon unterscheidet.

function assertNever(x: never): never {
  throw new Error('Unexpected: ' + String(x));
}
console.log('assertNever guards exhaustiveness');

Häufig gestellte Fragen

Ist die Lektion „Der Typ never und unmögliche Zustände“ kostenlos?

Ja — der vollständige Text von „Der Typ never und unmögliche Zustände“ 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 „Der Typ never und unmögliche Zustände“?

Modellieren Sie nicht erreichbaren Code und unmögliche Werte 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 2 von 4.

Wie lange dauert die Lektion „Der Typ never und unmögliche Zustände“?

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