Que fait l'assertion `as const` ?

Question

Accepted Answer

`as const` est une **const assertion** qui indique à TypeScript de déduire le type **le plus spécifique (littéral), profondément readonly** pour une valeur, au lieu de l'élargir.

```ts
// without as const — widened, mutable
let a = "up";            // type: string
const obj = { x: 1 };     // type: { x: number }
const arr = [1, 2];       // type: number[]

// with as const — narrow literals, readonly
const b = "up" as const;          // type: "up"
const obj2 = { x: 1 } as const;    // type: { readonly x: 1 }
const arr2 = [1, 2] as const;      // type: readonly [1, 2] (a tuple!)
```

Elle fait trois choses : n'élargit *rien* (conserve les valeurs littérales), rend tout `readonly` et transforme les tableaux en **tuples**.

## Pourquoi c'est tellement utile

**Dériver un type union d'une liste de valeurs (source unique de vérité) :**

```ts
const ROLES = ["admin", "editor", "viewer"] as const;
type Role = typeof ROLES[number]; // "admin" | "editor" | "viewer"
// add a role to the array → the union updates automatically
```

**Préserver les types littéraux pour config/state :**

```ts
const action = { type: "INCREMENT", by: 1 } as const;
// action.type is "INCREMENT" (a literal), so it works in discriminated unions
// without as const it'd be `string`, breaking narrowing
```

## Pourquoi c'est important

`as const` fait le lien entre les valeurs d'exécution et les types précis.

Cela vous permet de définir les données une seule fois (un tableau/objet) et d'en déduire les types littéraux exacts — indispensable pour les types d'actions, les cartes de routes, la config et tout tag d'union discriminée qui doit rester un littéral au lieu de s'élargir à `string`.