Que font les opérateurs keyof et typeof dans les contextes de type ?

Question

Accepted Answer

Ces deux opérateurs vous permettent de dériver des types à partir de types et de valeurs existants — la fondation de la programmation au niveau des types.

## keyof — l'union des clés d'un type objet

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

## typeof — le type d'une valeur

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

`typeof` (dans une position de type) capture le type inféré d'une valeur à l'exécution, de sorte que vous n'ayez pas à écrire le type séparément.

## Combiné : le getter de propriété classique et type-safe

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

Ici `K extends keyof T` restreint `key` aux clés réelles, et `T[K]` (un *indexed access type*) retourne le type de valeur exact pour cette clé. Les fautes de frappe deviennent des erreurs à la compilation.

## Dériver une union à partir d'un objet const

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

## Pourquoi c'est important

`keyof` et `typeof` connectent le monde des valeurs et le monde des types.

Ils permettent un accès aux propriétés type-safe, de dériver des types à partir de config/constantes (source unique de vérité), et sont des blocs de construction pour les types mappés et les types conditionnels.

C'est comment vous évitez de maintenir manuellement des définitions de types parallèles.