🔎Type Narrowing

Eine Variable hat einen deklarierten Typ – und an jeder Stelle im Code einen aktuellen, oft schmaleren Typ. Die Kontrollflussanalyse des Compilers wertet if, switch, return und Zuweisungen aus. Gehen Sie Schritt für Schritt durch – jeder angezeigte Typ kommt direkt vom Compiler.

typeof-Wächter: typeof x === "string" ist ganz normales JavaScript – TypeScript versteht die Prüfung und grenzt den Typ im jeweiligen Zweig ein.

Quelltext · gelb = aktuelle Zeile · Maus über Namen zeigt Typennur lesen

function formatiere(wert: string | number | boolean) {
  if (typeof wert === "string") {
    return wert.trim();
  }
  if (typeof wert === "number") {
    return wert.toFixed(2);
  }
  return wert ? "ja" : "nein";
}

function formatiere(wert: string | number | boolean) {
  if (typeof wert === "string") {
    return wert.trim();
  }
  if (typeof wert === "number") {
    return wert.toFixed(2);
  }
  return wert ? "ja" : "nein";
}

Schritt 1 / 5 · Tasten ← →

Zeile 1 · Typ von

wert

Compiler rechnet …

Mögliche Typen (Union-Mitglieder)

Schritt 1

Der Parameter ist als Union aus drei Typen deklariert – mehr weiß der Compiler hier noch nicht.

Alle Schritte

✍️Selbst ausprobieren

Der never-Check im default meldet, dass Fälle fehlen. Ergänzen Sie case "laedt" und case "fehler", bis der Fehler verschwindet.

TypeScript · bearbeitbar, Maus über Namen zeigt Typen

type Antwort =
  | { status: "laedt" }
  | { status: "ok"; daten: string[] }
  | { status: "fehler"; meldung: string };

function zeige(a: Antwort) {
  // Fahren Sie über „a“ – und ergänzen Sie die fehlenden Fälle!
  switch (a.status) {
    case "ok":
      return a.daten.join(", ");
    default:
      const rest: never = a;
      return rest;
  }
}

💡 Was grenzt ein?

typeof x === "…", x instanceof K, "p" in x, Vergleiche (===, !==), Wahrheitsprüfungen, Array.isArray, Type Guards (x is T), Assertion-Funktionen (asserts x is T) und Zuweisungen.

⚠️ Grenzen

Eine Eingrenzung gilt nicht in einer anderen Funktion: Wird eine let-Variable später noch neu zugewiesen, kann der Compiler in einem Callback nicht wissen, welcher Wert gerade drinsteht – dort gilt wieder der deklarierte Typ. Außerdem ist ein Type Guard nur so gut wie seine Implementierung.