Seriya: TypeScript Basics Dars 57

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.