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.