Mikä on non-null assertion -operaattori (!) ja milloin se on sopivaa?

Question

Accepted Answer

Jälkiliite `!` kertoo kääntäjälle "Takaan, että tämä arvo **ei ole** null tai undefined tässä" — poistaa `null`/`undefined` sen tyypistä ilman mitään runtime-tarkistusta.

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

Se on puhtaasti compile-time-väite — kuten `as`, se **ei** suorita runtime-verifiointia. Jos olet väärässä, se kaatuu:

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

## Milloin se on järkevää

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

## Suosi turvallisempia vaihtoehtoja

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

Jokaisella näistä *käsitellään* puuttuva tapaus sen sijaan, että se väitettäisiin pois.

## Miksi sillä on merkitystä

`!` on terävä väline: se vaientaa null-turvallisuuden, jonka kääntäjä yrittää antaa sinulle.

Se on joskus perusteltu (sinulla on tietoa, jota kääntäjältä puuttuu), mutta liikakäyttö tuottaa takaisin juuri ne null-crash-bugit, joita `strictNullChecks` estää.

Otaaksesi ensin `?.`, `??`, tai nimenomaisen suojan; käytä `!` vain, kun voit todella todistaa non-nullness.