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.