Hva er typeassersjoner og når er de risikable?

Question

Accepted Answer

En **typeassersjøn** forteller kompilatoren "stol på meg, denne verdien er av type X" ved hjelp av `as`. Den gjør **ingen runtime-konvertering eller kontroll** — den endrer bare hvordan kompilatoren behandler verdien.

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

## Hvorfor det er risikabelt

En assersjøn overstyrer kompilatorens vurdering — hvis du tar feil, får du en runtime-krasj uten varsel:

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

Assersjøn gjør ikke verdien til den typen; det stiller bare sjekeren. Du har tatt ansvaret for korrekthet vekk fra kompilatoren.

## Tryggere alternativer

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

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

## Hvorfor det har betydning

Assersjoner er noen ganger nødvendig (DOM-APIer, innsnevrering av `unknown` som du allerede har sjekket), men hver enkel er et sted hvor kompilatoren ikke kan beskytte deg.

Foretrekk typeguarder eller skjemavalidering for data du ikke stoler på, og behandle hver `as` som en liten, bevisst "Jeg vet bedre" som du må være sikker på.

Hvorfor det er risikabelt

Tryggere alternativer

as const er annerledes

Hvorfor det har betydning

`as const` er annerledes