Seriya: TypeScript Basics Dars 47

is keyword

TypeScript'da is kalit so'zi: boolean o'rniga type predicate, parametrNomi is Type sintaksisi, type sig'ishi qoidasi, false tarmog'ida chiqarib tashlash, this is T va guard ichiga biznes shart qo'shish xatosi.

47-dars

is keyword

x is T bilan custom type guard yozdik. Endi is'ning o'zini ko'ramiz: u qanday qoidalarga bo'ysunadi va qachon xavfli bo'ladi.

Muammo shundan boshlanadi: tekshiruvni yordamchi funksiyaga chiqarib, qaytish type'ini boolean deb yozsak, TS funksiyadan tashqarida narrowing'ni yo'qotadi:

type Manzil = { shahar: string; kocha: string };

// ❌ boolean — natija nimani anglatishi aytilmagan
function manzilBormi(m: Manzil | null): boolean {
  return m !== null;
}

function chopEt(m: Manzil | null) {
  if (manzilBormi(m)) {
    console.log(m.shahar);
    // ❌ 'm' is possibly 'null'.
  }
}

if (m !== null) to'g'ridan-to'g'ri yozilsa ishlardi. Lekin funksiya chegarasidan faqat boolean o'tadi, "nima uchun true" degan ma'lumot yo'qoladi. is aynan shu ma'lumotni funksiyadan tashqariga olib chiqadi:

// ✅ m is Manzil — true qaytsa, m — Manzil
function manzilBormi(m: Manzil | null): m is Manzil {
  return m !== null;
}

function chopEt(m: Manzil | null) {
  if (manzilBormi(m)) {
    console.log(m.shahar); // ✅ m: Manzil
  }
}

TS 5.5 dan boshlab qaytish type'i umuman yozilmasa, bunday oddiy funksiyalar uchun TS m is Manzil'ni o'zi chiqaradi. Lekin : boolean qo'lda yozilsa, bu xulosa o'chadi.

Qanday ishlaydi?

1. Sintaksis: parametrNomi is Type

is faqat funksiyaning qaytish type'i o'rnida ishlatiladi. Chap tomonda parametr nomi, o'ng tomonda type turadi. Funksiya tanasi esa oddiy boolean qaytaradi:

function sonmi(qiymat: unknown): qiymat is number {
  return typeof qiymat === "number";
}

// Arrow function'da ham xuddi shunday
const sonmi2 = (q: unknown): q is number => typeof q === "number";

Parametr nomi aniq mos kelishi kerak:

function sonmi(qiymat: unknown): x is number {
  // ❌ Cannot find parameter 'x'.
  return typeof qiymat === "number";
}

2. is o'ng tomonidagi type parametr type'iga sig'ishi kerak

Guard faqat toraytira oladi, type'ni butunlay boshqasiga almashtira olmaydi:

function raqammi(s: string): s is number {
  // ❌ A type predicate's type must be assignable to its parameter's type.
  //      Type 'number' is not assignable to type 'string'.
  return /^\d+$/.test(s);
}

"123" hali ham string. Uni number'ga aylantirish uchun Number(s) kerak, type guard emas.

3. false tarmog'ida type chiqarib tashlanadi

true qaytsa, argument T'ga torayadi. false qaytsa, T union'dan butunlay chiqarib tashlanadi:

type Natija = Manzil | string | null;

function korsat(n: Natija) {
  if (manzilmi(n)) {
    n; // Manzil
  } else {
    n; // string | null — Manzil chiqib ketdi
  }
}

function manzilmi(x: unknown): x is Manzil {
  return typeof x === "object" && x !== null && "shahar" in x && "kocha" in x;
}

Bu qoida juda kuchli, lekin pastdagi asosiy xatoning ham sababi aynan shu.

4. this is T — metod obyektning o'zini toraytiradi

this type'ini ko'rgan edik. is chap tomonida parametr o'rniga this ham turishi mumkin. Bunda metod chaqirilgan obyektning o'zi torayadi:

interface Tugun {
  nom: string;
  papkami(): this is Papka;
}

interface Papka extends Tugun {
  bolalar: Tugun[];
}

function daraxt(t: Tugun, chuqurlik = 0) {
  console.log(" ".repeat(chuqurlik * 2) + t.nom);
  if (t.papkami()) {
    t.bolalar.forEach((b) => daraxt(b, chuqurlik + 1)); // ✅ t: Papka
  }
}

this is ... asosan class metodlarida uchraydi.

5. is ning uch ko'rinishi

Qaytish type'i true bo'lsa false bo'lsa
boolean narrowing yo'q narrowing yo'q
x is T x → T T chiqarib tashlanadi
asserts x is T — xato otiladi, pastda x → T

Eng ko'p uchraydigan xato

Type tekshiruvini biznes shart bilan bitta guard'ga aralashtirish.

type Foydalanuvchi = { ism: string; faol: boolean };

// Faqat faol foydalanuvchi uchun true
function faolFoydalanuvchimi(u: Foydalanuvchi | null): u is Foydalanuvchi {
  return u !== null && u.faol;
}

function salomlash(u: Foydalanuvchi | null): string {
  if (faolFoydalanuvchimi(u)) {
    return `Xush kelibsiz, ${u.ism}!`;
  }
  u; // TS fikricha: null
  return "Iltimos, tizimga kiring"; // 🐛 bloklangan foydalanuvchi ham shu xabarni oladi
}

Nega bunday bo'ladi? 3-bo'limdagi qoida: false qaytsa, TS Foydalanuvchi'ni butunlay chiqarib tashlaydi va else tarmog'ida u'ni null deb hisoblaydi. Aslida esa false ikki sababdan qaytishi mumkin: null yoki faol emas. { ism: "Ali", faol: false } ham else'ga tushadi, lekin TS uni ko'rmaydi.

Bu yerda TS hech qanday xato chiqarmaydi. Keyinchalik else'ga yangi kod qo'shilsa, muammo kuchayadi:

if (u !== null) {
  bloklanganXabar(u.ism);
  // ❌ Property 'ism' does not exist on type 'never'.
  // TS bu kodni "hech qachon bajarilmaydi" deb hisoblaydi, aslida esa bajariladi 🐛
}

TS 5.5 ham aynan shu sababli u !== null && u.faol uchun predicate'ni o'zi chiqarmaydi.

✅ Yechim 1: guard faqat type'ni tekshirsin, biznes shart alohida yozilsin

function salomlash(u: Foydalanuvchi | null): string {
  if (u === null) return "Iltimos, tizimga kiring";
  if (!u.faol) return `${u.ism}, akkauntingiz bloklangan`; // u: Foydalanuvchi
  return `Xush kelibsiz, ${u.ism}!`;
}

✅ Yechim 2: biznes shart uchun oddiy boolean funksiya

function faolmi(u: Foydalanuvchi): boolean {
  return u.faol;
}

if (u !== null && faolmi(u)) { /* ... */ }

x is T faqat "true ⇔ x aynan T" degan holatda to'g'ri. "T va yana qo'shimcha shart" uchun boolean qoldiring.

Esda tuting: x is T guard'i false qaytarganda TS x'ni "T emas" deb hisoblaydi, shuning uchun guard ichiga type tekshiruvidan boshqa shart qo'shmang.