Wat is de non-null assertion operator (!) en wanneer is het geschikt?

Question

Accepted Answer

De postfix `!` vertelt de compiler "Ik garandeer dat deze waarde hier **niet** null of undefined is" — verwijdert `null`/`undefined` uit zijn type zonder enige runtime controle.

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

Het is puur een compile-time assertion — net als `as`, voert het **geen** runtime verificatie uit. Als je het mis hebt, crasht het:

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

## Wanneer het redelijk is

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

## Verkies veiligere alternatieven

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

Elk van deze *behandelt* het ontbrekende geval in plaats van het weg te stellen.

## Waarom het belangrijk is

`!` is een scherp gereedschap: het zet de null-veiligheid het zwijgen op die de compiler je probeert te geven.

Het is af en toe gerechtvaardigd (je hebt kennis die de compiler niet heeft), maar overmatig gebruik herintroduceert precies de null-crash bugs die `strictNullChecks` voorkomen.

Grij eerst naar `?.`, `??`, of een expliciete guard; gebruik `!` alleen als je echt non-nullness kunt bewijzen.