Series: TypeScript Basics Lesson 52

Generic constraints

TypeScript'da generic constraint'lar: T extends X — "kamida shunday", to'liq type'ni saqlab qolish, primitive va union constraint'lar, literal saqlanishi, keyof bilan cheklash va constraint shaklidagi obyektni T sifatida qaytarish xatosi.

52-dars

Generic constraints

Generic funksiya ichida T haqida hech narsa ma'lum emasligini ko'rgan edik: x.length xato beradi. Uni "tuzatish" uchun generic'dan voz kechilsa, boshqa muammo chiqadi:

// ❌ Generic yo'q — length'ga murojaat qilsa bo'ladi, lekin type yo'qoladi
function engUzun(a: { length: number }, b: { length: number }) {
  return a.length >= b.length ? a : b;
}

const ism = engUzun("Ali", "Valijon"); // ism: { length: number }
ism.toUpperCase();
// ❌ Property 'toUpperCase' does not exist on type '{ length: number; }'.

Funksiyaga string kirdi, lekin TS natijani faqat "length'i bor narsa" deb biladi. Generic constraint ikkalasini birlashtiradi: T istalgan type, lekin kamida length'i bo'lishi shart:

// ✅ T extends { length: number } — "length'i bor istalgan type"
function engUzun<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b; // ✅ length ma'lum
}

const ism = engUzun("Ali", "Valijon"); // ism: string
ism.toUpperCase();                     // ✅
const royxat = engUzun([1, 2], [3]);   // royxat: number[]

engUzun(10, 20);
// ❌ Argument of type 'number' is not assignable to parameter of type '{ length: number; }'.

Qanday ishlaydi?

1. extends — "kamida shunday"

T extends X — "T — X'ga sig'adigan istalgan type". TS'da type'lar strukturaviy, shuning uchun qo'shimcha maydonlar to'sqinlik qilmaydi:

function logla<T extends { id: number }>(x: T): T {
  console.log(`#${x.id}`); // ✅ id ma'lum
  return x;
}

logla({ id: 1 });                         // ✅
logla({ id: 2, ism: "Ali", faol: true }); // ✅ qo'shimcha maydonlar — muammo emas
logla({ ism: "Vali" });
// ❌ Argument of type '{ ism: string; }' is not assignable to parameter of type '{ id: number; }'.

Funksiya ichida faqat constraint'dagi maydonlar ishlatiladi. Tashqarida esa T to'liq type'ni saqlab qoladi.

2. Constraint — kirish uchun shart, qaytish type'i emas

Real loyihada eng ko'p uchraydigan holat: funksiyaga faqat bitta maydon kerak, lekin chaqiruvchi to'liq obyektni qaytarib olishi kerak:

function idBoyichaTop<T extends { id: number }>(arr: T[], id: number): T | undefined {
  return arr.find((x) => x.id === id);
}

type Mahsulot = { id: number; nom: string; narx: number };
declare const mahsulotlar: Mahsulot[];

const m = idBoyichaTop(mahsulotlar, 7); // m: Mahsulot | undefined — to'liq type
m?.narx;                                // ✅

Constraint'siz oddiy type yozilsa, natija qisqarib qolardi:

Imzo idBoyichaTop(mahsulotlar, 7) natijasi
(arr: { id: number }[]) => { id: number } | undefined { id: number } — nom, narx yo'qoldi ❌
<T extends { id: number }>(arr: T[]) => T | undefined Mahsulot ✅

3. Primitive va union constraint'lar

Constraint obyekt bo'lishi shart emas:

function formatla<T extends string | number>(x: T): string {
  return typeof x === "number" ? x.toFixed(2) : x.trim(); // typeof — 42-dars
}

formatla(3.14159); // "3.14"
formatla(true);
// ❌ Argument of type 'boolean' is not assignable to parameter of type 'string | number'.

Bonus: T extends string bo'lsa, TS argumentdagi literal'ni saqlaydi:

function holat<T extends string>(nom: T): { holat: T } {
  return { holat: nom };
}

holat("faol"); // { holat: "faol" } — string emas, aniq literal

Bu "discriminant string'ga kengayib ketishi" muammosining yordamchi funksiyalarda oldini oladi.

4. Boshqa type parametr bilan cheklash

Constraint ikkinchi type parametrga bog'liq bo'lishi mumkin. Eng mashhur misol — "obyekt va uning kaliti":

function ol<T, K extends keyof T>(obj: T, kalit: K): T[K] {
  return obj[kalit];
}

ol({ ism: "Ali", yosh: 30 }, "yosh"); // number
ol({ ism: "Ali", yosh: 30 }, "manzil");
// ❌ Argument of type '"manzil"' is not assignable to parameter of type '"ism" | "yosh"'.

Eng ko'p uchraydigan xato

Constraint shaklidagi yangi obyektni T sifatida qaytarish.

type Maqola = { id: number; sarlavha: string; yangilangan: Date };
declare const maqola: Maqola;

function yangila<T extends { yangilangan: Date }>(x: T): T {
  return { yangilangan: new Date() };
  // ❌ Type '{ yangilangan: Date; }' is not assignable to type 'T'.
  //      '{ yangilangan: Date; }' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{ yangilangan: Date; }'.
}

Ko'pchilik bu uzun xabarni tushunmay, as T bilan "yopadi":

function yangila<T extends { yangilangan: Date }>(x: T): T {
  return { yangilangan: new Date() } as T;
}

const m = yangila(maqola); // m: Maqola — TS shunday deydi
m.sarlavha.toUpperCase();
// 💥 TypeError: Cannot read properties of undefined (reading 'toUpperCase')
//    obyektda faqat yangilangan bor, id va sarlavha yo'qoldi

Nega bunday bo'ladi? T extends { yangilangan: Date } — "T kamida yangilangan'ga ega". Bu T aynan { yangilangan: Date } degani emas. Chaqiruvchi Maqola'ni uzatsa, T = Maqola bo'ladi va funksiya Maqola qaytarishga va'da beradi. { yangilangan: new Date() } esa constraint'ga sig'adi, lekin Maqola emas: unda id va sarlavha yo'q. TS xabari aynan shuni aytadi: "constraint'ga mos, lekin T uning boshqa, kengroq varianti bo'lishi mumkin".

✅ Yechim 1: kirgan obyektni yoyib (spread), faqat kerakli maydonni almashtiring

function yangila<T extends { yangilangan: Date }>(x: T): T {
  return { ...x, yangilangan: new Date() }; // ✅ barcha maydonlar saqlanadi
}

const m = yangila(maqola);
m.sarlavha.toUpperCase(); // ✅ sarlavha joyida

✅ Yechim 2: kirgan obyektning o'zini o'zgartirib, uni qaytaring

function yangila<T extends { yangilangan: Date }>(x: T): T {
  x.yangilangan = new Date();
  return x; // ✅ x — T
}

Bu variant asl obyektni o'zgartiradi (mutation). Bu ba'zan kerak, ba'zan xavfli: masalan, React state'ida yangi obyekt kerak bo'ladi.

Esda tuting: T extends X — "T kamida X", aynan X emas, shuning uchun T qaytarish kerak bo'lsa, X shaklidagi yangi obyekt emas, kirgan qiymatni (yoki uning nusxasini) qaytaring.