Multiple generics
TypeScript'da bir nechta type parametr: kirish va chiqishni ajratish, callback'dan inference, har biriga alohida constraint, nomlash odatlari, ortiqcha parametrlar va type argumentlardan faqat bittasini yozish xatosi.
53-dars
Multiple generics
Bitta T bilan generic funksiyalar yozdik. Lekin ko'p funksiyalarda kirish va chiqish har xil type bo'ladi. Bitta T bunga yetmaydi:
// ❌ Bitta T — kirish va chiqish majburan bir xil type
function ozgartir<T>(arr: T[], fn: (x: T) => T): T[] {
return arr.map(fn);
}
const narxlar = [85_000, 12_500];
const matnlar = ozgartir(narxlar, (n) => `${n.toLocaleString()} so'm`);
// ❌ Type 'string' is not assignable to type 'number'.
TS T'ni narxlar'dan number deb oldi va callback ham number qaytarishini talab qildi. Ikkinchi type parametr qo'shilsa, kirish va chiqish mustaqil bo'ladi:
// ✅ T — kirish, U — chiqish
function ozgartir<T, U>(arr: T[], fn: (x: T) => U): U[] {
return arr.map(fn);
}
const matnlar = ozgartir(narxlar, (n) => `${n.toLocaleString()} so'm`);
// T = number, U = string → matnlar: string[] ✅
Aslida Array.prototype.map'ning o'zi xuddi shunday yozilgan: map<U>(fn: (x: T) => U): U[].
Qanday ishlaydi?
1. Har bir type parametr o'z argumentidan aniqlanadi
Type parametrlar vergul bilan yoziladi. TS ularning har birini alohida chiqaradi:
// Bitta T — ikkalasi bir xil bo'lishi shart
function juft<T>(a: T, b: T): [T, T] { return [a, b]; }
// Ikki parametr — har biri mustaqil
function juftlik<A, B>(a: A, b: B): [A, B] { return [a, b]; }
juft(1, "a");
// ❌ Argument of type 'string' is not assignable to parameter of type 'number'.
juftlik(1, "a"); // [number, string] ✅
2. Callback qaytargan type ham aniqlanadi
TS type'ni faqat oddiy argumentlardan emas, callback qaytargan qiymatdan ham chiqaradi. Bu "bitta narsadan boshqasini yasaydigan" funksiyalarning asosi:
function guruhla<T, K>(arr: T[], kalitOl: (x: T) => K): Map<K, T[]> {
const natija = new Map<K, T[]>();
for (const x of arr) {
const k = kalitOl(x);
const guruh = natija.get(k) ?? [];
guruh.push(x);
natija.set(k, guruh);
}
return natija;
}
type Buyurtma = { id: number; shahar: string; summa: number };
declare const buyurtmalar: Buyurtma[];
const shaharBoyicha = guruhla(buyurtmalar, (b) => b.shahar);
// T = Buyurtma (arr'dan), K = string (callback'dan) → Map<string, Buyurtma[]>
const kattaKichik = guruhla(buyurtmalar, (b) => b.summa > 1_000_000);
// K = boolean → Map<boolean, Buyurtma[]>
Tartib muhim: TS avval arr'dan T'ni aniqlaydi, keyin callback'ning x parametriga uni beradi va shundan keyin callback natijasidan K'ni chiqaradi.
3. Har biriga alohida constraint
extends har bir parametrga alohida qo'yiladi:
function birlashtir<A extends object, B extends object>(a: A, b: B): A & B {
return { ...a, ...b };
}
const profil = birlashtir({ ism: "Ali" }, { yosh: 30 });
// { ism: string } & { yosh: number } — intersection
profil.yosh; // ✅
Bir parametr ikkinchisiga bog'liq bo'lishi ham mumkin (K extends keyof T, 52-dars).
4. Nomlash odatlari
| Nom | Odatdagi ma'nosi | Misol |
|---|---|---|
T, U, V |
1-, 2-, 3- type | ozgartir<T, U> |
K, V |
kalit (key) va qiymat (value) | Map<K, V> |
A, B |
ikki teng huquqli kirish | juftlik<A, B> |
| Ma'noli nom | murakkab funksiyalarda | <Kirish, Chiqish>, <Element, Kalit> |
Uchtadan ko'p parametr bo'lsa, harflar o'rniga ma'noli nomlar o'qishni ancha osonlashtiradi.
5. Har bir type parametr kamida ikki joyni bog'lashi kerak
Ikkinchi parametr faqat haqiqatan mustaqil type bo'lsa kerak. Agar u hech narsani bog'lamasa, ortiqcha:
// ❌ U faqat bitta joyda — hech narsani bog'lamaydi
function chopEt<T, U extends T[]>(arr: U): void {
arr.forEach((x) => console.log(x));
}
// ✅ Oddiyroq va bir xil ishlaydi
function chopEt<T>(arr: T[]): void {
arr.forEach((x) => console.log(x));
}
Type parametr ikki (yoki undan ko'p) joyda uchrab, ularni bog'lashi kerak. Faqat qaytish type'ida bo'lsa, bu yashirin as (51-dars).
6. Default type — standart type argument
Generic type'lar (Array<T>, Promise<T> kabi) har safar type argumentini talab qiladi. Ko'p hollarda esa deyarli doim bir xil type ishlatiladi:
// Server javoblari uchun umumiy shakl
type ApiJavob<T> = {
ok: boolean;
data: T;
xabar: string;
};
type Foydalanuvchi = { id: number; ism: string };
const profil: ApiJavob<Foydalanuvchi> = { ok: true, data: { id: 1, ism: "Ali" }, xabar: "" };
// ❌ O'chirish, chiqish va h.k. so'rovlar hech qanday data qaytarmaydi
const ochirish: ApiJavob = { ok: true, data: null, xabar: "O'chirildi" };
// ❌ Generic type 'ApiJavob' requires 1 type argument(s).
Natijada loyihada o'nlab joyda ApiJavob<null> yoziladi. Default type type parametrga standart qiymat beradi: argument yozilmasa, shu type ishlatiladi:
// ✅ T = null — argument berilmasa, data: null
type ApiJavob<T = null> = {
ok: boolean;
data: T;
xabar: string;
};
const profil: ApiJavob<Foydalanuvchi> = { ok: true, data: { id: 1, ism: "Ali" }, xabar: "" };
const ochirish: ApiJavob = { ok: true, data: null, xabar: "O'chirildi" }; // ✅ ApiJavob<null>
Eng ko'p uchraydigan xato
Type parametrlardan faqat bittasini qo'lda yozish. Ikki parametrli funksiyada faqat bittasini aniq ko'rsatmoqchisiz, ikkinchisini TS o'zi topsin:
function ozgartir<T, U>(arr: T[], fn: (x: T) => U): U[] {
return arr.map(fn);
}
type Variant = { qiymat: string; matn: string };
declare const shaharlar: string[];
const variantlar = ozgartir<Variant>(shaharlar, (s) => ({ qiymat: s, matn: s }));
// ❌ Expected 2 type arguments, but got 1.
Nega bunday bo'ladi? TS'da type argumentlari "hammasi yoki hech biri" qoidasi bilan ishlaydi. <...> yozilmasa, TS hammasini o'zi chiqaradi. Yozilsa, barchasini yozish kerak, qisman chiqarish (partial inference) yo'q. Bundan tashqari, bu yerda dasturchi aslida U'ni nazarda tutgan, lekin <Variant> tartib bo'yicha T'ga tushardi. Bu yana bir xato bo'lardi.
Ba'zan xato as bilan "chetlab o'tiladi": ozgartir(shaharlar, (s) => ({ ... }) as Variant). Shunda obyektda matn yozish unutilsa ham, TS indamaydi 🐛.
✅ Yechim 1: qaytish type'ini callback'ning o'zida yozing — ikkala parametr ham chiqariladi
const variantlar = ozgartir(shaharlar, (s): Variant => ({ qiymat: s, matn: s }));
// T = string, U = Variant ✅
Obyektda maydon unutilsa, xato aynan callback ichida chiqadi:
ozgartir(shaharlar, (s): Variant => ({ qiymat: s }));
// ❌ Property 'matn' is missing in type '{ qiymat: string; }' but required in type 'Variant'.
✅ Yechim 2: natija o'zgaruvchisiga type yozing
const variantlar: Variant[] = ozgartir(shaharlar, (s) => ({ qiymat: s, matn: s })); // ✅
✅ Yechim 3: kerak bo'lsa — ikkalasini ham yozing
const variantlar = ozgartir<string, Variant>(shaharlar, (s) => ({ qiymat: s, matn: s })); // ✅
Default type (<T, U = string>, 6-bo'lim) bilan type argumentlarni kamroq yozish mumkin, lekin bu inference emas: yozilmagan parametr argumentdan chiqarilmaydi, shunchaki default qiymatni oladi.
Esda tuting: type argumentlarni yo hammasini, yo hech birini yozasiz, shuning uchun bittasini aniqlashtirish kerak bo'lsa, <...> o'rniga callback yoki o'zgaruvchiga type yozing.