Series: TypeScript Basics Lesson 44

Equality-based narrowing

TypeScript'da tenglik orqali narrowing: literal qiymat bilan ===, !== va else, switch, ikki o'zgaruvchini solishtirish, == null va .includes() narrowing bermasligi.

44-dars

Equality-based narrowing

Ko'p qiymatlar cheklangan variantlardan birini oladi: buyurtma holati, tarif nomi, foydalanuvchi roli. Ularni oddiy string bilan saqlasak, xato yozilgan qiymat jimgina hech qachon mos kelmaydi:

// ❌ string — har qanday matn "to'g'ri"
function oylikNarx(tarif: string): number {
  if (tarif === "bepul") return 0;
  if (tarif === "Pro") return 99_000; // 🐛 aslida "pro" kichik harf bilan keladi
  return 299_000;
}

oylikNarx("pro"); // 299 000 — pro foydalanuvchi biznes narxini to'laydi

Literal union va === birga ishlaganda, TS ham xatoni ushlaydi, ham har bir tarmoqda type'ni toraytiradi:

// ✅ Literal union + ===
type Tarif = "bepul" | "pro" | "biznes";

function oylikNarx(tarif: Tarif): number {
  if (tarif === "Pro") return 99_000;
  // ❌ This comparison appears to be unintentional because the types 'Tarif' and '"Pro"' have no overlap.

  if (tarif === "bepul") return 0;    // tarif: "bepul"
  if (tarif === "pro") return 99_000; // tarif: "pro"
  return 299_000;                     // tarif: "biznes" — yagona qolgan variant
}

Qanday ishlaydi?

1. Literal qiymat bilan ===

Aniq qiymat bilan solishtirilganda, true tarmog'ida o'zgaruvchi type'i shu qiymatning literal type'iga torayadi:

type Javob = "ha" | "yo'q" | null;

function tasdiqla(j: Javob) {
  if (j === "ha") {
    j; // "ha"
  } else {
    j; // "yo'q" | null
  }
}

Bu nafaqat string'lar uchun: === 0, === true, === undefined ham xuddi shunday ishlaydi.

2. !== va else — qolgan variantlar

Chiqarib tashlash usuli guard clause bilan yaxshi ishlaydi:

type Holat = "yangi" | "jarayonda" | "yetkazildi" | "bekor";

function bekorQilishMumkinmi(h: Holat): boolean {
  if (h === "yetkazildi" || h === "bekor") {
    return false;
  }
  h; // "yangi" | "jarayonda"
  return true;
}

3. switch ham === bilan ishlaydi

Har bir case aslida === solishtiruvi, shuning uchun narrowing har bir case ichida ishlaydi. Mavjud bo'lmagan case ham xato beradi:

function rang(h: Holat): string {
  switch (h) {
    case "yangi":
      return "ko'k";    // h: "yangi"
    case "jarayonda":
      return "sariq";   // h: "jarayonda"
    case "yetkazilgan":
      // ❌ Type '"yetkazilgan"' is not comparable to type 'Holat'.
      return "yashil";
    default:
      return "kulrang"; // h: "yetkazildi" | "bekor"
  }
}

4. Ikki o'zgaruvchini bir-biri bilan solishtirish

Ikkala o'zgaruvchi teng bo'lsa, ular faqat umumiy type'da bo'lishi mumkin. TS ikkalasini ham shu umumiy qismga toraytiradi:

function solishtir(a: string | number, b: string | boolean) {
  if (a === b) {
    // ikkalasining yagona umumiy type'i — string
    a.toUpperCase(); // a: string
    b.toUpperCase(); // b: string
  }
}

Amalda ko'pincha null bo'lishi mumkin bo'lgan qiymatni aniq qiymat bilan solishtirganda uchraydi:

function tanlanganmi(id: string, tanlangan: string | null) {
  if (id === tanlangan) {
    tanlangan; // string — null id'ga teng bo'la olmaydi
  }
}

5. == null — null va undefined'ni birdaniga chiqaradi

Odatda === tavsiya qilinadi, lekin == null bitta foydali istisno: u ham null, ham undefined uchun true qaytaradi:

function ismChiqar(ism: string | null | undefined) {
  if (ism != null) {
    ism.trim(); // ism: string — ikkalasi ham chiqib ketdi
  }
}
Tekshiruv null undefined Natija type'i (string | null | undefined uchun)
x !== null chiqadi qoladi string | undefined
x !== undefined qoladi chiqadi string | null
x != null chiqadi chiqadi string ✅

Shu bilan birga 0 va "" chiqib ketmaydi. Truthiness tekshiruvidan (if (x)) farqi shunda.

Eng ko'p uchraydigan xato

.includes() bilan tekshirib, narrowing kutish. Ruxsat etilgan qiymatlar ro'yxati bor va URL yoki formadan kelgan string'ni tekshirmoqchisiz:

type Rol = "admin" | "muharrir" | "oquvchi";

const ROLLAR: Rol[] = ["admin", "muharrir", "oquvchi"];

function rolOrnat(kirish: string) {
  if (ROLLAR.includes(kirish)) {
    // ❌ Argument of type 'string' is not assignable to parameter of type 'Rol'.
    saqlash(kirish);
  }
}

function saqlash(rol: Rol) { /* ... */ }

Nega bunday bo'ladi? Ikki sabab bor. Birinchidan, Rol[]'ning includes metodi faqat Rol qabul qiladi, string emas. Ikkinchidan, xato bo'lmagan holatda ham .includes() oddiy metod, === emas. TS uning true qaytarishidan kirish haqida xulosa chiqarmaydi va kirish stringligicha qoladi.

Ko'pchilik buni as bilan "yopadi":

if (ROLLAR.includes(kirish as Rol)) {
  saqlash(kirish as Rol); // ishlaydi, lekin ikki marta TS'ga "ishon" deyildi
}

✅ Yechim 1: variantlar kam bo'lsa — to'g'ridan-to'g'ri ===

function rolOrnat(kirish: string) {
  if (kirish === "admin" || kirish === "muharrir" || kirish === "oquvchi") {
    saqlash(kirish); // ✅ kirish: Rol
  }
}

✅ Yechim 2: switch — o'qilishi oson, har bir rolga alohida mantiq qo'shish mumkin

function rolOrnat(kirish: string) {
  switch (kirish) {
    case "admin":
    case "muharrir":
    case "oquvchi":
      saqlash(kirish); // ✅ kirish: Rol
      break;
    default:
      console.warn(`Noma'lum rol: ${kirish}`);
  }
}

Ro'yxat katta bo'lsa yoki bu tekshiruv ko'p joyda kerak bo'lsa, uni qayta ishlatiladigan isRol(x): x is Rol funksiyasiga chiqarish mumkin.

Esda tuting: narrowing'ni ===, !== va switch beradi, .includes() esa faqat true/false qaytaradi va type'ni o'zgartirmaydi.