ਟਾਈਪ ਇਨਫਰੈਂਸ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?

Question

Accepted Answer

**Type inference** TypeScript ਦਾ ਸੰਦਰਭ ਤੋਂ ਆਪਣੇ ਆਪ ਨੂੰ ਕਿਸਮਾਂ ਦਾ ਪਤਾ ਲਗਾ ਲੈਣਾ ਹੈ, ਤਾਂ ਜੋ ਤੁਹਾਨੂੰ ਸਭ ਕੁਝ ਵਿਤਵਿਆ ਨਾ ਕਰਨਾ ਪਵੇ। ਇਹ ਸ਼ੁਰੂਆਤੀ ਮੁੱਲਾਂ, ਵਾਪਸੀ ਦੇ ਬਿਆਨਾਂ, ਅਤੇ ਵਰਤੋਂ ਤੋਂ ਅਨੁਮਾਨ ਲਗਾਉਂਦਾ ਹੈ।

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

ਇਹ **contextual typing** ਇਸ ਲਈ ਹੈ ਕਿ callbacks ਨੂੰ ਘੱਟ ਹੀ ਪੈਰਾਮੀਟਰ ਵਿਤਵਿਆ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ — TypeScript ਜਾਣਦਾ ਹੈ ਕਿ `map` ਇੱਕ `number[]` ਤੇ ਇੱਕ `number` ਪਾਸ ਕਰਦਾ ਹੈ।

## let ਬਨਾਮ 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
```

## ਫਿਰ ਵੀ ਕਦੋਂ ਵਿਤਵਿਆ ਕਰੀਏ

- ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰ (ਅਨੁਮਾਨ ਨਹੀਂ ਲਗ ਸਕਦਾ)।
- ਜਦੋਂ ਇਨਫਰੈਂਸ ਬਹੁਤ ਚੌੜਾ/ਤੰਗ ਹੋ (ਉਦਾ. ਤੁਸੀਂ `string` ਚਾਹੁੰਦੇ ਹੋ literal ਨਹੀਂ)।
- ਖਾਲੀ containers: `const xs = []` ਇੱਕ `any[]` ਦਾ ਅਨੁਮਾਨ ਲਗਾਉਂਦਾ ਹੈ — `number[]` ਵਜੋਂ ਵਿਤਵਿਆ ਕਰੋ।

## ਇਹ ਕਿਉਂ ਮਾਹਿਤੀ ਰੱਖਦਾ ਹੈ

Inference TypeScript code ਨੂੰ JavaScript ਜਿੰਨਾ ਸੰਖੇਪ ਰੱਖਦਾ ਹੈ ਜਦੋਂ ਕਿ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕਿਸਮ ਨਾਲ ਵੱਖ ਰਿਹਾ ਹੈ।

*ਕਦੋਂ* ਇਹ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ (ਅਤੇ ਕਦੋਂ ਇਹ ਚੌੜਾ ਹੁੰਦਾ ਹੈ) ਨੂੰ ਸਮਝਣਾ ਤੁਹਾਨੂੰ ਸਿਰਫ ਜਹਾਂ ਇਹ ਸੱਚਮੁੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਉਥੇ ਵਿਤਵਿਆ ਕਰਨ ਦਿੰਦਾ ਹੈ।