Co dělají operátory keyof a typeof v kontextech typů?

Question

Accepted Answer

Tyto dva operátory vám umožňují odvozovat typy z existujících typů a hodnot — základu programování na úrovni typů.

## keyof — sjednocení klíčů objektového typu

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

## typeof — typ hodnoty

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

`typeof` (v pozici typu) zachytí odvozený typ běhové hodnoty, takže nemusíte typ psát zvlášť.

## Kombinace: klasický getter vlastností bezpečný pro typy

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

Zde `K extends keyof T` omezuje `key` na skutečné klíče a `T[K]` (typ s indexovaným přístupem) vrací přesný typ hodnoty pro daný klíč. Překlepy se stanou chybami kompilace.

## Odvození sjednocení z objektu const

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

## Proč na tom záleží

`keyof` a `typeof` propojují svět hodnot a svět typů.

Zapříčiňují bezpečný přístup k vlastnostem, odvozování typů z konfigurace/konstant (jediný zdroj pravdy) a jsou stavebními bloky pro mapované a podmíněné typy.

Jsou to způsoby, jak se vyhnout ručnímu udržování paralelních definic typů.