यूजर-डिफाइंड टाइप गार्ड क्या है?

Question

Accepted Answer

एक **यूजर-डिफाइंड टाइप गार्ड** एक फ़ंक्शन है जिसका रिटर्न टाइप एक **टाइप प्रेडिकेट** (`x is T`) है। जब यह `true` रिटर्न करता है, तो कंपाइलर आर्गुमेंट को कॉलिंग कोड में `T` तक सीमित कर देता है — आपको कस्टम रनटाइम चेक को एनकैप्सुलेट करने देता है।

```ts
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` प्रेडिकेट के बिना, `isCat` रिटर्निंग `boolean` `pet` को *नरो* नहीं करेगी — कंपाइलर अभी भी `if` के अंदर `Cat | Dog` देखेगा। प्रेडिकेट ही वह चीज़ है जो इसे सिखाती है।

## अज्ञात बाहरी डेटा को मान्य करना

```ts
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
```

## सावधानी

कंपाइलर आपकी प्रेडिकेट पर **विश्वास** करता है — अगर बॉडी का लॉजिक गलत है, तो आपको असुरक्षित नैरोइंग मिलता है। जटिल आकृतियों के लिए, एक स्कीमा वेलिडेटर (zod) आपके लिए सही गार्ड्स जेनरेट करता है।

## यह क्यों महत्वपूर्ण है

टाइप गार्ड्स आपको मनमानी रनटाइम चेक्स को पुन: प्रयोज्य नैरोइंग फ़ंक्शन में बदलने देते हैं — API/सीमाओं पर `unknown` डेटा को मान्य करने के लिए आवश्यक और यूनियन के सदस्यों को अलग करने के लिए जब एक साधारण `typeof`/`in` चेक अकेले पर्याप्त न हो।