O que os operadores keyof e typeof fazem em contextos de tipo?

Question

Accepted Answer

Esses dois operadores permitem que você derive tipos de tipos e valores existentes — a fundação da programação em nível de tipo.

## keyof — a união das chaves de um tipo de objeto

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

## typeof — o tipo de um valor

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

`typeof` (em uma posição de tipo) captura o tipo inferido de um valor em tempo de execução, para que você não tenha que escrever o tipo separadamente.

## Combinado: o getter de propriedade seguro do tipo clássico

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

Aqui `K extends keyof T` restringe `key` para chaves reais, e `T[K]` (um tipo de *acesso indexado*) retorna o tipo exato do valor para essa chave. Erros de digitação se tornam erros de compilação.

## Derivando uma união de um objeto const

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

## Por que isso importa

`keyof` e `typeof` conectam o mundo do valor e o mundo do tipo.

Eles potencializam o acesso a propriedades seguro de tipos, derivam tipos de configurações/constantes (fonte única de verdade) e são blocos de construção para tipos mapeados e condicionais.

É assim que você evita manter manualmente definições de tipo paralelas.