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.