Co je operátor non-null assertion (!) a kdy je vhodný?

Question

Accepted Answer

Postfixovaný operátor `!` říká kompilátoru "Garantuji, že tato hodnota zde **není** null nebo undefined" — odebírá `null`/`undefined` z jejího typu bez jakéhokoli běhového ověření.

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

Jde čistě o tvrzení v době kompilace — podobně jako `as`, neprovádí **žádné** běhové ověření. Pokud se mýlíte, havaruje:

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

## Kdy je to rozumné

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

## Preferujte bezpečnější alternativy

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

Každá z nich se *zabývá* chybějícím případem místo toho, aby jej odmítla.

## Proč na tom záleží

`!` je ostrý nástroj: potlačuje null-bezpečnost, kterou se vám kompilátor pokouší dát.

Je příležitostně odůvodněný (máte znalosti, které kompilátoru chybí), ale nadměrné používání znovu zavádí právě ty null-crash chyby, které `strictNullChecks` zabraňuje.

Nejprve sáhněte po `?.`, `??`, nebo explicitní ochranné klauzuli; používejte `!` pouze v případě, že můžete skutečně dokázat non-nullness.