Ką daro keyof ir typeof operatoriai tipo kontekste?

Question

Accepted Answer

Šie du operatoriai leidžia išvesti tipus iš esamų tipų ir reikšmių — tipo lygio programavimo pagrindas.

## keyof — objekto tipo raktų sąjunga

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

## typeof — reikšmės tipo

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

`typeof` (tipo pozicijoje) nusifiksina nuo runtime reikšmės nustatytą tipą, todėl jūs negalėtumėte parašyti tipo atskirai.

## Sujungti: klasikinis tipo saugus savybės 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
```

Čia `K extends keyof T` riboja `key` tik tikraisiais raktais, o `T[K]` (*indeksuoto prieigos tipo*) grąžina tikslų reikšmės tipą tam raktui. Typos tampa kompiliavimo klaidomis.

## Sąjungos išvedimas iš const objekto

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

## Kodėl tai svarbu

`keyof` ir `typeof` sujungia reikšmės pasaulį ir tipo pasaulį.

Jie suteikia tipo saugų savybės prieigą, tipų išvedimą iš konfigūracijos/konstučių (vienas tiesos šaltinis), ir yra susieti bei sąlyginių tipų konstrukciniai blokai.

Tai kaip išvengti rankiniu būdu tvarkomos lygiagrečios tipo apibrėžties.