Series: TypeScript Basics Lesson 41

Control-flow analysis

TypeScript'da control-flow analysis: har bir kod nuqtasidagi type, return va throw'dan keyingi narrowing, tarmoqlarning birlashishi, qiymat berish orqali narrowing, funksiya chaqiruvlari va callback ichida narrowing yo'qolishi.

41-dars

Control-flow analysis

typeof, === va truthiness tekshiruvlari bilan type'ni toraytirdik. Bu ishlashi uchun TS kodni yuqoridan pastga "o'qib", har bir if, return, throw va = dan keyin o'zgaruvchi qaysi type'da ekanini kuzatib boradi. Shu kuzatishga control-flow analysis (CFA) deyiladi.

CFA bo'lmaganida har bir ishlatishda type'ni qo'lda aytishga to'g'ri kelardi:

// ❌ Har qadamda assertion — TS'ga ishonmaslik
function formatla(qiymat: string | number | null): string {
  if (qiymat === null) {
    return "—";
  }
  if (typeof qiymat === "number") {
    return (qiymat as number).toFixed(2); // as kerak emas edi
  }
  return (qiymat as string).trim(); // keyinroq kimdir yuqoridagi tekshiruvni o'chirsa, as xatoni yashiradi 🐛
}
// ✅ Tekshiruv qilinadi, qolganini TS o'zi kuzatadi
function formatla(qiymat: string | number | null): string {
  if (qiymat === null) {
    return "—";
  }
  // bu yerda: string | number
  if (typeof qiymat === "number") {
    return qiymat.toFixed(2); // number
  }
  return qiymat.trim(); // string — boshqa variant qolmadi
}

as TS'ga "menga ishon" deydi. CFA'da esa TS'ning o'zi isbotlaydi. Shuning uchun tekshiruv olib tashlansa, darhol xato chiqadi.

Qanday ishlaydi?

1. Har bir kod nuqtasida o'z type'i bor

O'zgaruvchining e'lon qilingan type'i (declared type) bitta. Lekin kodning har bir joyida TS uning hozirgi type'ini (narrowed type) alohida hisoblaydi:

function chopEt(id: string | number) {
  id; // string | number

  if (typeof id === "string") {
    id; // string
  } else {
    id; // number
  }

  id; // string | number — yana to'liq union
}

Editor'da kursorni id ustiga olib boring: har bir qatorda boshqacha type ko'rinadi.

2. return va throw'dan keyin kod "qolgan" variantlar bilan davom etadi

Tarmoq return yoki throw bilan tugasa, TS shu variant pastga o'tmasligini biladi. "Guard clause" shu sababli ishlaydi:

type Foydalanuvchi = { ism: string; email: string | null };

function xatYubor(f: Foydalanuvchi | undefined) {
  if (!f) {
    throw new Error("Foydalanuvchi topilmadi");
  }
  // bu yerdan pastda f: Foydalanuvchi

  if (f.email === null) {
    return;
  }
  // bu yerdan pastda f.email: string

  console.log(`${f.ism} <${f.email.toLowerCase()}>`); // ✅
}

Ichma-ich if piramidasi o'rniga erta chiqib ketish kodni ham, type'ni ham soddalashtiradi. return'dan keyin yozilgan kodni editor xira rangda ko'rsatadi (Unreachable code detected.), allowUnreachableCode: false sozlamasida esa bu xatoga aylanadi.

3. Tarmoqlar qayta qo'shilganda type'lar birlashadi

if/else tugagach, ikkala tarmoqdagi type'lar union bo'lib birlashadi:

function normalizatsiya(kiritma: string | string[]) {
  let natija;

  if (typeof kiritma === "string") {
    natija = [kiritma]; // string[]
  } else {
    natija = kiritma;   // string[]
  }

  natija; // string[] — ikkala tarmoqda ham bir xil
  return natija.join(", ");
}

Agar bitta tarmoqda o'zgaruvchiga hech narsa berilmasa, birlashgan type'da undefined paydo bo'ladi:

function chegirma(summa: number) {
  let foiz: number | undefined;
  if (summa > 1000) {
    foiz = 10;
  }
  foiz; // number | undefined — else tarmog'ida qiymat berilmagan
  return summa * (foiz ?? 0);
}

4. Qiymat berish (=) ham narrowing qiladi

let o'zgaruvchisiga qiymat berilganda TS uni berilgan qiymat type'iga toraytiradi. Lekin e'lon qilingan type chegarasidan chiqishga ruxsat bermaydi:

