Cum funcționează inferența de tip?

Question

Accepted Answer

**Inferența de tip** este atunci când TypeScript descoperă tipurile automat din context, deci nu trebuie să adnotezi totul. Deduce din valori inițiale, din instrucțiuni return și din utilizare.

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

## Inferența în funcții și callback-uri

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

Această **tipizare contextuală** este motivul pentru care callback-urile rareori au nevoie de adnotări de parametri — TypeScript știe că `map` pe un `number[]` transmite un `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` deduce tipul *literal* pentru că nu se poate schimba niciodată; `let` se extinde la tipul general. Aceasta contează pentru uniuni:

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

## Când să adnotezi oricum

- Parametri de funcții (nu pot fi deduși).
- Când inferența este prea largă/îngustă (de ex. vrei `string` nu literalul).
- Containere goale: `const xs = []` deduce `any[]` — adnotează ca `number[]`.

## De ce contează

Inferența ține codul TypeScript aproape la fel de concis ca JavaScript, rămânând pe deplin tipizat.

Înțelegerea *când* se activează (și când se extinde) te lasă să adnotezi doar acolo unde ajută cu adevărat.