Wat zijn type assertions en wanneer zijn ze riskant?

Question

Accepted Answer

Een **type assertion** vertelt de compiler "vertrouw me, deze waarde is van het type X" met behulp van `as`. Het voert **geen runtime-conversie of controle** uit — het verandert alleen hoe de compiler de waarde behandelt.

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

## Waarom het belangrijk is

Een assertion overschrijft het oordeel van de compiler — als je het mis hebt, krijg je een runtime-crash zonder waarschuwing:

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

Een assertion maakt de waarde niet van dat type; het stilzwijgen alleen de checker. Je hebt de verantwoordelijkheid voor correctheid uit handen van de compiler genomen.

## Veiliger alternatieven

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

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

## Waarom het belangrijk is

Assertions zijn soms nodig (DOM API's, narrowing van `unknown` dat je al hebt gecontroleerd), maar elk ervan is een plaats waar de compiler je niet kan beschermen.

Geef de voorkeur aan type guards of schema-validatie voor onbetrouwbare data, en behandel elk `as` als een klein, doelbewust "Ik weet het beter" waarvan je zeker moet zijn.

Waarom het belangrijk is

Veiliger alternatieven

as const is anders

Waarom het belangrijk is

`as const` is anders