Vad är non-null assertion-operatorn (!) och när är det lämpligt att använda den?

Question

Accepted Answer

Postfix `!` talar om för kompilatorn "Jag garanterar att detta värde **inte** är null eller undefined här" — den tar bort `null`/`undefined` från dess typ utan någon körtidskontroll.

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

Det är rent en kompileringstidskontroll — liksom `as`, utför den **ingen** körtidsverifiering. Om du har fel, kraschar det:

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

## När det är rimligt

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

## Föredra säkrare alternativ

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

Var och en av dessa *hanterar* det saknade fallet istället för att göra ett påstående om det.

## Varför det är viktigt

`!` är ett vassa verktyg: det tystnar ned den null-säkerhet kompilatorn försöker ge dig.

Det är ibland berättigat (du har kunskap kompilatorn saknar), men överanvändning av det återintroducerar exakt de null-krachfel som `strictNullChecks` förhindrar.

Gripa först till `?.`, `??`, eller en explicit kontroll; använd `!` endast när du verkligen kan bevisa non-nullness.