Seriya: TypeScript Basics Dars 53

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.