Generic interface va type alias'lar
TypeScript'da generic interface va type alias'lar: bitta umumiy tuzilma, default type parametr, constraint, generic'larni joylash, interface va metod darajasidagi generic, generic union va type argumentni any bilan to'ldirish xatosi.
58-dars
Generic interface va type alias'lar
API'dan keladigan javoblar odatda bir xil "qobiq"ga ega, faqat ichidagi ma'lumot har xil. Misollarda quyidagi type'lardan foydalanamiz:
type Mahsulot = { nomi: string; narx: number; omborda: boolean };
type Foydalanuvchi = { id: number; ism: string };
type Buyurtma = { id: string; summa: number };
Generic'siz har bir holat uchun alohida interface yoziladi:
// ❌ Muammo: bir xil tuzilma, faqat data type'i farq qiladi
interface MahsulotJavob {
muvaffaqiyat: boolean;
xabar: string;
data: Mahsulot;
}
interface FoydalanuvchiJavob {
muvaffaqiyat: boolean;
xabar: string;
data: Foydalanuvchi;
}
interface BuyurtmalarJavob {
muvaffaqiyat: boolean;
xabar: string;
data: Buyurtma[];
}
// ... va hokazo, har bir endpoint uchun
Backend javobga vaqt maydonini qo'shsa — barcha interface'larni topib, bittalab yangilash kerak. Bittasi esdan chiqsa, 🐛 TS hech narsa demaydi, chunki ular bir-biriga bog'lanmagan.
// ✅ Yechim: bitta generic interface
interface ApiJavob<T> {
muvaffaqiyat: boolean;
xabar: string;
data: T;
}
type MahsulotJavob = ApiJavob<Mahsulot>;
type FoydalanuvchiJavob = ApiJavob<Foydalanuvchi>;
type BuyurtmalarJavob = ApiJavob<Buyurtma[]>;
Tuzilma bitta joyda, o'zgaruvchan qism esa T orqali beriladi.
Qanday ishlaydi?
1. Asosiy sintaksis
Type parametr interface nomidan keyin yoziladi va ichida oddiy type kabi ishlatiladi:
interface Quti<T> {
qiymat: T;
yaratilgan: Date;
}
const narxQuti: Quti<number> = { qiymat: 85000, yaratilgan: new Date() };
const nomQuti: Quti<string> = { qiymat: "Choynak", yaratilgan: new Date() };
const xato: Quti<number> = { qiymat: "arzon", yaratilgan: new Date() };
// ❌ Type 'string' is not assignable to type 'number'.
Funksiyalardan farqli o'laroq, interface'da T infer qilinmaydi — type annotatsiyada uni doim yozish kerak.
2. Default type parametr
ApiJavob<T = null> misolini 53-darsda ko'rgan edik: ba'zi so'rovlar (masalan, o'chirish) hech qanday ma'lumot qaytarmaydi. Default qiymat shu holatni qisqa yozishga imkon beradi:
interface ApiJavob<T = null> {
muvaffaqiyat: boolean;
xabar: string;
data: T;
}
// DELETE /mahsulotlar/5 — ma'lumot yo'q
const ochirildi: ApiJavob = {
muvaffaqiyat: true,
xabar: "O'chirildi",
data: null, // T = null
};
// GET /mahsulotlar/5
const topildi: ApiJavob<Mahsulot> = {
muvaffaqiyat: true,
xabar: "",
data: { nomi: "Choynak", narx: 85000, omborda: true },
};
3. Constraint bilan
T'ga talab qo'yish mumkin — T extends { id: unknown } kabi:
interface Jadval<T extends { id: number | string }> {
qatorlar: T[];
tanlangan: T["id"] | null; // indexed access (56-dars)
}
const j1: Jadval<Foydalanuvchi> = { qatorlar: [], tanlangan: 5 }; // ✅
const j2: Jadval<Buyurtma> = { qatorlar: [], tanlangan: "a1b2" }; // ✅
const j3: Jadval<string> = { qatorlar: [], tanlangan: null };
// ❌ Type 'string' does not satisfy the constraint '{ id: string | number; }'.
4. Generic interface'larni bir-biriga joylash
Generic interface'lar "konstruktor" bo'laklaridek birlashadi:
interface Sahifa<T> {
elementlar: T[];
jami: number;
joriySahifa: number;
}
// GET /mahsulotlar?sahifa=2
type MahsulotlarSahifasi = ApiJavob<Sahifa<Mahsulot>>;
function korsat(javob: MahsulotlarSahifasi) {
javob.data.elementlar[0].narx; // number ✅
javob.data.jami; // number ✅
}
ApiJavob sahifalash haqida, Sahifa esa API haqida hech narsa bilmaydi — har biri o'z vazifasini bajaradi.
5. Interface darajasidagi va metod darajasidagi generic
Interface ichidagi metodlar ikki xil generic ishlatishi mumkin:
interface Ombor<T> {
qosh(element: T): void; // T — interface'dan, butun Ombor uchun bitta
hammasi(): T[];
ozgartir<U>(f: (x: T) => U): U[]; // U — har bir chaqiruvda yangidan
}
declare const mahsulotOmbori: Ombor<Mahsulot>;
mahsulotOmbori.qosh({ nomi: "Piyola", narx: 12000, omborda: true }); // ✅
mahsulotOmbori.ozgartir((m) => m.nomi); // string[]
mahsulotOmbori.ozgartir((m) => m.narx); // number[]
| Qayerda | Qachon aniqlanadi | Misol |
|---|---|---|
interface Ombor<T> |
Type yozilganda: Ombor<Mahsulot> |
Saqlanadigan element |
ozgartir<U>(...) |
Har bir metod chaqiruvida | Natija type'i |
6. Generic type alias — union kerak bo'lganda
ApiJavob<T>'ni generic interface sifatida yozdik. Lekin real API javobi ikki xil bo'ladi: muvaffaqiyatli (ma'lumot bilan) yoki xato (xabar bilan). Interface bilan buni ifodalashga urinsak:
// ❌ Muammo: bitta interface'da ikkala holat aralash
interface ApiJavob<T> {
muvaffaqiyat: boolean;
data?: T;
xato?: string;
}
function korsat(javob: ApiJavob<Mahsulot>) {
if (javob.muvaffaqiyat) {
console.log(javob.data.nomi);
// ❌ 'javob.data' is possibly 'undefined'.
}
}
// Mantiqan imkonsiz holatlarga ham ruxsat bor:
const galati: ApiJavob<Mahsulot> = { muvaffaqiyat: false }; // xato xabari yo'q
// 🐛 TS indamaydi: na data, na xato — UI nima ko'rsatsin?
Interface faqat bitta obyekt shaklini tasvirlaydi. Bizga esa "yo u, yo bu" kerak — ya'ni generic union. Buni faqat type alias qila oladi:
// ✅ Yechim: generic type alias + discriminated union (45-dars)
type ApiJavob<T> =
| { muvaffaqiyat: true; data: T }
| { muvaffaqiyat: false; xato: string };
function korsat(javob: ApiJavob<Mahsulot>) {
if (javob.muvaffaqiyat) {
console.log(javob.data.nomi); // ✅ data aniq bor
} else {
console.error(javob.xato); // ✅ xato aniq bor
}
}
const galati: ApiJavob<Mahsulot> = { muvaffaqiyat: false };
// ❌ Property 'xato' is missing in type '{ muvaffaqiyat: false; }' but required in type '{ muvaffaqiyat: false; xato: string; }'.
Endi imkonsiz holatlar type darajasida taqiqlangan.
| Generic interface | Generic type alias | |
|---|---|---|
| Bitta obyekt shakli | ✅ | ✅ |
| Union ("yo u, yo bu") | ❌ | ✅ |
| Declaration merging | ✅ | ❌ |
Eng ko'p uchraydigan xato
Type argumentni any bilan "tinchitish". Generic interface default'siz bo'lsa, type argumentsiz yozib bo'lmaydi:
interface ApiJavob<T> {
muvaffaqiyat: boolean;
xabar: string;
data: T;
}
function javobniLogla(javob: ApiJavob) {
// ❌ Generic type 'ApiJavob' requires 1 type argument(s).
}
Shoshilganda eng oson "yechim" — any:
declare const foydalanuvchiJavobi: ApiJavob<Foydalanuvchi>;
function narxlarniYig(javob: ApiJavob<any>) {
return javob.data.reduce((s: number, m: any) => s + m.narx, 0);
}
narxlarniYig(foydalanuvchiJavobi); // 🐛 TS indamaydi
// 💥 TypeError: javob.data.reduce is not a function — data obyekt, massiv emas
Nega bunday bo'ladi? Xato xabari "bu yerda qanday T?" deb so'rayapti. any bu savolga javob bermaydi, balki tekshiruvni o'chiradi. Natijada ApiJavob<any> qabul qiladigan funksiyaga istalgan javobni berish mumkin — butun generic interface foydasiz bo'lib qoladi.
✅ Yechim 1: funksiya aniq type bilan ishlasa — uni yozing:
function narxlarniYig(javob: ApiJavob<Mahsulot[]>) {
return javob.data.reduce((s, m) => s + m.narx, 0); // ✅ m: Mahsulot
}
✅ Yechim 2: funksiya data'ga tegmasa — uni ham generic qiling:
function javobniLogla<T>(javob: ApiJavob<T>) {
console.log(javob.muvaffaqiyat, javob.xabar); // data ishlatilmaydi
}
✅ Yechim 3: data haqiqatan noma'lum bo'lsa — unknown; ishlatishdan oldin tekshirishga majbur qiladi:
function xavfsizLogla(javob: ApiJavob<unknown>) { /* data'ni tekshirib ishlatish */ }
Esda tuting: Generic type requires 1 type argument(s) xatosi any so'ramaydi — u sizdan qaysi type ekanini so'raydi.