Comment fonctionne l'inférence de type ?

Question

Accepted Answer

L'**inférence de type** est la façon dont TypeScript détermine automatiquement les types à partir du contexte, vous évitant d'avoir à tout annoter. Elle déduit des valeurs initiales, des return statements et de l'utilisation.

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

## Inférence dans les fonctions et les 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
```

Ce **typage contextuel** est pourquoi les callbacks ont rarement besoin d'annotations de paramètres — TypeScript sait que `map` sur un `number[]` passe un `number`.

## Élargissement let vs const

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

`const` déduit le type *littéral* car il ne peut jamais changer ; `let` s'élargit au type général. C'est important pour les unions :

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

## Quand annoter de toute façon

- Paramètres de fonction (ne peuvent pas être déduits).
- Quand l'inférence est trop large/étroite (p. ex. vous voulez `string` pas le littéral).
- Conteneurs vides : `const xs = []` déduit `any[]` — annotez comme `number[]`.

## Pourquoi c'est important

L'inférence maintient le code TypeScript presque aussi concis que JavaScript tout en restant complètement typé.

Comprendre *quand* elle s'active (et quand elle s'élargit) vous permet d'annoter uniquement où cela aide réellement.