Ce fac operatorii keyof și typeof în contextele de tip?

Question

Accepted Answer

Acești doi operatori vă permit să derivați tipuri din tipuri și valori existente — baza programării la nivel de tip.

## keyof — uniunea cheilor unui tip de obiect

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

## typeof — tipul unei valori

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

`typeof` (într-o poziție de tip) capturează tipul dedus al unei valori la runtime, astfel încât nu trebuie să scrieți tipul separat.

## Combinat: getter-ul de proprietate sigur din punct de vedere al tipului clasic

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

Aici `K extends keyof T` restricționează `key` la cheile reale, iar `T[K]` (un tip de *acces indexat*) returnează tipul exact al valorii pentru acea cheie. Greșelile de scriere devin erori de compilare.

## Derivarea unei uniuni dintr-un obiect const

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

## De ce este important

`keyof` și `typeof` conectează lumea valorilor și lumea tipurilor.

Ele oferă acces sigur la proprietăți din punct de vedere al tipului, derivă tipuri din configurații/constante (o singură sursă de adevăr) și sunt blocuri de construcție pentru tipuri mapate și condiționale.

Acesta este modul în care evitați să mențineți manual definițiile de tip paralele.