Operesheni za keyof na typeof zinafanya nini katika muktadha wa aina (type contexts)?

Question

Accepted Answer

Operesheni hizi mbili zinakuruhusu kupata aina kutoka kwa aina na thamani zilizopo — msingi wa programu ya kiwango cha aina (type-level programming).

## keyof — muungano (union) wa funguo za aina ya object

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

## typeof — aina ya thamani

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

`typeof` (katika nafasi ya aina) hunasa aina iliyokisiwa ya thamani ya wakati wa utekelezaji (runtime value), hivyo hulazimiki kuandika aina kwa kujitegemea.

## Kuunganisha: kipataji cha sifa (property getter) salama kwa aina cha kawaida

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

Hapa `K extends keyof T` huzuia `key` kuwa funguo halisi tu, na `T[K]` (aina ya *indexed access type*) hurejesha aina kamili ya thamani kwa ufunguo huo. Makosa ya kuandika (typos) huwa makosa ya wakati wa kukusanya (compile errors).

## Kupata muungano kutoka kwa object ya const

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

## Kwa nini ni muhimu

`keyof` na `typeof` huunganisha ulimwengu wa thamani na ulimwengu wa aina.

Zinawezesha ufikiaji wa sifa salama kwa aina, kupata aina kutoka kwa config/constants (chanzo kimoja cha ukweli), na ni vipengele vya msingi vya aina za mapped na conditional.

Ni jinsi unavyoepuka kudumisha kwa mkono ufafanuzi wa aina sambamba.