Seriya: TypeScript Basics Dars 51

Generic fundamentals

TypeScript'da generic'lar asoslari: type parametr, argumentdan inference, tanish generic type'lar, T kirish va chiqishni bog'lashi, funksiya ichidagi cheklov va faqat qaytish type'idagi T — yashirin as.

51-dars

Generic fundamentals

Ba'zi funksiyalar har qanday type bilan bir xil ishlaydi: massivning birinchi elementini olish, qiymatni o'rash, ro'yxatni teskari qilish. Bunday funksiyani type'lashning ikki "oson" yo'li bor va ikkalasi ham yomon:

// ❌ 1-yo'l: har bir type uchun alohida funksiya
function birinchiString(arr: string[]): string | undefined { return arr[0]; }
function birinchiSon(arr: number[]): number | undefined { return arr[0]; }
// ... Foydalanuvchi, Mahsulot, Buyurtma uchun ham

// ❌ 2-yo'l: any — bitta funksiya, lekin type yo'qoladi
function birinchi(arr: any[]): any {
  return arr[0];
}

const narx = birinchi([12_000, 15_000]); // narx: any
narx.toUpperCase(); // TS indamaydi — 💥 TypeError: narx.toUpperCase is not a function

Generic funksiya type'ni parametr sifatida qabul qiladi. Funksiya bitta bo'lib qoladi, lekin har bir chaqiruvda TS aniq type'ni biladi:

// ✅ <T> — "qanday type kelsa, o'shani qaytaraman"
function birinchi<T>(arr: T[]): T | undefined {
  return arr[0];
}

const narx = birinchi([12_000, 15_000]); // narx: number | undefined
const ism = birinchi(["Ali", "Vali"]);   // ism: string | undefined

narx?.toUpperCase();
// ❌ Property 'toUpperCase' does not exist on type 'number'.

Qanday ishlaydi?

1. Type parametr — type uchun o'zgaruvchi

Oddiy parametr funksiyaga qiymat uzatadi, type parametr esa type uzatadi. Ular burchakli qavslarda, funksiya nomidan keyin e'lon qilinadi:

function orab<T>(qiymat: T): { qiymat: T } {
  //         ↑ e'lon    ↑ ishlatish      ↑ ishlatish
  return { qiymat };
}
Oddiy parametr Type parametr
Yoziladi (qiymat) <T>
Nimani ushlaydi 42, "Ali" number, string
Qachon aniqlanadi runtime'da compile vaqtida

T — an'anaviy nom ("Type"). Ma'noli nom ham yozish mumkin: <Element>, <Javob>. Bir nechta type parametr va ularni nomlashni keyingi darslarda ko'ramiz.

2. TS T'ni argumentdan o'zi aniqlaydi

Odatda T'ni qo'lda yozish shart emas. TS uni uzatilgan argumentdan chiqaradi (inference):

orab(42);        // T = number  → { qiymat: number }
orab("salom");   // T = string  → { qiymat: string }
orab({ id: 1 }); // T = { id: number }

Argumentdan aniqlab bo'lmaganda esa type'ni qo'lda yozasiz. Ko'pincha bu bo'sh holatda yaratiladigan konteynerlar:

const narxlar = new Map();                  // Map<any, any> ❌ — any yashirincha kirib keldi
const narxlar2 = new Map<string, number>(); // ✅ aniq

narxlar2.set("choynak", 85_000);
narxlar2.set("piyola", "arzon");
// ❌ Argument of type 'string' is not assignable to parameter of type 'number'.

3. Siz generic'larni allaqachon ishlatgansiz

Ko'p tanish type'lar aslida generic:

const ismlar: Array<string> = ["Ali"];      // string[] bilan bir xil
const javob: Promise<number> = Promise.resolve(42);
const teglar = new Set<string>();
const kesh = new Map<number, string>();

string[] — Array<string>'ning qisqa yozilishi. await javob number qaytarishini TS Promise<number>'dagi T orqali biladi.

4. T kirish va chiqishni bog'laydi

unknown ham har qanday qiymatni qabul qiladi. Lekin u "nima kirganini" eslab qolmaydi. Generic esa kirgan type'ni chiqishga olib o'tadi:

function takrorU(x: unknown): unknown[] { return [x, x]; }
function takrorT<T>(x: T): T[] { return [x, x]; }

takrorU("a"); // unknown[] — endi har bir elementni qayta tekshirish kerak
takrorT("a"); // string[]  ✅
Har qanday type qabul qiladimi Chiqishda type ma'lummi Xavfsizmi
any ✅ ❌ (any) ❌ tekshiruv o'chadi
unknown ✅ ❌ (unknown) ✅ lekin noqulay
<T> ✅ ✅ aniq type ✅

