Series: TypeScript Basics Lesson 61

Mapped types

TypeScript'da mapped type'lar: [K in Union] sintaksisi, keyof bilan mavjud type kalitlari ustidan aylanish, T[K] bilan aniq qiymat type'i, generic mapped type, cheklovlar, as bilan key remapping va T[K] o'rniga T[keyof T] yozish xatosi.

61-dars

Mapped types

Ko'pincha mavjud type'ning har bir maydoni uchun nimadir kerak bo'ladi: har bir maydonga tekshiruvchi, xato xabari yoki "o'zgarganmi?" bayrog'i. Buni qo'lda yozsak, ikki type bir-biridan ajralib qoladi:

// ❌ Mahsulot'ning maydonlari qo'lda takrorlangan
interface MahsulotTekshiruvlari {
  id: (qiymat: number) => boolean;
  nomi: (qiymat: string) => boolean;
  narx: (qiymat: number) => boolean;
  toifa: (qiymat: string) => boolean;
}

// Keyinroq Mahsulot'ga yangi maydon qo'shildi:
interface Mahsulot {
  id: number;
  nomi: string;
  narx: number;
  toifa: string;
  chegirma: number; // yangi
}

// 🐛 MahsulotTekshiruvlari'ni yangilash esdan chiqdi — TS indamaydi,
//    chegirma hech qachon tekshirilmaydi (masalan, -50 yoki 120 o'tib ketadi)

Mapped type yangi type'ni mavjud type'ning kalitlaridan avtomatik yasaydi:

// ✅ Mahsulot'dan hosil qilinadi
type MahsulotTekshiruvlari = {
  [K in keyof Mahsulot]: (qiymat: Mahsulot[K]) => boolean;
};

const tekshiruvlar: MahsulotTekshiruvlari = {
  id: q => q > 0,
  nomi: q => q.trim().length > 0,
  narx: q => q >= 0,
  toifa: q => q.length > 0,
};
// ❌ Property 'chegirma' is missing in type '{ id: ...; nomi: ...; narx: ...; toifa: ...; }'
//    but required in type 'MahsulotTekshiruvlari'.

Endi Mahsulot o'zgarsa, unga bog'liq type ham o'zi o'zgaradi va yetishmayotgan joyni TS ko'rsatadi.

Quyidagi misollarda yana chegirmasiz, odatdagi Mahsulot'dan foydalanamiz:

interface Mahsulot {
  id: number;
  nomi: string;
  narx: number;
  toifa: string;
}

Qanday ishlaydi?

1. Sintaksis: [K in Union]: Type

Mapped type union'dagi har bir a'zo ustidan "aylanib chiqadi" va har biri uchun bitta xususiyat yasaydi:

type BuyurtmaHolati = "yangi" | "yolda" | "yetkazildi";

type HolatlarSoni = {
  [H in BuyurtmaHolati]: number;
};

// Natija:
// {
//   yangi: number;
//   yolda: number;
//   yetkazildi: number;
// }

const statistika: HolatlarSoni = { yangi: 12, yolda: 5, yetkazildi: 40 }; // ✅

H — o'zgaruvchi nomi (odatda K, P yoki ma'noli nom). in — "shu union'ning har bir a'zosi uchun" degani. Bu for...in siklining type darajasidagi ko'rinishi.

Aynan shu ish uchun tayyor Record<BuyurtmaHolati, number> ham bor. U ichkarida xuddi shunday mapped type.

2. keyof bilan: mavjud type'ning kalitlari ustidan

keyof Mahsulot kalitlar union'ini beradi: "id" | "nomi" | "narx" | "toifa". Uni in'dan keyin qo'ysak, mavjud type'ning har bir kaliti uchun yangi xususiyat hosil bo'ladi:

type MahsulotXatolari = {
  [K in keyof Mahsulot]: string;
};

// Natija:
// {
//   id: string;
//   nomi: string;
//   narx: string;
//   toifa: string;
// }

Bu yerda barcha qiymatlar bir xil (string), ya'ni asl qiymat type'lari e'tiborga olinmagan.

3. T[K]: har bir kalitning o'z qiymat type'i

Indexed access (T["id"], 56-dars) mapped type ichida juda kuchli ishlaydi. K har aylanishda bitta aniq kalit bo'lgani uchun Mahsulot[K] aynan shu kalitning type'ini beradi:

type MahsulotNusxasi = {
  [K in keyof Mahsulot]: Mahsulot[K];
};
// { id: number; nomi: string; narx: number; toifa: string } — aslining aynan o'zi

