Si funksionon përfundimi i tipeve?

Question

Accepted Answer

**Përfundimi i tipeve** është kur TypeScript zbulon tipet automatikisht nga konteksti, kështu që nuk duhet t'i shënosh të gjitha. Zbulon nga vlerat fillestare, deklaratat e kthimit, dhe përdorimi.

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

## Përfundimi në funksione dhe callback-e

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

Ky **shënimi kontekstual** është arsyeja pse callback-et rrallë kanë nevojë për shënime parametrash — TypeScript e di se `map` në një `number[]` kalon një `number`.

## let vs const zgjerimi

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

`const` zbulon tipin *literal* sepse nuk mund të ndryshojë; `let` zgjerohet në tipin e përgjithshëm. Kjo ka rëndësi për unione:

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

## Kur të shënosh gjithsesi

- Parametrat e funksionit (nuk mund të përfundohen).
- Kur përfundimi është shumë i gjerë/i ngushtë (p.sh. dëshiron `string` jo literalin).
- Enë bosh: `const xs = []` zbulon `any[]` — shënoje si `number[]`.

## Pse ka rëndësi

Përfundimi e mban kodin TypeScript pothuajse kaq të përgjithshëm sa JavaScript ndërkohë që mbetet plotësisht i tipizuar.

Kuptimi i *kur* aktivizohet (dhe kur zgjerohet) të lejon të shënosh vetëm ku ndihmesë me të vërtetë.