5. Funksiya ichida T haqida hech narsa ma'lum emas

T istalgan type bo'lishi mumkin, shuning uchun funksiya ichida unga xos metodlarni ishlatib bo'lmaydi:

function uzunlik<T>(x: T): number {
  return x.length;
  // ❌ Property 'length' does not exist on type 'T'.
}

T raqam ham bo'lishi mumkin, raqamda esa .length yo'q. "T — length'i bor type" deb cheklashni keyingi darsda (generic constraints) ko'ramiz.

6. Generic yoki overload

Bir funksiya bir nechta type bilan ishlashi uchun overload yozgan edik (33-dars). Agar qaytish type'i kirish type'i bilan bir xil bo'lsa, overload'lar soni tez o'sadi:

// ❌ Har bir yangi type uchun yangi imzo
function oxirgi(arr: string[]): string | undefined;
function oxirgi(arr: number[]): number | undefined;
function oxirgi(arr: Foydalanuvchi[]): Foydalanuvchi | undefined;
function oxirgi(arr: unknown[]): unknown {
  return arr[arr.length - 1];
}

oxirgi([new Date()]);
// ❌ No overload matches this call. — Date uchun imzo yozilmagan

Bularning barchasi bitta qoida: "X massiv kirsa, X | undefined qaytadi". Generic aynan shu qoidani bitta imzoda yozadi:

// ✅ Bitta imzo — istalgan type uchun
function oxirgi<T>(arr: T[]): T | undefined {
  return arr[arr.length - 1];
}

oxirgi(["Ali", "Vali"]); // string | undefined
oxirgi([new Date()]);    // Date | undefined ✅

Eng ko'p uchraydigan xato

T faqat qaytish type'ida — bu yashirin as. Server yoki localStorage'dan ma'lumot olish uchun "chiroyli" generic funksiya yoziladi:

async function yukla<T>(url: string): Promise<T> {
  const javob = await fetch(url);
  return javob.json(); // json() — Promise<any>, istalgan T'ga sig'adi
}

type Foydalanuvchi = { id: number; ism: string; email: string };

const u = await yukla<Foydalanuvchi>("/api/profil"); // u: Foydalanuvchi
console.log(u.email.toLowerCase());
// server { xato: "Sessiya tugagan" } qaytarsa:
// 💥 TypeError: Cannot read properties of undefined (reading 'toLowerCase')

TS hech qanday xato chiqarmaydi. Kod type-safe ko'rinadi, aslida esa hech narsa tekshirilmagan 🐛.

Nega bunday bo'ladi? Bu yerda T hech qaysi argumentda ishtirok etmaydi, faqat qaytish type'ida bor. Demak TS uni hech narsadan chiqara olmaydi va chaqiruvchi yozgan type'ni shunchaki qabul qiladi. yukla<Foydalanuvchi>(url) amalda (await (await fetch(url)).json()) as Foydalanuvchi bilan bir xil. Faqat as so'zi yashiringan, shuning uchun xavf ko'rinmaydi.

Belgisi oddiy: generic funksiyada T faqat bir marta, qaytish type'ida uchrasa, u hech narsani bog'lamaydi, shunchaki assertion vazifasini bajaradi.

✅ Yechim 1: halol type qaytaring — unknown, tekshiruvni chaqiruvchiga qoldiring

async function yukla(url: string): Promise<unknown> {
  const javob = await fetch(url);
  return javob.json();
}

const data = await yukla("/api/profil");
if (foydalanuvchimi(data)) {             // type guard
  console.log(data.email.toLowerCase()); // ✅
}

✅ Yechim 2: tekshiruvchini argument sifatida uzating — shunda T haqiqatan bog'lanadi

async function yukla<T>(
  url: string,
  tekshir: (x: unknown) => x is T // type predicate
): Promise<T> {
  const data: unknown = await (await fetch(url)).json();
  if (!tekshir(data)) {
    throw new Error(`${url}: kutilmagan javob shakli`);
  }
  return data; // ✅ data: T — tekshiruv isbotladi
}

const u = await yukla("/api/profil", foydalanuvchimi); // T = Foydalanuvchi, argumentdan chiqarildi

Endi T argumentda ham, qaytish type'ida ham bor. TS uni <Foydalanuvchi> yozilmasa ham o'zi aniqlaydi va har bir javob runtime'da tekshiriladi.

Esda tuting: generic T kirish va chiqishni bog'lash uchun kerak. Agar u faqat qaytish type'ida bo'lsa — bu tekshiruvsiz as, ma'lumotni baribir runtime'da tekshirish kerak.