let javob: string | number = "salom";
javob.toUpperCase(); // ✅ hozir string

javob = 42;
javob.toFixed(1);    // ✅ endi number
javob.toUpperCase(); // ❌ Property 'toUpperCase' does not exist on type 'number'.

javob = true; // ❌ Type 'boolean' is not assignable to type 'string | number'.
E'lon qilingan type Hozirgi type
Nimani belgilaydi Qanday qiymat berish mumkin Hozir qanday qiymat bor
O'zgaradimi Yo'q Har = va tekshiruvdan keyin

5. Funksiya chaqiruvi property narrowing'ni bekor qilmaydi 🐛

TS boshqa funksiya obyektni ichidan o'zgartirganini kuzatmaydi. Unga "optimistik" yondashadi va eski narrowing'ni saqlab qoladi:

type Yuklash = { holat: "kutish" | "yuklanmoqda" };

function tozala(y: Yuklash) {
  y.holat = "kutish";
}

const y: Yuklash = { holat: "yuklanmoqda" };

if (y.holat === "yuklanmoqda") {
  tozala(y);
  y.holat; // TS fikricha: "yuklanmoqda". Aslida: "kutish" 🐛
}

Bu cheklov ataylab qilingan. Aks holda har bir funksiya chaqiruvidan keyin barcha narrowing yo'qolib, CFA deyarli foydasiz bo'lib qolardi. Amaliy xulosa: obyektni o'zgartiradigan funksiyani chaqirgandan keyin uning property'larini qayta tekshiring.

Eng ko'p uchraydigan xato

Tekshiruvdan keyin callback ichida narrowing "yo'qoladi".

let tanlanganId: string | null = null;

function tanla(id: string | null) {
  tanlanganId = id;
}

function yuklashniBoshlash() {
  if (tanlanganId !== null) {
    setTimeout(() => {
      console.log(tanlanganId.toUpperCase());
      // ❌ 'tanlanganId' is possibly 'null'.
    }, 1000);
  }
}

Nega bunday bo'ladi? if bajarilgan paytda tanlanganId haqiqatan ham string. Lekin callback keyinroq, bir soniyadan so'ng ishlaydi. O'sha orada tanla(null) chaqirilishi mumkin. tanlanganId qayta qiymat oladigan let bo'lgani uchun TS callback ichida eski tekshiruvga ishonmaydi. Bu yerda TS haqli. Agar ! bilan "o'chirib" qo'yilsa, kod haqiqatan qulashi mumkin 💥:

setTimeout(() => {
  console.log(tanlanganId!.toUpperCase()); // 💥 TypeError: Cannot read properties of null
}, 1000);

Narrowing callback ichida qachon saqlanadi:

O'zgaruvchi Callback ichida narrowing
const ✅ saqlanadi, qiymat o'zgara olmaydi
let yoki parametr, callback yaratilgandan keyin unga qiymat berilmaydi ✅ saqlanadi (TS 5.4+)
let, boshqa joyda (boshqa funksiyada) qayta qiymat oladi ❌ yo'qoladi
Oddiy (readonly bo'lmagan) obyekt property'si ❌ yo'qoladi
const obyektning readonly property'si ✅ saqlanadi

✅ Yechim 1: qiymatni constga ko'chirib oling. Bu eng keng tarqalgan usul:

function yuklashniBoshlash() {
  const id = tanlanganId; // aynan shu paytdagi qiymat "muzlatiladi"
  if (id !== null) {
    setTimeout(() => {
      console.log(id.toUpperCase()); // ✅ id: string
    }, 1000);
  }
}

✅ Yechim 2: tekshiruvni callback ichiga ko'chiring. Callback ishlagan paytdagi eng yangi qiymat kerak bo'lsa, shu usulni qo'llang:

setTimeout(() => {
  if (tanlanganId !== null) {
    console.log(tanlanganId.toUpperCase()); // ✅
  }
}, 1000);

Qaysi biri to'g'ri ekani mantiqqa bog'liq. Yechim 1 yuklashniBoshlash() chaqirilgan paytdagi id bilan ishlaydi, Yechim 2 esa bir soniyadan keyingi id bilan ishlaydi.

Esda tuting: narrowing faqat TS qiymat o'zgarmaganini isbotlay oladigan joygacha amal qiladi, shuning uchun keyinroq ishlaydigan kod uchun qiymatni constga oling yoki tekshiruvni o'sha kodning ichida qiling.