Ein user-defined type guard ist eine Funktion, deren Rückgabetyp ein type predicate (x is T) ist. Wenn es true zurückgibt, grenzt der Compiler das Argument im aufrufenden Code auf T ein — und ermöglicht es Ihnen, benutzerdefinierte Runtime-Checks zu kapseln.
interface Cat { meow(): void; }
interface Dog { bark(): void; }
// the magic is the return type `pet is Cat`, not just `boolean`
function isCat(pet: Cat | Dog): pet is Cat {
return "meow" in pet;
}
function speak(pet: Cat | Dog) {
if (isCat(pet)) {
pet.meow(); // ✅ narrowed to Cat
} else {
pet.bark(); // ✅ narrowed to Dog
}
}
Ohne das Prädikat pet is Cat würde isCat mit Rückgabe von boolean pet nicht eingrenzen — der Compiler würde immer noch Cat | Dog innerhalb von if sehen. Das Prädikat ist das, was es lehrt.
interface User { id: number; name: string; }
function isUser(x: unknown): x is User {
return (
typeof x === "object" && x !== null &&
typeof (x as any).id === "number" &&
typeof (x as any).name === "string"
);
}
const data: unknown = await res.json();
if (isUser(data)) data.name; // ✅ safely typed as User
Der Compiler vertraut Ihrem Prädikat — wenn die Logik im Body falsch ist, erhalten Sie eine unsichere Eingrenzung. Für komplexe Formen generiert ein Schema-Validator (zod) korrekte Guards für Sie.
Type Guards ermöglichen es Ihnen, willkürliche Runtime-Checks in wiederverwendbare Eingrenzungs-Funktionen umzuwandeln — unerlässlich zur Validierung von unknown Daten an API-Grenzen und zur Unterscheidung von Union-Membern, wenn eine einfache typeof/in Überprüfung allein nicht ausreicht.