Type narrowing भनेको के हो र compiler यो कसरी गर्छ?

Question

Accepted Answer

**Narrowing** भनेको TypeScript-ले एक विस्तृत प्रकार (जस्तै union) लाई कोडको शाखामा थप विशिष्ट प्रकारमा परिष्कृत गरेको तरिका हो, runtime checks को आधारमा। Compiler नियन्त्रण प्रवाह ट्र्याक गर्छ र प्रकारलाई तदनुसार अद्यावधिक गर्छ।

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

## Narrowing उपकरणहरू

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

## विभेदीकृत unions स्पष्टतासँग संकुचित हुन्छन्

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

साझा literal फील्ड (`kind`) जाँचले compiler लाई बिल्कुल बताउछ कि तपाईसँग कुन variant छ, त्यो variant को गुणहरू अनलक गर्छ।

## कस्टम guards narrowing विस्तृत गर्छन्

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

## किन यो महत्त्वपूर्ण छ

Narrowing भनेको जुन कुराले union types *प्रयोगयोग्य* बनाउँछ — यसले तपाईलाई प्रकार प्रमाणित गरेपछिमात्र type-specific सदस्यहरूमा सुरक्षित रूपमा पहुँच गर्न दिन्छ, runtime checks लाई compile-time ग्यारान्टीमा परिणत गर्छ।

यो `string | number`, `T | null`, र tagged state सम्हाल्नको पछाडिको दैनिक संयन्त्र हो।