Mit csinálnak a keyof és typeof operátorok a típuskörnyezetben?

Question

Accepted Answer

Ez a két operátor lehetővé teszi, hogy típusokat vezess le a meglévő típusokból és értékekből — ez a típus szintű programozás alapja.

## keyof — objektum típus kulcsainak uniója

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

## typeof — érték típusa

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

A `typeof` (típus pozícióban) egy futásidejű érték megállapított típusát rögzíti, így nem kell külön kiírni a típust.

## Kombinálva: a klasszikus típus-biztos 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
```

Itt a `K extends keyof T` korlátozza a `key` valós kulcsokra, és a `T[K]` (egy *indexed access type*) visszaadja az adott kulcs pontos értéktípusát. Az elírások fordítási hibák lesznek.

## Unió levezetése const objektumból

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

## Miért fontos ez

A `keyof` és `typeof` összeköti az érték világot és a típus világot.

Ezek lehetővé teszik a típus-biztos tulajdonság-hozzáférést, típusok levezetését a config/konstanokból (egyetlen információforrás), és a leképezett és feltételes típusok építőelemei.

Ez az a módszer, amellyel elkerülheted a párhuzamos típusdefiníciók kézi karbantartását.