Een user-defined type guard is een functie waarvan het retourtype een type predicate (x is T) is. Als het true retourneert, vernauwt de compiler het argument tot T in de aanroepende code — zodat u aangepaste runtime-controles kunt inkapselen.
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
}
}
Zonder het pet is Cat predicate zou isCat die boolean retourneert het type van pet niet vernauwwen — de compiler zou nog steeds Cat | Dog binnen de if zien. Het predicate is wat de compiler dit leert.
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
De compiler vertrouwt uw predicate — als de logica in de body onjuist is, krijgt u een onveilige vernauwing. Voor complexe vormen genereert een schema-validator (zod) correcte guards voor u.
Type guards stellen u in staat om willekeurige runtime-controles om te zetten in herbruikbare vernallmingsfuncties — essentieel voor het valideren van unknown gegevens op API-grenzen en voor het onderscheiden van leden van een union als een eenvoudige typeof/in-controle niet op zichzelf voldoende is.