Cosa fanno gli operatori keyof e typeof nei contesti di tipo?

Question

Accepted Answer

Questi due operatori ti permettono di derivare tipi da tipi e valori esistenti — il fondamento della programmazione a livello di tipo.

## keyof — l'unione delle chiavi di un tipo di oggetto

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

## typeof — il tipo di un valore

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

`typeof` (in una posizione di tipo) cattura il tipo inferito di un valore a runtime, quindi non devi scrivere il tipo separatamente.

## Combinato: il classico property getter type-safe

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

Qui `K extends keyof T` limita `key` alle chiavi reali, e `T[K]` (un tipo di *indexed access*) restituisce il tipo di valore esatto per quella chiave. I refusi diventano errori di compilazione.

## Derivare un'unione da un oggetto const

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

## Perché è importante

`keyof` e `typeof` collegano il mondo dei valori e il mondo dei tipi.

Abilitano l'accesso alle proprietà type-safe, derivando tipi da configurazioni/costanti (unica fonte di verità), e sono blocchi costruttivi per tipi mappati e tipi condizionali.

Sono il modo in cui eviti di mantenere manualmente definizioni di tipo parallele.