एक user-defined type guard हा असा फंक्शन आहे ज्याचा return type हा एक type predicate (x is T) असतो. जेव्हा तो true रिटर्न करतो, तेव्हा compiler argument ला T मध्ये narrowing करतो calling code मध्ये — यामुळे तुम्ही custom runtime checks encapsulate करू शकता.
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
}
}
pet is Cat predicate न असल्यास, isCat हा boolean रिटर्न करील पण pet ला narrow करणार नाही — compiler हा if च्या आतील Cat | Dog दाखत राहील. Predicate हेच आहे जे तिला शिकवते.
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
Compiler विश्वास ठेवतो तुमच्या predicate वर — जर body मधील logic चुकीचे असेल, तर तुम्हाला unsafe narrowing मिळेल. Complex shapes साठी, schema validator (zod) तुमच्यासाठी सुरक्षित guards generate करतो.
Type guards तुम्हाला arbitrary runtime checks ला reusable narrowing functions मध्ये रूपांतरित करू देतात — unknown डेटा API/boundaries मध्ये validate करण्यासाठी आवश्यक आहे आणि union च्या सदस्यांमध्ये फरक करण्यासाठी जेव्हा साधे typeof/in check पुरेसे नाही.