Seriya: TypeScript Basics Dars 50

never bilan exhaustive switch

TypeScript'da assertNever yordamchi funksiyasi: compile va runtime himoyasi, never parametri, discriminated union bilan ishlatish, uch usulni solishtirish va string ustida switch'ni as never bilan yopish xatosi.

50-dars

never bilan exhaustive switch

default ichida const tekshiruv: never = h yozib, unutilgan variantni TS'ga topdirgan edik. Bu usulning ikki kamchiligi bor:

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

function holatMatni(h: Holat): string {
  switch (h) {
    case "yangi":
      return "Yangi buyurtma";
    case "tolangan":
      return "To'landi";
    case "yuborildi":
      return "Yo'lda";
    default: {
      const tekshiruv: never = h;
      return tekshiruv; // ❌ 1) har safar shu ikki qatorni takrorlash
    }
  }
}

// ❌ 2) Faqat compile vaqtida himoya qiladi.
// Server yangi "qaytarildi" holatini yuborsa (frontend hali yangilanmagan):
holatMatni(serverdanKelgan.holat); // "qaytarildi" 🐛 sahifada tarjima qilinmagan xom qiymat chiqadi

TS type'lari runtime'da yo'q. Tashqaridan kutilmagan qiymat kelsa, default hech narsa qilmaydi. Yechim — bitta kichik yordamchi funksiya. U compile vaqtida ham, runtime'da ham himoya qiladi:

// ✅ Bir marta yoziladi, butun loyihada ishlatiladi
function assertNever(qiymat: never): never {
  throw new Error(`Kutilmagan qiymat: ${JSON.stringify(qiymat)}`);
}

function holatMatni(h: Holat): string {
  switch (h) {
    case "yangi":
      return "Yangi buyurtma";
    case "tolangan":
      return "To'landi";
    case "yuborildi":
      return "Yo'lda";
    default:
      return assertNever(h);
  }
}

holatMatni(serverdanKelgan.holat);
// server "qaytarildi" yuborsa:
// 💥 Error: Kutilmagan qiymat: "qaytarildi" — xato aniq joyda va aniq xabar bilan

Qanday ishlaydi?

1. Parametr type'i never — faqat "hech narsa" qabul qiladi

never type'iga hech qanday qiymat sig'maydi. Shuning uchun assertNever(h) faqat h type'i never bo'lgandagina, ya'ni barcha variantlar case'larda qayta ishlangandagina, xatosiz kompilyatsiya bo'ladi:

type Holat = "yangi" | "tolangan" | "yuborildi" | "qaytarildi"; // yangi variant

function holatMatni(h: Holat): string {
  switch (h) {
    case "yangi":
      return "Yangi buyurtma";
    case "tolangan":
      return "To'landi";
    case "yuborildi":
      return "Yo'lda";
    default:
      return assertNever(h);
      // ❌ Argument of type '"qaytarildi"' is not assignable to parameter of type 'never'.
  }
}

Loyihada assertNever qidirilsa, yangi variant qo'shilganda yangilanishi kerak bo'lgan barcha switch'lar topiladi.

2. return assertNever(h) — har qanday funksiyada

return assertNever(h) istalgan qaytish type'li funksiyada ishlaydi, chunki never har qanday type'ga sig'adi. TS default'dan keyin kod davom etmasligini biladi, shuning uchun "lacks ending return statement" xatosi chiqmaydi.

3. Discriminated union bilan

Discriminated union'larda switch discriminant bo'yicha, assertNever esa obyektning o'zi bilan chaqiriladi. Xato xabarida unutilgan variantning butun shakli ko'rinadi:

type Tolov =
  | { usul: "naqd" }
  | { usul: "karta"; kartaRaqami: string }
  | { usul: "click"; telefon: string };

function tolovIzohi(t: Tolov): string {
  switch (t.usul) {
    case "naqd":
      return "Naqd pul";
    case "karta":
      return `Karta: **** ${t.kartaRaqami.slice(-4)}`;
    default:
      return assertNever(t);
      // ❌ Argument of type '{ usul: "click"; telefon: string; }' is not assignable to parameter of type 'never'.
  }
}

4. Uch usulni solishtirish

default ichida Compile vaqtida unutilgan variant Runtime'da kutilmagan qiymat
return "boshqa" ❌ sezilmaydi jimgina noto'g'ri natija 🐛
const x: never = h ✅ jimgina noto'g'ri natija 🐛
return assertNever(h) ✅ aniq xabarli xato 💥

Tashqi ma'lumot tez-tez yangi qiymat olib kelishi mumkin bo'lsa, bu qiymatni switch'gacha, ma'lumot kirib keladigan joyda tekshirgan ma'qul. Shunda assertNever faqat haqiqiy bug'larda ishlaydi.

Eng ko'p uchraydigan xato

Union o'rniga string ustida switch qilish, keyin as never bilan "tuzatish". Server javobining type'i shunday yozilgan:

type Buyurtma = { id: number; holat: string }; // API'dan "qanday bo'lsa shunday"

function holatMatni(b: Buyurtma): string {
  switch (b.holat) {
    case "yangi":
      return "Yangi buyurtma";
    case "tolangan":
      return "To'landi";
    case "yuborildi":
      return "Yo'lda";
    default:
      return assertNever(b.holat);
      // ❌ Argument of type 'string' is not assignable to parameter of type 'never'.
  }
}

Hamma case yozilgan, lekin xato baribir chiqadi. Ko'pchilik xatoni shunday "yopadi":

    default:
      return assertNever(b.holat as never); // 🐛 exhaustiveness tekshiruvi butunlay o'chdi

Nega bunday bo'ladi? string — cheksiz variantli type. Uchta case'dan keyin ham "yangi", "tolangan", "yuborildi"'dan boshqa yuzlab string'lar qoladi, type hech qachon never bo'lmaydi. TS bu yerda haqli. as never esa TS'ga yolg'on gapiradi: endi yangi holat qo'shilganda ham xato chiqmaydi. Bu esa assertNever'dan foydalanishdan butun maqsadni yo'qqa chiqaradi.

Xuddi shu muammo literal string'ga kengayganda ham yuz beradi: let holat = "yangi" — type'i string.

✅ Yechim 1: maydon type'ini literal union qiling

type Holat = "yangi" | "tolangan" | "yuborildi";
type Buyurtma = { id: number; holat: Holat };

function holatMatni(b: Buyurtma): string {
  switch (b.holat) {
    case "yangi":     return "Yangi buyurtma";
    case "tolangan":  return "To'landi";
    case "yuborildi": return "Yo'lda";
    default:          return assertNever(b.holat); // ✅ b.holat: never
  }
}

✅ Yechim 2: serverdan kelgan string'ni chegarada tekshirib, union'ga aylantiring

function holatmi(x: string): x is Holat {
  return x === "yangi" || x === "tolangan" || x === "yuborildi";
}

const xom: { id: number; holat: string } = await javob.json();
if (!holatmi(xom.holat)) {
  throw new Error(`Noma'lum holat: ${xom.holat}`);
}
const buyurtma: Buyurtma = { id: xom.id, holat: xom.holat }; // ✅ holat: Holat

Shunda ilova ichidagi barcha switch'lar aniq union bilan ishlaydi, noma'lum qiymat esa kirish nuqtasidayoq ushlanadi.

Esda tuting: assertNever faqat literal union ustida ishlaydi, string bilan xato bersa, as never yozmang, type'ni union'ga aylantiring.