Series: TypeScript Basics Lesson 45

Discriminated union

TypeScript'da discriminated union: imkonsiz holatlarni yo'qotish, uch tarkibiy qism, boolean discriminant, in operatoridan farqi, error-first callback'ni almashtirish va discriminant'ning string'ga kengayishi.

45-dars

Discriminated union

Ma'lumot yuklash holatini ko'pincha shunday yozishadi: hamma maydonlar bitta obyektda, ko'pi ixtiyoriy:

// ❌ Hamma narsa optional — imkonsiz holatlar ham "to'g'ri"
type Sorov = {
  yuklanmoqda: boolean;
  data?: string[];
  xato?: string;
};

const s1: Sorov = { yuklanmoqda: true, data: ["Ali"], xato: "Timeout" }; // 🐛 ham yuklanmoqda, ham data, ham xato?
const s2: Sorov = { yuklanmoqda: false };                               // 🐛 tugadi, lekin na data, na xato

function korsat(s: Sorov) {
  if (!s.yuklanmoqda && !s.xato) {
    return s.data!.join(", "); // s2 uchun 💥 TypeError: Cannot read properties of undefined
  }
}

TS bu yerda yordam bera olmaydi: yuklanmoqda: false bo'lsa ham data bor-yo'qligini bilmaydi. Natijada ! paydo bo'ladi.

Discriminated union har bir holatni alohida variant qilib yozadi va ularni bitta umumiy kalit bilan ajratadi:

// ✅ Har bir holat — o'z maydonlari bilan
type Sorov =
  | { holat: "yuklanmoqda" }
  | { holat: "muvaffaqiyat"; data: string[] }
  | { holat: "xato"; xabar: string };

function korsat(s: Sorov): string {
  if (s.holat === "yuklanmoqda") return "Kuting...";
  if (s.holat === "xato") return `Xato: ${s.xabar}`; // s: { holat: "xato"; xabar: string }
  return s.data.join(", ");                           // s: { holat: "muvaffaqiyat"; data: string[] }
}

const s1: Sorov = { holat: "yuklanmoqda", data: ["Ali"] };
// ❌ Object literal may only specify known properties, and 'data' does not exist in type '{ holat: "yuklanmoqda"; }'.

Endi imkonsiz holatni yaratib bo'lmaydi, ! ham kerak emas.

Qanday ishlaydi?

1. Uch tarkibiy qism

Discriminated union bo'lishi uchun:

  1. Bir nechta obyekt type'idan iborat union;
  2. Har bir variantda bir xil nomli kalit (discriminant): holat, type, kind va h.k.;
  3. Bu kalitning type'i har variantda boshqa literal.
type Shakl =
  | { tur: "doira"; radius: number }
  | { tur: "tortburchak"; eni: number; boyi: number }
  | { tur: "uchburchak"; asos: number; balandlik: number };

Discriminant === yoki switch bilan tekshirilganda, TS butun obyektni mos variantga toraytiradi:

function yuza(s: Shakl): number {
  switch (s.tur) {
    case "doira":
      return Math.PI * s.radius ** 2;    // faqat radius mavjud
    case "tortburchak":
      return s.eni * s.boyi;             // faqat eni, boyi
    case "uchburchak":
      return (s.asos * s.balandlik) / 2; // faqat asos, balandlik
  }
}

2. Discriminant faqat string bo'lishi shart emas

boolean va number literal'lari ham ishlaydi. Ikki variant uchun ok: true | false juda qulay:

type Saqlash =
  | { ok: true; id: number }
  | { ok: false; sabab: string };

function xabar(n: Saqlash): string {
  if (n.ok) {
    return `Saqlandi, id: ${n.id}`; // n: { ok: true; id: number }
  }
  return `Saqlanmadi: ${n.sabab}`;  // n: { ok: false; sabab: string }
}

if (n.ok) — truthiness tekshiruvi, lekin ok faqat true yoki false bo'lishi mumkinligi uchun TS uni ham narrowing deb tushunadi.

3. Nega in operatoridan ishonchliroq

"radius" in s bilan ham obyektlarni ajratgan edik. Lekin in "bu maydon obyektda bormi?" deb so'raydi, discriminant esa "bu obyekt qaysi variant?" deb so'raydi. Farq optional maydonlar paydo bo'lganda ko'rinadi:

type Doira = { radius: number };
type Kvadrat = { tomon: number; radius?: number }; // burchak yumaloqligi uchun

