Was bewirken die Operatoren keyof und typeof in Typkontexten?

Question

Accepted Answer

Diese beiden Operatoren ermöglichen es dir, Typen aus vorhandenen Typen und Werten abzuleiten — die Grundlage der Typ-Ebenen-Programmierung.

## keyof — die Vereinigung der Schlüssel eines Objekttyps

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

## typeof — der Typ eines Wertes

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

`typeof` (in einer Typposition) erfasst den hergeleiteten Typ eines Laufzeitwerts, sodass du den Typ nicht separat aufschreiben musst.

## Kombiniert: der klassische typsichere 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 beschränkt `K extends keyof T` den `key` auf echte Schlüssel, und `T[K]` (ein *Indexed Access Type*) gibt den genauen Werttyp für diesen Schlüssel zurück. Tippfehler werden zu Kompilierungsfehlern.

## Ableitung einer Vereinigung aus einem const-Objekt

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

## Warum es wichtig ist

`keyof` und `typeof` verbinden die Wertwelt und die Typwelt.

Sie ermöglichen typsichere Property-Zugriffe, leiten Typen aus Config/Konstanten ab (Single Source of Truth) und sind Bausteine für Mapped und Conditional Types.

Sie sind der Weg, um zu vermeiden, parallele Typdefinitionen manuell zu pflegen.