Što su type assertions i kada su rizični?

Question

Accepted Answer

Tvrdnja tipa **type assertion** govori kompajleru "vjeruj mi, ova vrijednost je tipa X" koristeći `as`. To **ne vrši nikakvu runtime konverziju ili provjeru** — samo mijenja kako kompajler tretira vrijednost.

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

## Zašto je to rizično

Tvrdnja prepisuje sudbu kompajlera — ako griješiš, dobit ćeš runtime pad bez upozorenja:

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

Tvrdnja ne *čini* vrijednost tog tipa; samo šuti provjeru. Preuzeo si odgovornost za ispravnost od kompajlera.

## Sigurniji pristup

```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` je drugačije

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

## Zašto je to važno

Tvrdnje su ponekad potrebne (DOM API-ji, sužavanje `unknown` koje si već provjerio), ali svaka je mjesto gdje kompajler ne može te zaštititi.

Preferaj type guards ili schema validaciju za nepouzdane podatke, i svaki `as` tretira kao mali, namenski "bolje znam" za koji moraš biti siguran.

Zašto je to rizično

Sigurniji pristup

as const je drugačije

Zašto je to važno

`as const` je drugačije