Wat doen de keyof- en typeof-operators in typcontexten?

Question

Accepted Answer

Deze twee operators stellen je in staat types af te leiden van bestaande types en waarden — de basis van type-level programmeren.

## keyof — de unie van sleutels van een objecttype

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

## typeof — het type van een waarde

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

`typeof` (in een typepositie) legt het afgeleide type van een runtimewaarde vast, zodat je het type niet afzonderlijk hoeft op te schrijven.

## Gecombineerd: de klassieke typeveilige property getter

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

Hier beperkt `K extends keyof T` `key` tot echte sleutels, en `T[K]` (een *indexed access type*) geeft het exacte waardetype voor die sleutel terug. Typfouten worden compilatiefouten.

## Een unie afleiden van een const-object

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

## Waarom het belangrijk is

`keyof` en `typeof` verbinden de wereld van waarden en de wereld van types.

Ze maken type veilige property access mogelijk, types afleiden uit config/constanten (één bron van waarheid), en zijn bouwstenen voor mapped en conditional types.

Ze voorkomen dat je parallel typedefinities met de hand moet onderhouden.