O'z-o'zidan foydasi yo'q, lekin Mahsulot[K]'ni boshqa narsa ichiga o'rasak, maydonlarning aniq type'lari saqlanib qoladi:

type MahsulotOzgarishlari = {
  [K in keyof Mahsulot]: { eski: Mahsulot[K]; yangi: Mahsulot[K] };
};

const ozgarish: MahsulotOzgarishlari["narx"] = { eski: 85000, yangi: 79000 }; // ✅
const xato: MahsulotOzgarishlari["narx"] = { eski: "85000", yangi: 79000 };
// ❌ Type 'string' is not assignable to type 'number'.

4. Qiymatni istalgancha o'zgartirish

:'dan keyingi qism istalgan type bo'lishi mumkin. Bir nechta keng tarqalgan shakllar:

// Har bir maydon uchun o'qib oluvchi funksiya
type MahsulotOquvchilar = {
  [K in keyof Mahsulot]: () => Mahsulot[K];
};

// Har bir maydon bo'yicha filtr: bir nechta qiymat ro'yxati
type MahsulotFiltri = {
  [K in keyof Mahsulot]: Mahsulot[K][];
};

// Har bir maydon o'zgarganmi
type MahsulotBayroqlari = {
  [K in keyof Mahsulot]: boolean;
};

const filtr: MahsulotFiltri = {
  id: [],
  nomi: [],
  narx: [10000, 50000],
  toifa: ["oshxona", "maishiy"],
};

5. Generic qilish: istalgan type uchun

Mahsulot o'rniga T qo'ysak, mapped type istalgan entity uchun ishlaydi:

type Tekshiruvlar<T> = {
  [K in keyof T]: (qiymat: T[K]) => boolean;
};

type Foydalanuvchi = { id: number; ism: string };

const foydalanuvchiTekshiruvlari: Tekshiruvlar<Foydalanuvchi> = {
  id: q => q > 0,
  ism: q => q.length >= 2,
};

6. Mapped type — faqat type bilan va o'zi alohida

Mapped type'ni interface ichida yozib bo'lmaydi va unga qo'shimcha oddiy xususiyat aralashtirib ham bo'lmaydi:

type Tanlov = {
  [K in keyof Mahsulot]: boolean;
  hammasiTanlangan: boolean;
};
// ❌ A mapped type may not declare properties or methods.

Qo'shimcha maydon kerak bo'lsa, intersection (&) bilan qo'shiladi:

type Tanlov = {
  [K in keyof Mahsulot]: boolean;
} & {
  hammasiTanlangan: boolean;
}; // ✅

7. Key remapping: kalit nomini ham o'zgartirish (as)

Yuqoridagi mapped type'lar kalitlarni o'zgarishsiz olib, faqat qiymatlarni o'zgartirdi. Lekin ko'pincha kalit nomining o'zi ham boshqacha bo'lishi kerak: nomi → olNomi, narx → narxOzgardi. Buni qo'lda yozsak, yana nusxa paydo bo'ladi:

// ❌ Har bir maydon uchun o'qib oluvchi — nomlar qo'lda yozilgan
interface MahsulotOquvchilar {
  olId: () => number;
  olNomi: () => string;
  olNarx: () => number;
  olToifa: () => string;
}

// 🐛 Mahsulot'da "toifa" → "kategoriya" deb qayta nomlandi.
//    MahsulotOquvchilar'da esa olToifa qolib ketdi — TS indamaydi,
//    olToifa() endi yo'q maydonni qaytarib, undefined beradi

Key remapping (as) bilan yangi nom eski kalitdan hosil qilinadi:

// ✅ Nomlar Mahsulot'dan avtomatik yasaladi
type MahsulotOquvchilar = {
  [K in keyof Mahsulot as `ol${Capitalize<K>}`]: () => Mahsulot[K];
};

// Natija:
// {
//   olId: () => number;
//   olNomi: () => string;
//   olNarx: () => number;
//   olToifa: () => string;
// }

Mahsulot'dagi maydon qayta nomlansa, olToifa o'z-o'zidan olKategoriya'ga aylanadi va eski nomdan foydalangan joylarni TS ko'rsatadi.

as'dan keyingi qism — template literal type: `ol${...}` qatorni yasaydi, Capitalize esa birinchi harfni katta qiladi ("nomi" → "Nomi"). Generic T bilan yozilganda keyof T ichida number va symbol kalitlar ham bo'lishi mumkin, shuning uchun Capitalize<string & K> deb yoziladi:

type Oquvchilar<T> = {
  [K in keyof T as `ol${Capitalize<string & K>}`]: () => T[K];
};

8. Modifikatorlar: readonly va ?

Bitta entity'ning odatda bir nechta "ko'rinishi" kerak bo'ladi: o'zgartirib bo'lmaydigan nusxa, forma uchun hamma maydoni ixtiyoriy qoralama va hokazo. Ularni qo'lda yozsak, yana nusxalar paydo bo'ladi:

// ❌ Mahsulot'ning qo'lda yozilgan versiyalari
interface OzgarmasMahsulot {
  readonly id: number;
  readonly nomi: string;
  readonly narx: number;
  readonly toifa: string;
}

interface MahsulotQoralama {
  id?: number;
  nomi?: string;
  narx?: number;
  // 🐛 toifa yozish esdan chiqdi — TS indamaydi,
  //    formada toifa maydoni type darajasida umuman "yo'q"
}

Mapped type'da kalit oldiga yoki keyiniga modifikator qo'yib, xuddi shu versiyalarni Mahsulot'dan hosil qilish mumkin:

// ✅ Hammasi Mahsulot'dan yasaladi
type OzgarmasMahsulot = {
  readonly [K in keyof Mahsulot]: Mahsulot[K];
};

type MahsulotQoralama = {
  [K in keyof Mahsulot]?: Mahsulot[K];
};

// MahsulotQoralama:
// { id?: number; nomi?: string; narx?: number; toifa?: string }

Endi Mahsulot'ga maydon qo'shilsa, barcha versiyalarga u o'zi qo'shiladi. Tayyor Readonly<T> va Partial<T> utility type'lari ichkarida aynan shunday yozilgan.

Eng ko'p uchraydigan xato

T[K] o'rniga T[keyof T] yozish. Mapped type ichida qiymat type'ini yozishda ko'pchilik Mahsulot[K] o'rniga Mahsulot[keyof Mahsulot] yozib qo'yadi — "kalitning qiymati-ku" deb:

type MahsulotTekshiruvlari = {
  [K in keyof Mahsulot]: (qiymat: Mahsulot[keyof Mahsulot]) => boolean;
};

const tekshiruvlar: MahsulotTekshiruvlari = {
  id: q => q > 0,
  // ❌ Operator '>' cannot be applied to types 'string | number' and 'number'.
  nomi: q => String(q).length > 0, // TS'ni "tinchlantirish" uchun String()
  narx: q => Number(q) >= 0,       // ...va Number()
  toifa: q => String(q).length > 0,
};

tekshiruvlar.narx("qimmat"); // TS indamaydi
// 🐛 Number("qimmat") → NaN, NaN >= 0 → false, lekin narxga matn berilgani ushlanmadi

Nega bunday bo'ladi? keyof Mahsulot — barcha kalitlar union'i, demak Mahsulot[keyof Mahsulot] — barcha qiymat type'lari union'i: number | string. Aylanish o'zgaruvchisi K esa har safar bitta aniq kalit:

Yozuv Ma'nosi Mahsulot uchun
keyof Mahsulot Barcha kalitlar "id" | "nomi" | "narx" | "toifa"
Mahsulot[keyof Mahsulot] Barcha qiymatlar aralash number | string
Mahsulot[K] (ichkarida) Shu kalitning qiymati narx uchun number

✅ Yechim: mapped type ichida doim aylanish o'zgaruvchisini ishlating:

type MahsulotTekshiruvlari = {
  [K in keyof Mahsulot]: (qiymat: Mahsulot[K]) => boolean;
};

const tekshiruvlar: MahsulotTekshiruvlari = {
  id: q => q > 0,                 // q: number ✅
  nomi: q => q.trim().length > 0, // q: string ✅
  narx: q => q >= 0,              // q: number ✅
  toifa: q => q.length > 0,       // q: string ✅
};

tekshiruvlar.narx("qimmat");
// ❌ Argument of type 'string' is not assignable to parameter of type 'number'.

Callback'larda String() / Number() kabi "tinchlantiruvchi" o'girishlar paydo bo'lsa, bu odatda qiymat type'i noto'g'ri yozilganining belgisi.

Esda tuting: mapped type ichida T[K] — "shu kalitning qiymati", T[keyof T] esa "hamma qiymatlar aralashmasi"; ichkarida deyarli doim birinchisi kerak.