Vad är typkastningar och när är de riskfyllda?

Question

Accepted Answer

En **typkastning** säger till compilatorn "lita på mig, detta värde är av typ X" med `as`. Den gör **ingen omvandling eller kontroll vid körning** — den ändrar bara hur compilatorn behandlar värdet.

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

## Varför det är riskfyllt

En assertion åsidosätter compileratorns bedömning — om du har fel får du en körningsfelkrasch utan varning:

```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 gör inte att värdet *blir* den typen; det tystnar bara checknern. Du har tagit ansvaret för korrekthet bort från compilatorn.

## Säkrare alternativ

```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` är annorlunda

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

## Varför det är viktigt

Assertions är ibland nödvändiga (DOM-API:er, begränsning av `unknown` som du redan har kontrollerat), men var och en är en plats där compilatorn inte kan skydda dig.

Föredra typvakter eller schemavalidering för opålitlig data, och behandla varje `as` som ett litet, avsiktligt "Jag vet bättre" som du måste vara säker på.

Varför det är riskfyllt

Säkrare alternativ

as const är annorlunda

Varför det är viktigt

`as const` är annorlunda