Hvad er type assertions, og hvornår er de risikable?

Question

Accepted Answer

En **type assertion** fortæller compileren "stol på mig, denne værdi er af type X" ved hjælp af `as`. Den **foretager ingen runtime-konvertering eller -kontrol** — den ændrer blot, hvordan compileren behandler værdien.

```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 assertion tilsidesætter compilerens dømmekraft — hvis du tager fejl, får du et runtime-crash uden advarsel:

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

Assertionen *gør* ikke værdien til den type; det stiller blot checkeren til. Du har overtaget ansvaret for korrekthed fra compileren.

## Sikrere 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 anderledes

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

## Hvorfor det betyder noget

Assertions er undertiden nødvendige (DOM-API'er, indsnævring af `unknown`, som du allerede har kontrolleret), men hver enkelt er et sted, hvor compileren ikke kan beskytte dig.

Prioritér type guards eller schema-validering til upålidelige data, og behandl hver `as` som en lille, bevidst "jeg ved bedre", som du skal være sikker på.

Hvorfor det er risikabelt

Sikrere alternativer

as const er anderledes

Hvorfor det betyder noget

`as const` er anderledes