Mi a non-null assertion operátor (!) és mikor megfelelő?

Question

Accepted Answer

Az utótag `!` azt mondja a fordítónak "Garantálom, hogy ez az érték **nem** null vagy undefined itt" — eltávolítja a `null`/`undefined` elemeket a típusából anélkül, hogy futásidejű ellenőrzést végezne.

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

Purán egy fordítási idejű asszerzió — mint az `as`, **nem** végez futásidejű ellenőrzést. Ha tévedtél, összeomlott:

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

## Amikor ez ésszerű

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

## Preferáljuk a biztonságosabb alternatívákat

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

Mindegyik *kezeli* a hiányzó esetet ahelyett, hogy elfogadná.

## Miért van ez fontos

A `!` egy éles eszköz: elnémítja az null-biztonságot, amelyet a fordító meg próbál adni.

Okasionálisan indokolt (van olyan tudása, amely a fordítónak nincs), de a túlzott használata újra bemutatja a pontosan null-összeomlás hibákat, amelyeket a `strictNullChecks` megelőz.

Előbb forduljon a `?.`, `??`, vagy egy kifejezett őrhöz; csak akkor használja a `!` értéket, ha valóban be tudja bizonyítani a nem-nullságot.