¿Qué hace la aserción `as const`?

Question

Accepted Answer

`as const` es una **aserción const** que le indica a TypeScript que infiera el tipo **más específico (literal) y profundamente readonly** para un valor, en lugar de ampliarlo (widening).

```ts
// without as const — widened, mutable
let a = "up";            // type: string
const obj = { x: 1 };     // type: { x: number }
const arr = [1, 2];       // type: number[]

// with as const — narrow literals, readonly
const b = "up" as const;          // type: "up"
const obj2 = { x: 1 } as const;    // type: { readonly x: 1 }
const arr2 = [1, 2] as const;      // type: readonly [1, 2] (a tuple!)
```

Hace tres cosas: no amplía *nada* (mantiene los valores literales), convierte todo en `readonly` y transforma los arrays en **tuplas**.

## Por qué es tan útil

**Derivar un tipo de unión a partir de una lista de valores (fuente única de verdad):**

```ts
const ROLES = ["admin", "editor", "viewer"] as const;
type Role = typeof ROLES[number]; // "admin" | "editor" | "viewer"
// add a role to the array → the union updates automatically
```

**Preservar los tipos literales para configuración/estado:**

```ts
const action = { type: "INCREMENT", by: 1 } as const;
// action.type is "INCREMENT" (a literal), so it works in discriminated unions
// without as const it'd be `string`, breaking narrowing
```

## Por qué es importante

`as const` tiende un puente entre los valores en tiempo de ejecución y los tipos precisos.

Te permite definir los datos una sola vez (un array/objeto) y derivar tipos literales exactos a partir de ellos: invaluable para tipos de acciones, mapas de rutas, configuración y cualquier etiqueta de unión discriminada que deba seguir siendo un literal en vez de ampliarse a `string`.