რა აკეთებს keyof და typeof ოპერატორები ტიპის კონტექსტში?

Question

Accepted Answer

ეს ორი ოპერატორი საშუალებას გაძლევთ წაკითხოთ ტიპები არსებული ტიპებიდან და მნიშვნელობებიდან — ტიპ-დონის პროგრამირების საფუძველი.

## keyof — ობიექტის ტიპის გასაღებების კავშირი

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

## typeof — მნიშვნელობის ტიპი

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

`typeof` (ტიპის პოზიციაში) ხელმისაწვდომი ხდის runtime მნიშვნელობის გამოვლენილ ტიპს, ასე რომ თქვენ არ უნდა დაწეროთ ტიპი ცალკე.

## დაკომბინირებული: კლასიკური ტიპ-უსაფრთხო თვისების 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`-ს რეალურ გასაღებებზე, ხოლო `T[K]` (*indexed access type*) აბრუნებს ზუსტ მნიშვნელობის ტიპს ამ გასაღებისთვის. ტიპოგრაფიული შეცდომები ხდება compile შეცდომები.

## კავშირის წაკითხვა const ობიექტიდან

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

## რატომ აქვს მნიშვნელობა

`keyof` და `typeof` აკავშირებენ მნიშვნელობის სამყაროს და ტიპის სამყაროს.

ისინი აკეთებენ ტიპ-უსაფრთხო თვისების წვდომას, ტიპების წაკითხვას კონფიგურაციადან/მუდმივებიდან (სიმართის ერთი წყარო), და არის mapped და conditional ტიპების აგურ ბლოკი.

ისინი ის უკან უწინ, რომ თავიდან აიცილოთ პარალელური ტიპის განმარტებების ხელით შენარჩუნება.