Series: TypeScript Basics Lesson 40

Type narrowing

TypeScript'da type narrowing: tekshiruvlar orqali union'ni toraytirish, narrowing usullari, truthiness, early return, in operatori, never va 0 hamda ""ni yo'qotish xatosi.

40-dars

Type narrowing

Union type bilan ishlaganda TS faqat barcha a'zolarda bor bo'lgan amallarga ruxsat beradi. Bitta a'zoga xos amalni bajarish uchun avval qiymat aynan qaysi type ekanini aniqlash kerak.

// ❌ Muammo: union'ning bitta a'zosiga xos method chaqirilyapti
function format(value: string | number) {
  return value.toUpperCase();
  // ❌ Property 'toUpperCase' does not exist on type 'string | number'.
  //      Property 'toUpperCase' does not exist on type 'number'.
}
// ✅ Yechim: runtime'da tekshiramiz — TS shu tekshiruvga qarab type'ni toraytiradi
function format(value: string | number) {
  if (typeof value === "string") {
    return value.toUpperCase(); // value: string
  }
  return value.toFixed(2);      // value: number
}

Narrowing — TS'ning sizning if, switch, return kabi tekshiruvlaringizni "o'qib", har bir tarmoqda type'ni torroq qilishi. Assertion'dan farqi: bu yerda haqiqiy runtime tekshiruvi bor, shuning uchun u xavfsiz.

Qanday ishlaydi?

1. Bir o'zgaruvchi — har joyda boshqa type

Bitta o'zgaruvchining type'i kodning turli joylarida turlicha bo'ladi. IDE'da kursorni har bir value ustiga olib borsangiz, buni ko'rasiz.

function show(value: string | number | null) {
  // value: string | number | null

  if (value === null) {
    return "bo'sh";      // value: null
  }
  // value: string | number

  if (typeof value === "string") {
    return value.trim(); // value: string
  }
  // value: number

  return value.toFixed(1);
}

Har bir tekshiruv union'dan bir qismni "kesib" tashlaydi. TS bu yo'lni qanday kuzatishi (control flow analysis) keyingi darslarda batafsil ko'riladi.

2. Narrowing usullari

TS bir nechta tekshiruv turlarini tushunadi. Ularning har biri keyingi darslarda alohida ko'riladi.

Usul Misol Nima uchun
typeof typeof x === "string" primitive type'lar
instanceof x instanceof Date class instance'lari
=== / !== x === null, x === "admin" aniq qiymatlar
Truthiness if (x) null/undefinedni olib tashlash
in "swim" in x obyekt shakllari
Array.isArray Array.isArray(x) massiv yoki yo'q
Discriminant field x.type === "circle" belgilangan union'lar
Custom type guard isUser(x) o'zingiz yozgan tekshiruv
Assertion function assertIsUser(x) tekshirib, xato otish
function total(input: number | number[]) {
  if (Array.isArray(input)) {
    return input.reduce((a, b) => a + b, 0); // input: number[]
  }
  return input;                               // input: number
}

3. Truthiness narrowing

if (x) qiymatni boolean'ga aylantirib tekshiradi. null va undefined doim "falsy", shuning uchun TS ularni type'dan olib tashlaydi.

function greet(name: string | null | undefined) {
  if (name) {
    return `Salom, ${name}`; // name: string
  }
  return "Salom, mehmon";    // name: string | null | undefined
}

else tarmog'ida string ham qoladi, chunki bo'sh satr "" ham falsy. JavaScript'dagi falsy qiymatlar:

Qiymat Type
false boolean
0, -0, NaN number
0n bigint
"" string
null, undefined null, undefined

Bu ro'yxat quyidagi "Eng ko'p uchraydigan xato" bo'limida muhim bo'ladi.

4. Early return — funksiyaning qolgan qismi toraygan

type User = { name: string; email: string | null };

function sendWelcome(user: User | undefined) {
  if (!user) return;                  // user yo'q — chiqib ketamiz
  if (!user.email) return;            // email yo'q — chiqib ketamiz

  // Bu yerdan pastda: user: User, user.email: string
  const address = user.email.toLowerCase();
  console.log(`${user.name} → ${address}`);
}

5. in operatori bilan obyekt shakllarini ajratish

Union a'zolari turli field'larga ega obyektlar bo'lsa, field borligini in bilan tekshirish mumkin.

type Fish = { swim: () => void };
type Bird = { fly: () => void };

function move(animal: Fish | Bird) {
  if ("swim" in animal) {
    animal.swim(); // animal: Fish
  } else {
    animal.fly();  // animal: Bird
  }
}

Obyekt union'lari uchun yanada ishonchli usul — umumiy "belgi" field'i (discriminated union).

6. else — qolgan qism, oxirida never

TS har bir tarmoqda "nima qoldi"ni hisoblaydi. Barcha variantlar tekshirib bo'linsa, qolgan type never bo'ladi.

function label(value: string | number | boolean) {
  if (typeof value === "string") return "matn";
  if (typeof value === "number") return "son";
  if (typeof value === "boolean") return "mantiqiy";

  value; // value: never — boshqa variant qolmadi
}

Bu xususiyat "hamma holat ishlandimi?" degan tekshiruvga aylanadi — exhaustiveness checking.

Eng ko'p uchraydigan xato

Son yoki satrni truthiness bilan tekshirib, 0 va ""ni yo'qotish.

function setVolume(level?: number) {
  if (level) {
    player.volume = level;
  } else {
    player.volume = 50; // default
  }
}

setVolume(80); // ✅ 80
setVolume(0);  // 🐛 50 — foydalanuvchi ovozni o'chirmoqchi edi!

Nega bunday bo'ladi? Maqsad "level berilganmi?"ni tekshirish edi, ya'ni undefinedni ajratish. Lekin if (level) "falsy emasmi?" deb so'raydi, 0 esa falsy. TS bu yerda hech narsa demaydi: if ichida level: number to'g'ri toraydi, xato type'da emas, mantiqda. Xuddi shu muammo satrlarda ham bor:

function search(query: string | undefined) {
  if (!query) return getAll(); // 🐛 "" ham shu yerga tushadi
  return find(query);
}
// ✅ 1-yechim: aynan undefined bilan solishtirish
function setVolume(level?: number) {
  if (level !== undefined) {
    player.volume = level; // 0 ham shu yerga tushadi
  } else {
    player.volume = 50;
  }
}

// ✅ 2-yechim: ?? — faqat null/undefined uchun default
function setVolume2(level?: number) {
  player.volume = level ?? 50; // 0 → 0, undefined → 50
}

// ✅ 3-yechim: default parametr
function setVolume3(level: number = 50) {
  player.volume = level;       // 0 → 0, berilmasa → 50
}

|| operatori ham xuddi shu tuzoqqa ega: level || 50 ham 0ni 50ga almashtiradi. Son va satrlar uchun ?? ishlating.

Esda tuting: if (x) "x falsy emasmi?" deb so'raydi, "x bormi?" deb emas — 0 yoki "" haqiqiy qiymat bo'lishi mumkin bo'lsa, !== undefined yoki ?? ishlating.