Co jsou Type Assertions a kdy jsou riziková?

Question

Accepted Answer

**Type assertion** řekne kompilátoru "věřte mi, tato hodnota je typu X" pomocí `as`. **Neprovádí žádný runtime konverzi ani ověřování** — pouze změní, jak kompilátor hodnotu chápe.

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

## Proč je to riskantní

Assertion obchází úsudek kompilátoru — pokud se mýlíte, dostanete runtime selhání bez varování:

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

Assertion hodnotu tím typem *neučiní*; pouze ztlumí kontrolu. Převzali jste odpovědnost za správnost od kompilátoru.

## Bezpečnější alternativy

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

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

## Proč to záleží

Assertiony jsou někdy nezbytné (DOM API, zúžení `unknown`, které jste již ověřili), ale každý z nich je místo, kde vás kompilátor nemůže chránit.

Dejte přednost type guards nebo schema validation pro nedůvěryhodná data a považujte každý `as` za malý, záměrný "já vím lépe", který si musíte být jistý.

Proč je to riskantní

Bezpečnější alternativy

as const je jiné

Proč to záleží

`as const` je jiné