Co robią operatory keyof i typeof w kontekstach typów?

Question

Accepted Answer

Te dwa operatory pozwalają pochodzonić typy z istniejących typów i wartości — fundament programowania na poziomie typów.

## Dlaczego to ważne

keyof` i `typeof` łączą świat wartości i świat typów.

Umożliwiają bezpieczny dostęp do właściwości, pochodzone typy z konfiguracji/stałych (jedno źródło prawdy) i stanowią budulce dla typów mapowanych i warunkowych.

To sposób, aby uniknąć ręcznego utrzymywania równoległych definicji typów.

## keyof — unia kluczy typu obiektu

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

## typeof — typ wartości

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

`typeof` (w pozycji typu) przechwytuje wnioskowany typ wartości w czasie wykonania, dzięki czemu nie musisz wpisywać typ oddzielnie.

## Połączone: klasyczny bezpieczny getter właściwości

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

Tutaj `K extends keyof T` ogranicza `key` do rzeczywistych kluczy, a `T[K]` (typ *indeksowanego dostępu*) zwraca dokładny typ wartości dla tego klucza. Literówki stają się błędami kompilacji.

## Pochodny związek z obiektu const

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