Kaj je operator za asertcijo brez null vrednosti (!) in kdaj je primeren?

Question

Accepted Answer

Postfiksni `!` pove prevajalniku »Garantiram, da ta vrednost **ni** null ali undefined tukaj« — odstrani `null`/`undefined` iz njenega tipa brez kakršnega koli preverjanja med izvajanjem.

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

Gre zgolj za asertcijo ob prevajanju — kot `as`, **ne** opravi nobenega preverjanja med izvajanjem. Če se motite, se program zruši:

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

## Kdaj je 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
```

## Dajte prednost varnejšim alternativam

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

Vsak od teh *obravnava* primanjkljaj namesto da bi ga asertiral.

## Zakaj je to važno

`!` je ostra orodje: utišuje null-varnost, ki vam jo je prevajalnik poskušal dati.

Zgodaj se lahko upravičeno uporabi (imate znanje, ki ga prevajalnik nima), vendar je prečesta uporaba ponovno uvedla točno tiste null-napake, ki jih `strictNullChecks` preprečuje.

Prej posegajte po `?.`, `??` ali eksplicitni zaščiti; `!` uporabite le, kadar lahko resnično dokažete, da vrednost ni null.