¿Qué hacen los operadores keyof y typeof en contextos de tipos?

Question

Accepted Answer

Estos dos operadores te permiten derivar tipos a partir de tipos y valores existentes — la base de la programación a nivel de tipos.

## keyof — la unión de las claves de un tipo de objeto

```ts
interface User { id: number; name: string; }
type UserKey = keyof User; // "id" | "name"
```

## typeof — el tipo de un valor

```ts
const config = { host: "localhost", port: 3000 };
type Config = typeof config; // { host: string; port: number }
```

`typeof` (en una posición de tipo) captura el tipo inferido de un valor en tiempo de ejecución, así no tienes que escribir el tipo por separado.

## Combinados: el clásico getter de propiedades con seguridad de tipos

```ts
function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const user = { id: 1, name: "Ann" };
getProp(user, "name"); // returns string
getProp(user, "age");  // ❌ Error: "age" is not a key of user
```

Aquí `K extends keyof T` restringe `key` a claves reales, y `T[K]` (un *tipo de acceso indexado*) devuelve el tipo de valor exacto para esa clave. Los errores de tipeo se convierten en errores de compilación.

## Derivar una unión a partir de un objeto const

```ts
const Roles = { Admin: "admin", User: "user" } as const;
type Role = typeof Roles[keyof typeof Roles]; // "admin" | "user"
```

## Por qué es importante

`keyof` y `typeof` conectan el mundo de los valores con el mundo de los tipos.

Impulsan el acceso a propiedades con seguridad de tipos, la derivación de tipos a partir de configuraciones/constantes (una única fuente de verdad), y son bloques de construcción para los tipos mapeados y condicionales.

Son la forma de evitar mantener a mano definiciones de tipos paralelas.