Seriya: TypeScript Basics Dars 49

Exhaustiveness checking

TypeScript'da exhaustiveness checking: union'ning barcha variantlari qayta ishlanganini tekshirish, oxirida never, return type usuli, never o'zgaruvchi usuli va else/default yangi variantlarni yutib yuborishi.

49-dars

Exhaustiveness checking

Union bilan ishlaydigan kod odatda har bir variantni alohida qayta ishlaydi. Muammo keyin, union'ga yangi variant qo'shilganda chiqadi:

type Yetkazish = "pochta" | "ekspress" | "olib_ketish";

// ❌ Oxirgi variant "qolgan hammasi" deb yozilgan
function yetkazishNarxi(t: Yetkazish): number {
  if (t === "pochta") return 15_000;
  if (t === "ekspress") return 40_000;
  return 0; // olib_ketish — bepul
}

Yarim yildan keyin boshqa dasturchi "kuryer" variantini qo'shadi:

type Yetkazish = "pochta" | "ekspress" | "olib_ketish" | "kuryer";

yetkazishNarxi("kuryer"); // 0 🐛 kuryer xizmati bepul bo'lib qoldi, TS indamadi

Exhaustiveness checking — "union'ning barcha variantlari qayta ishlanganmi?" degan savolni TS'ga tekshirtirish. To'g'ri yozilgan kodda yangi variant qo'shilishi bilan TS uni qayta ishlash kerak bo'lgan har bir joyni ko'rsatadi:

// ✅ Har bir variant ochiq tekshiriladi, return type yozilgan
function yetkazishNarxi(t: Yetkazish): number {
  // ❌ Function lacks ending return statement and return type does not include 'undefined'.
  if (t === "pochta") return 15_000;
  if (t === "ekspress") return 40_000;
  if (t === "olib_ketish") return 0;
  // "kuryer" qayta ishlanmagan — TS shu funksiyani ko'rsatadi
}

"kuryer" uchun qator qo'shilishi bilan xato yo'qoladi.

Qanday ishlaydi?

1. Har bir tekshiruv union'ni kichraytiradi, oxirida never qoladi

Control-flow analysis har return'dan keyin qolgan variantlarni hisoblaydi. Barcha variantlar tugagach, hech qanday qiymat qolmaydi. TS buni never deb belgilaydi:

function belgi(t: Yetkazish) {
  t; // "pochta" | "ekspress" | "olib_ketish" | "kuryer"
  if (t === "pochta") return "📮";
  t; // "ekspress" | "olib_ketish" | "kuryer"
  if (t === "ekspress") return "⚡";
  t; // "olib_ketish" | "kuryer"
  if (t === "olib_ketish") return "🏪";
  t; // "kuryer"
  if (t === "kuryer") return "🛵";
  t; // never — bu nuqtaga hech qanday qiymat yetib kela olmaydi
}

Exhaustiveness checking'ning butun g'oyasi shunda: "oxirgi nuqtada type never bo'lishi kerak". never bo'lmasa, qandaydir variant e'tibordan chetda qolgan.

2. 1-usul: qaytish type'ini yozish

Funksiya qiymat qaytarsa, eng oddiy usul — qaytish type'ini qo'lda yozish (26-dars). Agar oxiriga qandaydir variant yetib kelsa, funksiya undefined qaytaradi. Bu esa yozilgan type'ga mos kelmaydi:

function vaqt(t: Yetkazish): string {
  // ❌ Function lacks ending return statement and return type does not include 'undefined'.
  if (t === "pochta") return "3–5 kun";
  if (t === "ekspress") return "1 kun";
  if (t === "olib_ketish") return "bugun";
}

Qaytish type'i yozilmasa, TS uni string | undefined deb chiqaradi va bu yerda xato bermaydi. Shuning uchun exhaustiveness uchun return type annotation muhim.

3. 2-usul: qolgan qiymatni never o'zgaruvchiga berish

