Que sont les type assertions et quand sont-elles dangereuses ?

Question

Accepted Answer

Une **type assertion** dit au compilateur « fais-moi confiance, cette valeur est de type X » en utilisant `as`. Elle n'effectue **aucune conversion ou vérification au runtime** — elle change simplement la manière dont le compilateur traite la valeur.

```ts
const el = document.getElementById("app") as HTMLInputElement;
el.value = "hi"; // compiler now allows .value (it assumed HTMLInputElement)

const data = JSON.parse(str) as User; // assert the parsed shape
```

## Pourquoi c'est important

Une assertion contourne le jugement du compilateur — si tu te trompes, tu auras un crash au runtime sans avertissement :

```ts
const x = "hello" as unknown as number; // double assertion — compiler stops complaining
x.toFixed(2); // 💥 runtime error: x.toFixed is not a function
```

L'assertion ne *rend* pas la valeur de ce type ; elle fait juste taire le vérificateur. Tu as repris au compilateur la responsabilité de la correction.

## Alternatives plus sûres

```ts
// 1. type guard — actually verify at runtime
if (typeof input === "string") { /* input is string, proven */ }

// 2. validation library (zod) for external data
const user = UserSchema.parse(data); // throws if shape is wrong
```

## `as const` est différent

```ts
const point = { x: 1 } as const; // not a risky cast — narrows to literal/readonly
```

## Pourquoi c'est important

Les assertions sont parfois nécessaires (API DOM, affinage de `unknown` que tu as déjà vérifié), mais chacune d'elles est un endroit où le compilateur ne peut pas te protéger.

Préfère les type guards ou la validation de schéma pour les données non fiables, et traite chaque `as` comme un petit « je sais mieux » délibéré dont tu dois être certain.

Pourquoi c'est important

Alternatives plus sûres

as const est différent

Pourquoi c'est important

`as const` est différent