Kas yra tipo tvirtinimai ir kada jie yra rizikinga?

Question

Accepted Answer

**Tipo tvirtinimas** sako kompiliatoriui "pasitikėk manimi, ši reikšmė yra X tipo" naudojant `as`. Jis **neatlieka jokios vykdymo laiku konversijos ar tikrinimo** — jis tik keičia, kaip kompiliatorius traktuoja reikšmę.

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

## Kodėl tai rizikinga

Tvirtinimas panaikina kompiliatoriaus sprendimą — jei klydi, gausi vykdymo laiku klaidą be jokio perspėjimo:

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

Tvirtinimas nekeičia reikšmės į tą tipo — jis tik nutildo tikrintuvą. Tu perimei atsakomybę dėl teisingumo iš kompiliatoriaus.

## Saugesni alternatyvos

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

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

## Kodėl tai svarbu

Tvirtinimai kartais būtini (DOM API, `unknown` susiaurimas, kurį jau patikrinai), bet kiekvienas yra vieta, kurioje kompiliatorius negali tave apsaugoti.

Primer tipo saugos mechanizmus arba schemos validaciją nepasitikimams duomenims, ir traktuok kiekvieną `as` kaip mažą, sąmoningą "aš žinau geriau" sprendimą, kuriame turi būti tikras.

Kodėl tai rizikinga

Saugesni alternatyvos

as const yra kitoks

Kodėl tai svarbu

`as const` yra kitoks