Qu'est-ce que l'opérateur d'assertion non-null (!) et quand est-il approprié?

Question

Accepted Answer

Le postfixe `!` dit au compilateur "Je garantis que cette valeur n'est **pas** null ou undefined ici" — supprime `null`/`undefined` de son type sans vérification d'exécution.

```ts
function f(name?: string) {
  // name is string | undefined
  console.log(name!.toUpperCase()); // `!` asserts it's defined → string
}
```

C'est purement une assertion au moment de la compilation — comme `as`, elle n'effectue **aucune** vérification à l'exécution. Si vous vous trompez, cela plante:

```ts
const el = document.getElementById("app")!; // assert non-null
el.innerHTML = "hi"; // 💥 runtime error if #app doesn't actually exist
```

## Quand c'est raisonnable

```ts
// 1. You've logically guaranteed it, but the compiler can't see it
if (map.has(key)) map.get(key)!.doThing(); // has() proves get() isn't undefined

// 2. Class fields initialized outside the constructor (DI, lifecycle hooks)
class C { value!: string; } // definite assignment assertion
```

## Préférez les alternatives plus sûres

```ts
name?.toUpperCase();           // optional chaining — no crash, yields undefined
const x = name ?? "default";    // provide a fallback
if (name) name.toUpperCase();   // narrow with a real check
```

Chacune d'elles *gère* le cas manquant au lieu de l'ignorer.

## Pourquoi c'est important

`!` est un outil acéré : il réduit au silence la sécurité null que le compilateur essaie de vous donner.

C'est occasionnellement justifié (vous avez des connaissances que le compilateur n'a pas), mais l'abus le réintroduit exactement les bugs null-crash que `strictNullChecks` prévient.

Recourez d'abord à `?.`, `??`, ou à une garde explicite ; utilisez `!` uniquement lorsque vous pouvez vraiment prouver la non-nullité.