keyof + generics
TypeScript'da keyof va generic'lar birga: K extends keyof T, T[K] bilan aniq qaytish type'i, kalit o'zgaruvchida bo'lganda, overload'lar o'rniga bitta imzo, qiymatni tekshirish va massivdan ustun ajratish.
57-dars
keyof + generics
Obyektdan kalit bo'yicha qiymat oladigan universal funksiya yozmoqchimiz:
interface Mahsulot {
nomi: string;
narx: number;
omborda: boolean;
}
declare const mahsulot: Mahsulot;
// ❌ 1-urinish: kalit — oddiy string
function ol(obj: Mahsulot, kalit: string) {
return obj[kalit];
// ❌ Element implicitly has an 'any' type because expression of type 'string'
// can't be used to index type 'Mahsulot'.
}
// ❌ 2-urinish: kalit — keyof (54-dars)
function ol2(obj: Mahsulot, kalit: keyof Mahsulot) {
return obj[kalit]; // string | number | boolean
}
const narx = ol2(mahsulot, "narx"); // string | number | boolean
narx.toFixed(2);
// ❌ Property 'toFixed' does not exist on type 'string | number | boolean'.
Ikkinchi variant kalitni to'g'ri tekshiradi, lekin natija har doim barcha qiymatlar union'i. Biz esa "narx" bersak — number, "nomi" bersak — string olishni xohlaymiz. Bundan tashqari, funksiya faqat Mahsulot bilan ishlaydi.
// ✅ Yechim: obyekt ham, kalit ham generic
function ol<T, K extends keyof T>(obj: T, kalit: K): T[K] {
return obj[kalit];
}
const narx = ol(mahsulot, "narx"); // number ✅
const nomi = ol(mahsulot, "nomi"); // string ✅
narx.toFixed(2); // ✅ xato yo'q
Qanday ishlaydi?
1. K extends keyof T — kalitni cheklash
Constraint'lar (52-dars) bu yerda ham ishlaydi: K istalgan type emas, faqat T'ning kalitlaridan biri bo'lishi mumkin:
const mahsulot = { nomi: "Choynak", narx: 85000, omborda: true };
ol(mahsulot, "narx"); // ✅
ol(mahsulot, "rang");
// ❌ Argument of type '"rang"' is not assignable to parameter of type '"nomi" | "narx" | "omborda"'.
TS avval birinchi argumentdan T'ni aniqlaydi, keyin keyof T'ni hisoblab, ikkinchi argumentni shunga solishtiradi. Tahrirlovchi ham kalitlarni avtomatik taklif qiladi.
2. T[K] — aniq qiymat type'i
Qaytish type'i — indexed access (56-dars). Har bir chaqiruvda K aniq literal bo'ladi, shuning uchun T[K] ham aniq:
| Chaqiruv | K |
T[K] |
|---|---|---|
ol(mahsulot, "nomi") |
"nomi" |
string |
ol(mahsulot, "narx") |
"narx" |
number |
ol(mahsulot, "omborda") |
"omborda" |
boolean |
3. Kalit o'zgaruvchida bo'lsa
TS K'ni argumentdan aniqlaydi (infer). Agar o'zgaruvchi let bilan e'lon qilingan bo'lsa, uning type'i string'ga kengayadi:
let kalit = "narx"; // string
ol(mahsulot, kalit);
// ❌ Argument of type 'string' is not assignable to parameter of type '"nomi" | "narx" | "omborda"'.
const kalit2 = "narx"; // "narx" — literal
ol(mahsulot, kalit2); // ✅ number
Kalit bir nechta qiymatdan biri bo'lsa, natija yana union bo'ladi — bu to'g'ri, chunki TS qaysi kalit kelishini bilmaydi:
function tanla(k: "nomi" | "narx") {
const q = ol(mahsulot, k); // string | number
}
4. Overload'lar o'rniga bitta generic imzo
"Har bir kalit uchun alohida type" muammosini overload'lar bilan yechgan edik:
// ❌ Eski usul: har bir sozlama uchun alohida overload
function sozlamaOl(k: "til"): string;
function sozlamaOl(k: "sahifaHajmi"): number;
function sozlamaOl(k: "qorongiRejim"): boolean;
function sozlamaOl(k: string) {
return sozlamalar[k as keyof Sozlamalar];
}
// Yangi sozlama qo'shilsa — yangi overload yozishni unutmaslik kerak
// ✅ keyof + generics: bitta imzo, hamma kalitlar uchun
interface Sozlamalar {
til: string;
sahifaHajmi: number;
qorongiRejim: boolean;
}
const sozlamalar: Sozlamalar = { til: "uz", sahifaHajmi: 20, qorongiRejim: false };
function sozlamaOl<K extends keyof Sozlamalar>(k: K): Sozlamalar[K] {
return sozlamalar[k]; // as kerak emas
}
sozlamaOl("sahifaHajmi"); // number
sozlamaOl("til"); // string
Bu yerda T generic emas — u Sozlamalar'ga qotirilgan, faqat K generic. Sozlamalar'ga yangi maydon qo'shilsa, funksiya avtomatik uni qo'llab-quvvatlaydi.
5. Qiymatni ham tekshirish: ornat
T[K] faqat qaytish type'ida emas, parametrda ham ishlaydi — kalitga mos qiymatni majburlaydi:
function ornat<T, K extends keyof T>(obj: T, kalit: K, qiymat: T[K]): void {
obj[kalit] = qiymat;
}
ornat(mahsulot, "narx", 90000); // ✅
ornat(mahsulot, "narx", "arzon");
// ❌ Argument of type 'string' is not assignable to parameter of type 'number'.
ornat(mahsulot, "omborda", false); // ✅
6. Massivdan bitta ustunni ajratish
Real loyihalarda tez-tez kerak bo'ladigan yordamchi:
function ustun<T, K extends keyof T>(royxat: T[], kalit: K): T[K][] {
return royxat.map((element) => element[kalit]);
}
const mahsulotlar = [
{ nomi: "Choynak", narx: 85000 },
{ nomi: "Piyola", narx: 12000 },
];
const narxlar = ustun(mahsulotlar, "narx"); // number[]
const nomlar = ustun(mahsulotlar, "nomi"); // string[]
Eng ko'p uchraydigan xato
K'ni cheklamasdan qoldirish.
function ol<T, K>(obj: T, kalit: K): T[K] {
// ^^^^ ❌ Type 'K' cannot be used to index type 'T'.
return obj[kalit];
// ❌ Type 'K' cannot be used to index type 'T'.
}
Nega bunday bo'ladi? K constraint'siz bo'lsa, u istalgan narsa bo'lishi mumkin: number, boolean, {}... TS T'ning bunday kalitlari bor-yo'qligini bilmaydi, shuning uchun T[K] deb yozishga ruxsat bermaydi. T ham, K ham generic bo'lgani bilan, ular o'rtasida bog'lanish yo'q.
✅ Yechim: K'ni T'ning kalitlari bilan bog'lang:
function ol<T, K extends keyof T>(obj: T, kalit: K): T[K] {
return obj[kalit]; // ✅
}
⚠️ as any yoki kalit as keyof T bilan xatoni "yashirish" yechim emas: chaqiruvchi tomonda kalit tekshiruvi ham, aniq qaytish type'i ham yo'qoladi.
Esda tuting: generic kalit doim K extends keyof T ko'rinishida yoziladi — aynan shu extends T[K]'ni mumkin qiladi.