Funksiya hech narsa qaytarmasa (masalan, faqat log yozsa yoki UI'ni yangilasa), 1-usul ishlamaydi. Bunda qolgan qiymatni never type'li o'zgaruvchiga berib ko'ramiz. Agar haqiqatan hech narsa qolmagan bo'lsa, never'ga never berish xato emas:

function logYoz(t: Yetkazish): void {
  if (t === "pochta") {
    console.log("Pochta bo'limiga yuborildi");
  } else if (t === "ekspress") {
    console.log("Ekspress kuryer chaqirildi");
  } else if (t === "olib_ketish") {
    console.log("Do'konda kutilmoqda");
  } else {
    const tekshiruv: never = t;
    // ❌ Type '"kuryer"' is not assignable to type 'never'.
  }
}

Xato xabarida aynan qaysi variant unutilgani ko'rinadi. Bu usulni switch bilan qayta ishlatiladigan funksiyaga aylantirish mumkin.

4. Qaysi usul qachon

Usul Qachon ishlaydi Xato xabari unutilgan variantni ko'rsatadimi
Return type yozish Funksiya qiymat qaytarsa ❌ faqat "return yetishmaydi"
const x: never = t Har qanday kod ✅ '"kuryer"' deb nomini aytadi
else / default "qolgan hammasi" — ❌ tekshiruv umuman yo'q 🐛

Discriminated union'larda ham xuddi shunday ishlaydi: s.tur bo'yicha tekshirilganda oxirida s type'i never bo'ladi.

Eng ko'p uchraydigan xato

else yoki default bilan "qolgan hamma holat" deb yozish.

type Holat = "yangi" | "tolangan" | "yuborildi" | "bekor";

function holatRangi(h: Holat): string {
  switch (h) {
    case "yangi":
      return "ko'k";
    case "tolangan":
      return "yashil";
    default:
      return "kulrang"; // yuborildi va bekor
  }
}

Keyinchalik "qaytarildi" holati qo'shiladi. Mijozga pul qaytarilganini darhol ko'rsatish kerak, lekin kod hech qanday xato bermaydi, yangi holat default'ga tushadi va kulrang ko'rinadi 🐛.

Nega bunday bo'ladi? default (yoki oxirgi else) TS uchun "bu yerda har qanday qolgan variant bo'lishi mumkin, bu normal" degani. U yangi variantni ham "qolganlar" qatoriga qo'shadi. Natijada TS xato ko'rsatishi uchun hech qanday sabab qolmaydi: barcha yo'llar return bilan tugaydi, type'lar mos keladi. Bu "hozir ishlaydigan, lekin kelajakda jimgina buziladigan" kod.

✅ Yechim 1: har bir variantni ochiq yozing, default'ni olib tashlang

function holatRangi(h: Holat): string {
  // "qaytarildi" qo'shilgandan keyin:
  // ❌ Function lacks ending return statement and return type does not include 'undefined'.
  switch (h) {
    case "yangi":
      return "ko'k";
    case "tolangan":
      return "yashil";
    case "yuborildi":
    case "bekor":
      return "kulrang";
  }
}

Bir xil natija beradigan variantlar case qatorlarini ketma-ket yozib birlashtiriladi. "Qolgan hammasi" kerak bo'lmaydi.

✅ Yechim 2: default kerak bo'lsa — uni never tekshiruviga aylantiring

function holatRangi(h: Holat): string {
  switch (h) {
    case "yangi":
      return "ko'k";
    case "tolangan":
      return "yashil";
    case "yuborildi":
    case "bekor":
      return "kulrang";
    default: {
      const tekshiruv: never = h;
      // "qaytarildi" qo'shilgandan keyin:
      // ❌ Type '"qaytarildi"' is not assignable to type 'never'.
      return "kulrang";
    }
  }
}

Esda tuting: else va default yangi variantlarni jimgina "yutib yuboradi", shuning uchun union'ning har bir variantini ochiq yozing va oxirgi nuqtada type never ekanini TS'ga tekshirting.