function hisobla(s: Doira | Kvadrat) {
  if ("radius" in s) {
    s;       // Doira | Kvadrat — Kvadrat ham radius'ga ega bo'lishi mumkin
    s.tomon; // ❌ Property 'tomon' does not exist on type 'Doira | Kvadrat'.
  }
}

TS'da obyekt type'lari strukturaviy: type'da yozilmagan qo'shimcha maydon ham obyektda bo'lishi mumkin. Shu sababli in faqat taxminiy ajratadi.

in operatori Discriminant
Nimani tekshiradi Maydon borligini Variant nomini
Optional maydonlar bilan chalkashadi ta'sir qilmaydi
Xato yozilgan qiymat sezilmaydi darhol xato
Yangi variant qo'shilganda qo'lda qidirish kerak exhaustive check yordam beradi

in hali ham foydali: tashqi kutubxona type'larini o'zgartira olmasangiz yoki discriminant yo'q bo'lsa.

4. Error-first callback muammosi hal bo'ladi

Node.js uslubidagi callback'da err va data bir-biriga bog'lanmaganini ko'rgan edik:

// ❌ Ikki alohida parametr — TS ular orasidagi aloqani bilmaydi
function oqi(callback: (err: Error | null, data?: string) => void) { /* ... */ }

oqi((err, data) => {
  if (err) return console.error(err);
  data.toUpperCase();
  // ❌ 'data' is possibly 'undefined'.
});

err tekshirilgandan keyin ham data — string | undefined. Chunki type'da "err bo'lmasa data albatta bor" degan qoida yo'q. Ikkalasini bitta discriminated union'ga birlashtiramiz:

// ✅ Bitta parametr — ikki holat aniq ajratilgan
type OqishNatijasi =
  | { ok: false; xato: Error }
  | { ok: true; data: string };

function oqi(callback: (natija: OqishNatijasi) => void) { /* ... */ }

oqi((natija) => {
  if (!natija.ok) return console.error(natija.xato);
  natija.data.toUpperCase(); // ✅ data: string
});

Eng ko'p uchraydigan xato

Obyektni avval o'zgaruvchiga saqlab, keyin uzatish — discriminant stringga kengayadi.

type Bildirishnoma =
  | { tur: "muvaffaqiyat"; matn: string }
  | { tur: "xato"; matn: string; qaytaUrinish: () => void };

function korsat(b: Bildirishnoma) { /* ... */ }

korsat({ tur: "muvaffaqiyat", matn: "Saqlandi" }); // ✅ to'g'ridan-to'g'ri — ishlaydi

const b = { tur: "muvaffaqiyat", matn: "Saqlandi" };
korsat(b);
// ❌ Argument of type '{ tur: string; matn: string; }' is not assignable to parameter of type 'Bildirishnoma'.

Nega bunday bo'ladi? const b = {...} yozilganda TS obyekt type'ini o'zi chiqaradi. Obyekt maydonlarini keyinchalik o'zgartirish mumkin (b.tur = "boshqa"), shuning uchun TS "muvaffaqiyat"'ni literal emas, keng string deb oladi. string esa hech bir variantning discriminant'iga mos kelmaydi. To'g'ridan-to'g'ri uzatilganda TS kutilgan type'ni ko'radi va literal'ni saqlaydi.

Ko'pincha bu xatoni as bilan "yopishadi": korsat(b as Bildirishnoma). Shunda tur: "xato" bo'lib, qaytaUrinish unutilgan obyekt ham o'tib ketadi 🐛, keyin b.qaytaUrinish() chaqirilganda 💥 TypeError: b.qaytaUrinish is not a function.

✅ Yechim 1: o'zgaruvchiga type yozing (eng yaxshi usul)

const b: Bildirishnoma = { tur: "muvaffaqiyat", matn: "Saqlandi" };
korsat(b); // ✅

const x: Bildirishnoma = { tur: "xato", matn: "Tarmoq uzildi" };
// ❌ Property 'qaytaUrinish' is missing in type '{ tur: "xato"; matn: string; }' but required in type '{ tur: "xato"; matn: string; qaytaUrinish: () => void; }'.

Annotation literal'ni saqlaydi va har bir variantning majburiy maydonlarini ham tekshiradi.

✅ Yechim 2: funksiya qaytarsa, return type yozing

function saqlandi(): Bildirishnoma {
  return { tur: "muvaffaqiyat", matn: "Saqlandi" }; // ✅ literal saqlanadi
}

Esda tuting: discriminated union'ga tegishli obyektni o'zgaruvchida yaratsangiz, o'zgaruvchiga union type'ini yozing, aks holda discriminant stringga aylanadi.