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.