Hva gjør operatorene keyof og typeof i typekontekster?

Question

Accepted Answer

Disse to operatorene lar deg utlede typer fra eksisterende typer og verdier — grunnlaget for typeprogrammering.

## keyof — unionen av en objekttypes nøkler

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

## typeof — typen til en verdi

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

`typeof` (i en typeposi) fanger opp den utledede typen til en kjøretidsverdi, slik at du ikke trenger å skrive typen separat.

## Kombinert: den klassiske typesikre 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
```

Her begrenser `K extends keyof T` `key` til reelle nøkler, og `T[K]` (en *indexed access type*) gir tilbake den eksakte verdiutypen for den nøkkelen. Stavefeil blir kompileringsfeil.

## Utlede en union fra et const-objekt

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

## Hvorfor det er viktig

`keyof` og `typeof` forbinder verdiverdenen og typeverdenen.

De muliggjør typesikker egenskapsatkomst, utledelse av typer fra konfig/konstanter (enkelt kildeprinsipp), og er byggeklodser for mappet og betingede typer.

De er hvordan du unngår å vedlikeholde parallelle typedefinisjo manuelt.