¿Qué son las type assertions y cuándo son riesgosas?

Question

Accepted Answer

Una **type assertion** le dice al compilador "confía en mí, este valor es del tipo X" usando `as`. No hace **ninguna conversión ni comprobación en tiempo de ejecución**: solo cambia cómo el compilador trata el valor.

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

## Por qué es riesgoso

Una assertion anula el criterio del compilador: si te equivocas, obtienes un fallo en tiempo de ejecución sin ninguna advertencia:

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

Hacer una assertion no *convierte* el valor en ese tipo; solo silencia al chequeador. Le has quitado al compilador la responsabilidad sobre la corrección.

## Alternativas más seguras

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

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

## Por qué es importante

Las assertions a veces son necesarias (APIs del DOM, hacer narrowing de un `unknown` que ya comprobaste), pero cada una es un lugar donde el compilador no puede protegerte.

Prefiere type guards o validación con esquemas para datos no confiables, y trata cada `as` como un pequeño y deliberado "yo sé mejor" del que debes estar seguro.

Por qué es riesgoso

Alternativas más seguras

as const es diferente

Por qué es importante

`as const` es diferente