Seriya: TypeScript Basics Dars 42

typeof type guard

TypeScript'da typeof type guard: typeof qaytaradigan 8 ta qiymat, else tarmog'idagi qolgan variantlar, qiymat yoki funksiya pattern'i, switch (typeof x), obyektlarni ajrata olmasligi va typeof null === "object" tuzog'i.

42-dars

typeof type guard

Funksiya bir nechta primitive type'ni qabul qilsa (string | number), har bir type bilan boshqacha ishlash kerak bo'ladi. Ba'zi amallar ikkala type uchun ham "ishlaydi", lekin natija har xil chiqadi va TS buni xato deb hisoblamaydi:

// ❌ + operatori string va number uchun boshqa-boshqa ishlaydi
function jamiNarx(narx: string | number, yetkazish: number) {
  return narx + yetkazish;
}

jamiNarx(5000, 1000);   // 6000
jamiNarx("5000", 1000); // "50001000" 🐛 TS indamaydi: string + number ruxsat etilgan

Narx formadan kelganda (input.value doim string) foydalanuvchi 50 001 000 so'm to'lov ko'radi. typeof bilan har bir holatni alohida qayta ishlaymiz:

// ✅ typeof bilan avval type aniqlanadi
function jamiNarx(narx: string | number, yetkazish: number): number {
  if (typeof narx === "string") {
    return Number(narx) + yetkazish; // narx: string
  }
  return narx + yetkazish; // narx: number
}

jamiNarx("5000", 1000); // 6000 ✅

typeof — JS'ning oddiy runtime operatori. TS esa uning natijasini o'qib, type'ni toraytiradi. Shuning uchun u type guard deb ataladi.

Qanday ishlaydi?

1. typeof faqat 8 ta qiymat qaytaradi

typeof x Qachon
"string" string
"number" number (shu jumladan NaN)
"bigint" bigint
"boolean" boolean
"symbol" symbol
"undefined" undefined
"function" funksiya
"object" obyekt, massiv va null ⚠️

TS bu ro'yxatni biladi, shuning uchun xato yozilgan string'ni darhol ushlaydi:

function tekshir(x: string | number) {
  if (typeof x === "strng") {
    // ❌ This comparison appears to be unintentional because the types '"string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"' and '"strng"' have no overlap.
  }
}

2. else tarmog'ida qolgan variantlar qoladi

CFA bu yerda ham ishlaydi: tekshiruv bitta variantni ajratsa, qolgan variantlar elsega yoki return'dan keyingi kodga o'tadi:

function uzunlik(qiymat: string | number | boolean): number {
  if (typeof qiymat === "boolean") {
    return qiymat ? 1 : 0; // boolean
  }
  // bu yerda: string | number

  if (typeof qiymat !== "string") {
    return String(qiymat).length; // number
  }
  return qiymat.length; // string
}

=== ham, !== ham narrowing qiladi. !== bilan "keraksiz variantni chiqarib tashlash" guard clause uchun qulay.

3. "function" — qiymat yoki uni hisoblaydigan funksiya

Kutubxonalarda tez-tez uchraydigan pattern: parametr tayyor qiymat ham, uni qaytaradigan funksiya ham bo'lishi mumkin:

type Sozlama = number | (() => number);

function vaqtOlish(timeout: Sozlama): number {
  if (typeof timeout === "function") {
    return timeout(); // timeout: () => number
  }
  return timeout; // timeout: number
}

vaqtOlish(3000);            // 3000
vaqtOlish(() => 1000 * 60); // 60000

Bu pattern React'ning useState ichida ham bor.

4. switch (typeof x) ham narrowing qiladi

Variantlar ko'p bo'lsa, if zanjiri o'rniga switch o'qilishi osonroq:

function logFormat(qiymat: string | number | bigint | undefined): string {
  switch (typeof qiymat) {
    case "string":
      return `"${qiymat}"`;     // string
    case "number":
      return qiymat.toFixed(2); // number
    case "bigint":
      return `${qiymat}n`;      // bigint
    case "undefined":
      return "(bo'sh)";         // undefined
  }
}

5. typeof obyektlarni bir-biridan ajrata olmaydi

Har qanday obyekt, massiv yoki Date uchun typeof bir xil "object" qaytaradi:

type Natija = string[] | { xato: string };

function korsat(n: Natija) {
  if (typeof n === "object") {
    n; // string[] | { xato: string } — hech narsa toraymadi
  }

  if (Array.isArray(n)) {
    n; // string[] ✅ massiv uchun maxsus tekshiruv
  } else {
    n; // { xato: string }
  }
}
Nimani ajratish kerak Vosita
Primitive'lar (string, number...) typeof
Massiv yoki massiv emas Array.isArray()
Class instance (Date, Error) instanceof
O'zingiz yozgan obyekt type'lari discriminated union, custom guard

Eng ko'p uchraydigan xato

typeof x === "object" tekshiruvi nullni o'tkazib yuboradi. Server javobi yoki localStorage'dan olingan ma'lumot obyekt ekanini tekshirmoqchi bo'lasiz:

type Sozlamalar = { mavzu: string };

function sozlamaniOqi(saqlangan: Sozlamalar | null) {
  if (typeof saqlangan === "object") {
    console.log(saqlangan.mavzu);
    // ❌ 'saqlangan' is possibly 'null'.
  }
}

Nega bunday bo'ladi? JS'ning eski xatosi tufayli typeof null === "object" qaytaradi. TS buni biladi, shuning uchun "object" tekshiruvidan keyin ham nullni type'da qoldiradi. Agar shu xato ! yoki as bilan "o'chirilsa", runtime'da kod qulaydi:

if (typeof saqlangan === "object") {
  console.log(saqlangan!.mavzu); // 💥 TypeError: Cannot read properties of null (reading 'mavzu')
}

unknown bilan ishlaganda ham xuddi shu holat: typeof data === "object" dan keyin data type'i object | null bo'ladi.

✅ Yechim 1: nullni alohida chiqarib tashlang

if (saqlangan !== null && typeof saqlangan === "object") {
  console.log(saqlangan.mavzu); // ✅ Sozlamalar
}

✅ Yechim 2: type'da faqat obyekt va null bo'lsa, typeof umuman kerak emas

if (saqlangan !== null) {
  console.log(saqlangan.mavzu); // ✅ yagona qolgan variant — Sozlamalar
}

typeof ... === "object" faqat type'da obyekt bilan birga primitive'lar ham bor bo'lganda (masalan, string | Sozlamalar | null) foydali.

Esda tuting: typeof x === "object" "x — obyekt" degani emas, "x — obyekt yoki null" degani, shuning uchun uni doim x !== null bilan birga yozing.