Što je operator za potvrdu koja nije nula (!) i kada je prikladan?

Question

Accepted Answer

Postfiksna `!` govori kompajleru "Jamčim da ova vrijednost **nije** null ili undefined ovdje" — uklanja `null`/`undefined` iz njezine vrste bez bilo kakve provjere tijekom izvršavanja.

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

To je čista potvrda tijekom kompajliranja — kao `as`, **ne** obavlja nikakvu provjeru tijekom izvršavanja. Ako se prevariš, srušit će se:

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

## Kada je to razumno

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

## Preferiramo sigurnije alternative

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

Svaki od njih *rukuje* slučajem koji nedostaje umjesto da ga zanemaruje.

## Zašto je to važno

`!` je oštar alat: on gušit će zaštitu od nula-vrijednosti koju kompajler pokušava dati.

Okasionalno je opravdano (imate znanje koje kompajler nema), ali pretjerana upotreba ponovno uvodi točno one greške null-rušenja koje `strictNullChecks` sprječava.

Prvom se obratite `?.`, `??`, ili eksplicitnoj zaštiti; koristite `!` samo kada stvarno možete dokazati da nije null.