Kaj počneta operatorja keyof in typeof v kontekstih tipov?

Question

Accepted Answer

Ta dva operatorja vam omogočata, da izpeljete tipe iz obstoječih tipov in vrednosti — temelj programiranja na ravni tipov.

## keyof — unija ključev tipa objekta

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

## typeof — tip vrednosti

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

`typeof` (v položaju tipa) zajame sklepani tip vrednosti med izvajanjem, tako da vam ni treba ločeno pisati tipa.

## Kombinirano: klasični getter varnega tipa lastnosti

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

Tukaj `K extends keyof T` omejuje `key` na prave ključe, `T[K]` (tip *indeksiranega dostopa*) pa vrne natančen tip vrednosti za ta ključ. Napake pri tipkanju postanejo napake pri prevajanju.

## Izpeljava unije iz const objekta

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

## Zakaj je to pomembno

`keyof` in `typeof` povežeta svet vrednosti in svet tipov.

Omogoči varni dostop do lastnosti, izpeljavo tipov iz konfigur./konstant (enak vir resnice) in so gradniki za preslikane in pogojne tipe.

To je način, kako se izognete ročnemu vzdrževanju vzporednih definicij tipov.