ஒரு user-defined type guard என்பது ஒரு type predicate (x is T) என்ற return type கொண்ட function ஆகும். அது true என்று திரும்பும்போது, compiler அந்த argument-ஐ calling code-இல் T-ஆக narrow செய்கிறது — இதன் மூலம் தனிப்பயன் runtime சரிபார்ப்புகளை நீங்கள் 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 தவறாக இருந்தால், நீங்கள் பாதுகாப்பற்ற narrowing-ஐ பெறுவீர்கள். சிக்கலான வடிவங்களுக்கு (shapes), ஒரு schema validator (zod) உங்களுக்கு சரியான guard-களை உருவாக்கித் தரும்.
type guard-கள், ஏதேனும் runtime சரிபார்ப்புகளை மீண்டும் பயன்படுத்தக்கூடிய narrowing function-களாக மாற்ற உதவுகின்றன — API/boundary-களில் unknown தரவை validate செய்யவும், எளிய typeof/in சரிபார்ப்பு மட்டும் போதாதபோது ஒரு union-இன் உறுப்பினர்களை வேறுபடுத்தவும் இவை இன்றியமையாதவை.