Mitä keyof- ja typeof-operaattorit tekevät tyyppi-yhteyksissä?

Question

Accepted Answer

Nämä kaksi operaattoria antavat sinulle mahdollisuuden johtaa tyyppejä olemassa olevista tyypeistä ja arvoista — tämä on tyyppitason ohjelmoinnin perusta.

## keyof — objektityypin avainten unioni

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

## typeof — arvon tyyppi

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

`typeof` (tyyppi-asemassa) kaappaa ajonaikaisesti päätellyt tyypin arvolle, joten sinun ei tarvitse kirjoittaa tyyppiä erikseen.

## Yhdistetty: klassinen tyyppiturvainen 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
```

Tässä `K extends keyof T` rajoittaa `key`:n todellisiin avaimiin, ja `T[K]` (indeksisaantityyppi) palauttaa täsmälleen sen avaimen arvotyypin. Kirjoitusvirheet muuttuvat käännösvirheiksi.

## Unionin johtaminen const-objektista

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

## Miksi se on tärkeää

`keyof` ja `typeof` yhdistävät arvon ja tyypin maailmat.

Ne mahdollistavat tyyppiturvalliset property-kaannaokset, tyyppien johtamisen konfiguraatioista/vakioista (yksi totuuden lähde), ja ovat rakennuspalikoita mapped- ja conditional-tyypeille.

Ne ovat keino välttää rinnakkaisten tyyppimäärittelyjen manuaalista ylläpitoa.