Hvad er non-null assertion-operatoren (!) og hvornår er det passende?

Question

Accepted Answer

Postfiks `!` fortæller compileren "Jeg garanterer, at denne værdi **ikke er** null eller undefined her" — fjerner `null`/`undefined` fra dens type uden nogen runtime-kontrol.

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

Det er rent og skært en compile-time-assertion — ligesom `as` udfører den **ingen** runtime-verifikation. Hvis du tager fejl, går det ned:

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

## Hvornår det er rimeligt

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

## Foretrække mere sikre alternativer

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

Hver af disse *håndterer* det manglende tilfælde i stedet for at påstå det væk.

## Hvorfor det betyder noget

`!` er et skarpt værktøj: det får compileren til at tie ned om null-sikkerhed.

Det kan være berettiget af og til (du har viden, som compileren mangler), men overuse introducerer præcis de null-crash-bugs, som `strictNullChecks` forhindrer.

Grib efter `?.`, `??`, eller en eksplicit guard først; brug `!` kun når du virkelig kan bevise non-nullness.