Type inference कसरी काम गर्छ?

Question

Accepted Answer

**Type inference** हो TypeScript ले संदर्भबाट स्वचालित रूपमा प्रकारहरू बुझ्न खोज्ने कुरा हो, त्यसैले तपाईंले सबै कुरामा एनोटेसन गर्न आवश्यक छैन। यो प्रारम्भिक मानहरू, return कथनहरू, र प्रयोगबाट अनुमान गर्छ।

```ts
let x = 10;          // inferred: number
let s = "hi";        // inferred: string
const arr = [1, 2];  // inferred: number[]
const obj = { a: 1, b: "x" }; // inferred: { a: number; b: string }
```

## कार्यहरू र callbacks मा अनुमान

```ts
function double(n: number) { return n * 2; } // return inferred as number

[1, 2, 3].map(n => n * 2); // `n` inferred as number from the array — no annotation needed
```

यो **संदर्भगत टाइपिङ** कारण हो कि callbacks लाई विरलै प्यारामिटर एनोटेशन आवश्यक हुन्छ — TypeScript जान्दछ कि `map` on `number[]` ले `number` पास गर्छ।

## let vs const विस्तार

```ts
let a = "hello";     // widened to string (let can be reassigned)
const b = "hello";   // narrowed to the literal type "hello"
```

`const` ले *literal* प्रकार अनुमान गर्छ किनभने यो कहिलै परिवर्तन हुन सक्दैन; `let` सामान्य प्रकारमा विस्तार हुन्छ। यो unions को लागि महत्त्वपूर्ण छ:

```ts
const dir = "up";              // type "up"
let dir2 = "up";               // type string
```

## कहिले अनुमान गर्ने

- कार्य प्यारामिटरहरू (अनुमान गर्न सकिँदैन)।
- जब अनुमान खुबै चौडो/साँघुरो हुन्छ (जस्तै तपाईं `string` चाहनुहुन्छ literal होइन)।
- खाली कन्टेनरहरू: `const xs = []` ले `any[]` अनुमान गर्छ — `number[]` को रूपमा एनोटेट गर्नुहोस्।

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

अनुमानले TypeScript कोडलाई JavaScript जस्तै संक्षिप्त राख्छ जब यो पूर्णतः प्रकार गरिएको रहन्छ।

*कहिले* यो सुरु हुन्छ (र कहिले विस्तार हुन्छ) भन्ने कुरा बुझ्दा तपाईंले केवल जहाँ यो साँच्चै मद्दत गर्छ त्यहाँ एनोटेट गर्न सक्नुहुन्छ।