Kas yra non-null assertion operatorius (!) ir kada jis yra tinkamas?

Question

Accepted Answer

Postfiksinis `!` kompiliatoriui sako "Garantuoju, kad šis reikšmė **nėra** null arba undefined čia" — pašalina `null`/`undefined` iš jos tipo be jokios runtime patikros.

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

Tai grynai compile-time tvirtinimas — kaip `as`, jis **neatliko** jokios runtime verifikacijos. Jei klydote, jis sutrūksta:

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

## Kada tai pagrįsta

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

## Pageidauti saugesnes alternatyvas

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

Kiekviena iš jų *tvarko* trūkstamą atvejį, o ne jį paneigia.

## Kodėl tai svarbu

`!` yra aštrus įrankis: jis numalšina null-safety, kurią kompilyatorius bando jums suteikti.

Ji retais atvejais yra pagrįsta (turite žinių, kuriomis neturi kompilyatorius), tačiau perdažnas naudojimas iš naujo įveda null-crash klaidas, kurias `strictNullChecks` neigia.

Pirmiausia siekite `?.`, `??` arba aiškios saugos; naudokite `!` tik tada, kai tikrai galite įrodyti non-nullness.