Ce sunt afirmațiile de tip și când sunt ele riscante?

Question

Accepted Answer

O **afirmație de tip** spune compilatorului "ai încredere în mine, această valoare este de tip X" folosind `as`. Ea **nu efectuează nicio conversie sau verificare la runtime** — doar schimbă modul în care compilatorul tratează valoarea.

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

## De ce este riscant

O afirmație anulează judecata compilatorului — dacă te înșeli, obții o cădere la runtime fără avertisment:

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

Afirmația nu *transformă* valoarea în acel tip; doar tace verificatorul. Ai transferat responsabilitatea pentru corectitudine departe de compilator.

## Alternativele mai sigure

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

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

## De ce conteaza

Afirmațiile sunt uneori necesare (API-uri DOM, restrângerea `unknown` pe care l-ai deja verificat), dar fiecare una este un loc în care compilatorul nu te poate proteja.

Prefură gărzi de tip sau validare schemă pentru date neîncredute, și tratează fiecare `as` ca un mic, deliberat "Eu știu mai bine" despre care trebuie să fii sigur.

De ce este riscant

Alternativele mai sigure

as const este diferit

De ce conteaza

`as const` este diferit