Apa itu operator non-null assertion (!) lan kapan iku layak digunakaken?

Question

Accepted Answer

Postfix `!` ngomong marang compiler "Aku jamin nilai iki **ora** null utawa undefined ing kene" — ngilangi `null`/`undefined` saka tipenya tanpa mriksa runtime apa-apa.

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

Iku murni assertion compile-time — kaya `as`, ora nglakoni **ora** verifikasi runtime. Yen sampeyan salah, bakal ambruk:

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

## Kapan iku masuk akal

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

## Luwih seneng alternatif sing luwih aman

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

Saben-saben iki *nangani* kasus sing ilang tinimbang negesikake.

## Mengapa iku penting

`!` iku alat sing landhep: nggawe senyep null-safety sing dadi coba diwekani compiler.

Kadang-kadang layak (sampeyan duwe kawruh sing ora duwe compiler), nanging overusing nggawe metu maneh null-crash bugs sing `strictNullChecks` nyegah.

Ngutamakake `?.`, `??`, utawa guard sing jelas luwih dulu; gunakaake `!` mung yen sampeyan bener-bener bisa buktekake non-nullness.