Vad gör operatorerna keyof och typeof i typsammanhang?

Question

Accepted Answer

Dessa två operatorer låter dig härleda typer från befintliga typer och värden — grunden för typnivåprogrammering.

## keyof — unionen av ett objekttypens nycklar

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

## typeof — typen av ett värde

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

`typeof` (i en typposition) fångar den härledda typen för ett körningsvärde, så du behöver inte skriva ut typen separat.

## Kombinerat: klassisk typsäker egenskapshämtare

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

Här begränsar `K extends keyof T` `key` till verkliga nycklar, och `T[K]` (en *indexed access type*) ger tillbaka den exakta värdetypen för den nyckeln. Stavfel blir kompileringsfel.

## Härleda en union från ett const-objekt

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

## Varför det spelar roll

`keyof` och `typeof` förbinder värdevärld och typvärld.

De möjliggör typsäker egenskapsåtkomst, härledning av typer från konfiguration/konstanter (enkel källa till sanning), och är byggstenar för mappade och villkorliga typer.

Det är hur du undviker att manuellt underhålla parallella typdefinitioner.