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 இல் Inference

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

இந்த **contextual typing** callbacks வெகுவாக parameter annotations தேவைப்படாத காரணம் — TypeScript `number[]` மீது `map` ஒரு `number` கடிக்கிறது என்று அறியும்.

## let vs const widening

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

## எப்போது annotation செய்ய வேண்டும்

- செயல்பாட்டின் parameters (தீர்மானிக்க முடியாது).
- Inference மிகவும் விரிவாகவோ குறுகியதாகவோ இருக்கும் போது (உதாரணமாக நீங்கள் `string` விரும்புகிறீர்கள் literal அல்ல).
- வெற்று containers: `const xs = []` `any[]` தீர்மானிக்கிறது — `number[]` என annotate செய்யுங்கள்.

## இது ஏன் முக்கியமாக இருக்கிறது

Inference TypeScript code ஐ JavaScript ஐப்போல் எளிமையாக வைத்திருந்து, முழுவதுமாக typed ஆக இருக்க வைக்கிறது.

এটি எப்போது செயல்படுகிறது (மற்றும் எப்போது விரிவுபடுகிறது) என்பதைப் புரிந்துகொள்ள, நீங்கள் உண்மையில் உதவும் இடங்களில் மட்டுமே annotation செய்ய முடியும்.