टाइप नेरोइंग क्या है और कंपाइलर इसे कैसे करता है?

Question

Accepted Answer

**नेरोइंग** यह है कि TypeScript एक व्यापक टाइप (जैसे यूनियन) को कोड ब्रांच के भीतर अधिक विशिष्ट टाइप में कैसे परिवर्तित करता है, रनटाइम चेक के आधार पर। कंपाइलर नियंत्रण प्रवाह को ट्रैक करता है और तदनुसार टाइप को अपडेट करता है।

```ts
function process(x: string | number) {
  if (typeof x === "string") {
    x.toUpperCase(); // ✅ here x is narrowed to string
  } else {
    x.toFixed(2);    // ✅ here x must be number
  }
}
```

## नेरोइंग के साधन

```ts
typeof x === "string"          // typeof guard — for primitives
x instanceof Date              // instanceof — for classes
"role" in obj                  // in operator — property existence
Array.isArray(x)               // built-in guards
if (x) { ... }                  // truthiness narrows out null/undefined/0/""
if (x === null) { ... }         // equality narrowing
```

## विभेदक यूनियन स्पष्ट रूप से नेरो होते हैं

```ts
type Shape =
  | { kind: "circle"; r: number }
  | { kind: "square"; side: number };

function area(s: Shape) {
  switch (s.kind) {            // the discriminant
    case "circle": return Math.PI * s.r ** 2;  // s is the circle variant
    case "square": return s.side ** 2;          // s is the square variant
  }
}
```

साझा लिटरल फील्ड (`kind`) को जांचने से कंपाइलर को सटीक पता चल जाता है कि आपके पास कौन सा वेरिएंट है, जो उस वेरिएंट की प्रॉपर्टीज़ को अनलॉक करता है।

## कस्टम गार्ड्स नेरोइंग को विस्तारित करते हैं

```ts
function isUser(x: unknown): x is User { return !!x && typeof (x as any).name === "string"; }
```

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

नेरोइंग वह है जो यूनियन टाइप्स को *उपयोगी* बनाता है — यह आपको टाइप-विशिष्ट सदस्यों को सुरक्षित रूप से एक्सेस करने देता है केवल तब जब आप टाइप साबित कर दें, रनटाइम चेक्स को कंपाइल-टाइम गारंटी में बदल देता है।

यह `string | number`, `T | null`, और टैग किए गए स्टेट को हैंडल करने के पीछे की दैनिक व्यवस्था है।