Type inference ఎలా పని చేస్తుంది?

Question

Accepted Answer

**Type inference** TypeScript సందర్భం నుండి రకాలను స్వయంచాలకంగా గుర్తించడం, కాబట్టి మీరు ప్రతిదాన్ని annotate చేయవలసిన అవసరం లేదు. ఇది ప్రారంభ విలువలు, 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 కోడ్‌ను JavaScript కంటే దాదాపు సంక్షిప్తంగా ఉంచుతుంది కాని పూర్తిగా typed ఉంటుంది.

ఇది ఎప్పుడు సక్రియమైనది (మరియు ఎప్పుడు విస్తరిస్తుంది) అర్థం చేసుకోవడం ఇది నిజంగా సహాయపడే చోట మాత్రమే annotate చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.