Che cos'è l'operatore di asserzione non-null (!) e quando è appropriato?

Question

IT Interview Practice · Accepted Answer

Il postfisso `!` dice al compilatore "Garantisco che questo valore **non** è null o undefined qui" — rimuove `null`/`undefined` dal suo tipo senza alcun controllo runtime.

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

È puramente un'asserzione in fase di compilazione — come `as`, **non** esegue alcuna verifica runtime. Se sbagli, si blocca:

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

## Quando è ragionevole

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

## Preferisci alternative più sicure

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

Ognuno di questi *gestisce* il caso mancante invece di affermare.

## Perché è importante

`!` è uno strumento affilato: mette a tacere la sicurezza null che il compilatore sta cercando di darti.

È occasionalmente giustificato (hai conoscenze che il compilatore non ha), ma l'abuso lo reintroduce esattamente i bug di arresto null che `strictNullChecks` previene.

Ricorri prima a `?.`, `??`, o a una protezione esplicita; usa `!` solo quando puoi davvero provare la non-nullness.

Quando è ragionevole

Preferisci alternative più sicure

Perché è importante

Domande correlate