keyof
TypeScript'da keyof operatori: type kalitlarining literal union'i, type bilan sinxronlik, keyof bilan murojaat, index signature'da keyof, keyof typeof va Object.keys() natijasini as bilan keyof'ga aylantirish xatosi.
54-dars
keyof
Obyektning maydon nomi bilan ishlaydigan funksiyalar ko'p: saralash, filtrlash, jadval ustunlari, forma maydonlari. Maydon nomi oddiy string deb yozilsa, xato nom jimgina o'tib ketadi:
type Mahsulot = { id: number; nom: string; narx: number };
declare const mahsulotlar: Mahsulot[];
// ❌ maydon: string — har qanday matn "to'g'ri"
function saralash(arr: Mahsulot[], maydon: string): Mahsulot[] {
return [...arr].sort((a, b) => (a as any)[maydon] > (b as any)[maydon] ? 1 : -1);
}
saralash(mahsulotlar, "narxi"); // 🐛 bunday maydon yo'q — undefined > undefined, tartib o'zgarmaydi
Qo'lda yozilgan union ham to'liq yechim emas:
type MahsulotMaydoni = "id" | "nom" | "narx";
// Mahsulot'ga "ombor" qo'shildi — bu union eskirib qoldi 🐛, TS eslatmaydi
keyof type'dan uning barcha kalitlarini avtomatik oladi:
// ✅ keyof Mahsulot = "id" | "nom" | "narx"
function saralash(arr: Mahsulot[], maydon: keyof Mahsulot): Mahsulot[] {
return [...arr].sort((a, b) => (a[maydon] > b[maydon] ? 1 : -1));
}
saralash(mahsulotlar, "narx"); // ✅
saralash(mahsulotlar, "narxi");
// ❌ Argument of type '"narxi"' is not assignable to parameter of type 'keyof Mahsulot'.
Qanday ishlaydi?
1. keyof T — kalitlar nomlarining literal union'i
keyof — type operatori: u obyekt type'ini oladi va uning kalitlarini string literal'lar union'i sifatida qaytaradi:
type Foydalanuvchi = { id: number; ism: string; email: string };
type Kalit = keyof Foydalanuvchi; // "id" | "ism" | "email"
const a: Kalit = "ism"; // ✅
const b: Kalit = "parol";
// ❌ Type '"parol"' is not assignable to type 'keyof Foydalanuvchi'.
Editor'da Kalit ustiga borilsa, keyof Foydalanuvchi ko'rinadi. Uni ochib ko'rish uchun hover'da "expand" qilinadi.
2. Type bilan doim sinxron
keyof type'ning o'zidan hisoblanadi. Shuning uchun type o'zgarsa, u ham avtomatik o'zgaradi:
type Foydalanuvchi = { id: number; ism: string; email: string; telefon?: string };
type Kalit = keyof Foydalanuvchi; // "id" | "ism" | "email" | "telefon"
Optional va readonly maydonlar ham keyof'ga kiradi. keyof faqat kalit nomlariga qaraydi, maydon majburiy yoki o'zgarmasligiga emas.
3. keyof bilan obyektga murojaat
Kalit keyof T type'ida bo'lsa, obj[kalit] xavfsiz. Lekin natija type'i barcha maydon type'larining union'i bo'ladi:
declare const user: Foydalanuvchi;
function qiymat(u: Foydalanuvchi, k: keyof Foydalanuvchi) {
return u[k]; // string | number | undefined (telefon optional)
}
const id = qiymat(user, "id"); // string | number | undefined — aniq "number" emas
"id" uzatilganda number, "ism" uzatilganda string qaytishi uchun generic kerak: <K extends keyof T>(obj: T, k: K): T[K]. Bu usulni 52-darsda (ol funksiyasi) ko'rgan edik, T[K]'ni esa keyingi darslarda batafsil ko'ramiz.
4. Index signature'da keyof
Kalitlari oldindan ma'lum bo'lmagan obyektda keyof aniq nomlar emas, kalitning type'ini beradi:
type Lugat = { [soz: string]: string };
type A = keyof Lugat; // string | number
type Royxat = { [indeks: number]: string };
type B = keyof Royxat; // number
string index signature'da number ham qo'shiladi, chunki JS'da obj[1] va obj["1"] bir xil narsa: raqamli kalitlar avtomatik string'ga aylanadi.
5. keyof faqat type bilan ishlaydi, qiymat bilan emas
keyof type operatori, shuning uchun unga oddiy o'zgaruvchi berib bo'lmaydi:
const sozlamalar = { mavzu: "qorong'i", til: "uz" };
type K = keyof sozlamalar;
// ❌ 'sozlamalar' refers to a value, but is being used as a type here. Did you mean 'typeof sozlamalar'?
type K2 = keyof typeof sozlamalar; // ✅ "mavzu" | "til"
Qiymatdan type olish uchun typeof type operatori kerak.
| Yozuv | Nima beradi |
|---|---|
keyof Mahsulot |
Mahsulot type'i kalitlari |
keyof typeof obj |
obj o'zgaruvchisi kalitlari |
keyof { [k: string]: X } |
string | number |
Eng ko'p uchraydigan xato
Object.keys() natijasi bilan obyektga murojaat qilish.
type Sozlamalar = { mavzu: string; til: string; shrift: string };
function chopEt(s: Sozlamalar) {
Object.keys(s).forEach((k) => {
console.log(k, s[k]);
// ❌ Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'Sozlamalar'.
// No index signature with a parameter of type 'string' was found on type 'Sozlamalar'.
});
}
Ko'pchilik "TS bu yerda ahmoqlik qilyapti" deb, as bilan tuzatadi:
(Object.keys(s) as (keyof Sozlamalar)[]).forEach((k) => {
console.log(k, s[k].toUpperCase());
});
Nega bunday bo'ladi? Object.keys() ataylab string[] qaytaradi, (keyof T)[] emas. Sababi strukturaviy typing: Sozlamalar type'idagi o'zgaruvchida runtime'da qo'shimcha maydonlar ham bo'lishi mumkin:
const kengaytirilgan = { mavzu: "oq", til: "uz", shrift: "Inter", versiya: 3 };
chopEt(kengaytirilgan); // ✅ TS ruxsat beradi — kerakli maydonlar bor
// as bilan yozilgan kodda k = "versiya" ham keladi:
// s["versiya"].toUpperCase()
// 💥 TypeError: s[k].toUpperCase is not a function — 3 raqam
TS bu yerda haqli: keyof type'dagi kalitlarni biladi, obyektdagi haqiqiy kalitlarni esa bilmaydi.
✅ Yechim 1: aynan kerakli kalitlarni ro'yxat qilib yozing
const KALITLAR: (keyof Sozlamalar)[] = ["mavzu", "til", "shrift"];
function chopEt(s: Sozlamalar) {
KALITLAR.forEach((k) => {
console.log(k, s[k].toUpperCase()); // ✅ k: keyof Sozlamalar, s[k]: string
});
}
Endi faqat ma'lum kalitlar aylanib chiqiladi. Ro'yxatda xato nom yozilsa, TS uni darhol ko'rsatadi.
✅ Yechim 2: as — faqat obyektni o'zingiz yaratgan bo'lsangiz
Obyekt shu funksiya ichida, aniq literal sifatida yaratilgan bo'lsa va tashqaridan kelmasa, qo'shimcha kalitlar bo'lmasligi aniq. Bunda as (keyof T)[] qabul qilinadi. Lekin bu ongli qaror bo'lishi kerak: obyekt parametr sifatida kelsa, Yechim 1'ni tanlang.
Esda tuting: keyof T type'dagi kalitlarni beradi, Object.keys() esa obyektdagi haqiqiy kalitlarni, shuning uchun ularni as bilan tenglashtirmang, kerakli kalitlar ro'yxatini o'zingiz yozing.