Seriya: TypeScript Basics Dars 58

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.