type சூழல்களில் keyof மற்றும் typeof operator-கள் என்ன செய்கின்றன?

Question

Accepted Answer

இந்த இரண்டு operator-களும் ஏற்கனவே உள்ள type-கள் மற்றும் value-களில் இருந்து type-களைப் பெற உதவுகின்றன — இது type-நிலை நிரலாக்கத்தின் (type-level programming) அடித்தளம்.

## keyof — ஒரு object type-இன் key-களின் union

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

## typeof — ஒரு value-இன் type

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

`typeof` (type position-இல்) ஒரு runtime value-இன் infer செய்யப்பட்ட type-ஐ capture செய்கிறது, எனவே நீங்கள் type-ஐ தனியாக எழுத வேண்டியதில்லை.

## இணைந்தது: செம்மையான type-safe property getter

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

இங்கே `K extends keyof T` என்பது `key`-ஐ உண்மையான key-களுக்கு மட்டுமே வரம்பிடுகிறது, மேலும் `T[K]` (ஒரு *indexed access type*) அந்த key-க்கான சரியான value type-ஐ திரும்பத் தருகிறது. எழுத்துப் பிழைகள் (typos) compile error-களாக மாறுகின்றன.

## const object-இல் இருந்து ஒரு union-ஐப் பெறுதல்

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

## இது ஏன் முக்கியம்

`keyof` மற்றும் `typeof` ஆகியவை value உலகத்தையும் type உலகத்தையும் இணைக்கின்றன.

இவை type-safe property access-ஐ இயக்குகின்றன, config/constant-களில் இருந்து type-களைப் பெறுகின்றன (single source of truth), மேலும் mapped மற்றும் conditional type-களுக்கான கட்டுமான தொகுதிகளாகவும் (building blocks) உள்ளன.

இணையான type வரையறைகளை கையால் பராமரிப்பதை நீங்கள் இவ்வாறு தவிர்க்கிறீர்கள்.