Che cosa sono le type assertions e quando sono rischiose?

Question

Accepted Answer

Una **type assertion** dice al compilatore "fidati di me, questo valore è di tipo X" usando `as`. Non esegue **alcuna conversione o controllo runtime** — cambia solo come il compilatore tratta il valore.

```ts
const el = document.getElementById("app") as HTMLInputElement;
el.value = "hi"; // compiler now allows .value (it assumed HTMLInputElement)

const data = JSON.parse(str) as User; // assert the parsed shape
```

## Perché è importante

Una asserzione sostituisce il giudizio del compilatore — se hai torto, ottieni un crash a runtime senza avviso:

```ts
const x = "hello" as unknown as number; // double assertion — compiler stops complaining
x.toFixed(2); // 💥 runtime error: x.toFixed is not a function
```

L'asserzione non *rende* il valore quel tipo; silenzia solo il checker. Hai tolto al compilatore la responsabilità della correttezza.

## Alternative più sicure

```ts
// 1. type guard — actually verify at runtime
if (typeof input === "string") { /* input is string, proven */ }

// 2. validation library (zod) for external data
const user = UserSchema.parse(data); // throws if shape is wrong
```

## `as const` è diverso

```ts
const point = { x: 1 } as const; // not a risky cast — narrows to literal/readonly
```

## Perché è importante

Le asserzioni a volte sono necessarie (API DOM, restringere `unknown` che hai già controllato), ma ognuna è un punto in cui il compilatore non può proteggerti.

Preferisci type guards o schema validation per dati non attendibili, e tratta ogni `as` come un piccolo, intenzionale "so meglio io" di cui devi essere sicuro.

Perché è importante

Alternative più sicure

as const è diverso

Perché è importante

`as const` è diverso