Series: TypeScript Basics Lesson 46

Custom type guard

TypeScript'da custom type guard: x is T qaytish type'i, takrorlanadigan tekshiruvni bitta joyga chiqarish, unknown'ni bosqichma-bosqich tekshirish, .filter() bilan toraytirish va to'liq tekshirmaydigan guard xavfi.

46-dars

Custom type guard

Tashqaridan keladigan ma'lumot (server javobi, JSON.parse, localStorage) TS uchun noma'lum. Uni as bilan "tanitish" xavfli ekanini ko'rgan edik:

type Foydalanuvchi = { id: number; ism: string; email: string };

// ❌ as — tekshiruv yo'q, faqat va'da
const u = JSON.parse(localStorage.getItem("user") ?? "{}") as Foydalanuvchi;
console.log(u.email.toLowerCase());
// localStorage bo'sh yoki eski formatda bo'lsa:
// 💥 TypeError: Cannot read properties of undefined (reading 'toLowerCase')

Tekshiruvni oddiy boolean funksiyaga chiqarsak, runtime xavfsiz bo'ladi, lekin TS natijani "ko'rmaydi":

function foydalanuvchimi(x: unknown): boolean {
  return typeof x === "object" && x !== null && "email" in x /* ... */;
}

const data: unknown = JSON.parse(matn);
if (foydalanuvchimi(data)) {
  data.email;
  // ❌ 'data' is of type 'unknown'.
}

Custom type guard — qaytish type'i x is T bo'lgan funksiya. U true qaytarsa, TS chaqirilgan joyda argumentni T'ga toraytiradi:

// ✅ x is Foydalanuvchi — "true bo'lsa, x Foydalanuvchi"
function foydalanuvchimi(x: unknown): x is Foydalanuvchi {
  return (
    typeof x === "object" && x !== null &&
    "id" in x && typeof x.id === "number" &&
    "ism" in x && typeof x.ism === "string" &&
    "email" in x && typeof x.email === "string"
  );
}

const data: unknown = JSON.parse(matn);
if (foydalanuvchimi(data)) {
  console.log(data.email.toLowerCase()); // ✅ data: Foydalanuvchi
} else {
  console.warn("Saqlangan ma'lumot buzilgan");
}

Qanday ishlaydi?

1. x is T — funksiya qaytarayotgan "va'da"

Runtime'da type guard oddiy true/false qaytaradi. Farq faqat type'da: x is T TS'ga natija nimani anglatishini aytadi. x funksiya parametrlaridan birining nomi bo'lishi kerak:

function stringmi(qiymat: unknown): qiymat is string {
  return typeof qiymat === "string";
}

function uzunlik(q: string | number) {
  if (stringmi(q)) {
    return q.length; // q: string
  }
  return q;          // q: number — else tarmog'ida string chiqib ketdi
}

2. Takrorlanadigan tekshiruvni bitta joyga chiqarish

.includes() narrowing qilmasligini ko'rgan edik. Type guard shu tekshiruvni qayta ishlatiladigan qiladi:

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

function rolmi(x: string): x is Rol {
  return ROLLAR.some((r) => r === x);
}

function rolOrnat(kirish: string) {
  if (rolmi(kirish)) {
    saqlash(kirish); // ✅ kirish: Rol
  }
}

Endi yangi rol qo'shilsa, faqat Rol va ROLLAR yangilanadi. Tekshiruv yozilgan o'nlab joylar o'zgarmaydi.

3. unknown'ni bosqichma-bosqich tekshirish

Guard ichida avvalgi darslardagi barcha vositalar ishlaydi. unknown obyektni tekshirish tartibi doim bir xil:

type Mahsulot = { nom: string; narx: number; teglar: string[] };

function mahsulotmi(x: unknown): x is Mahsulot {
  if (typeof x !== "object" || x === null) return false;          // 1. obyektmi (null emas — 42-dars)
  if (!("nom" in x) || typeof x.nom !== "string") return false;   // 2. har bir maydon bormi
  if (!("narx" in x) || typeof x.narx !== "number") return false; // 3. va to'g'ri type'dami
  if (!("teglar" in x) || !Array.isArray(x.teglar)) return false;
  return x.teglar.every((t) => typeof t === "string");            // 4. massiv elementlari ham
}

"nom" in xdan keyin TS x.nom'ga murojaat qilishga ruxsat beradi, lekin uning type'i unknown bo'ladi. Shuning uchun keyingi typeof tekshiruvi kerak.

4. .filter() bilan massiv type'ini toraytirish

Type guard .filter()'ga uzatilsa, natija massivi ham torayadi:

const xom: unknown[] = await javob.json();

const mahsulotlar = xom.filter(mahsulotmi); // Mahsulot[] ✅
const buzilganlar = xom.length - mahsulotlar.length;

TS 5.5 dan boshlab oddiy holatlarda TS predicate'ni o'zi chiqaradi:

const ismlar = ["Ali", null, "Vali"].filter((x) => x !== null); // string[] (TS 5.5+)

Murakkabroq tekshiruvlar uchun esa guard'ni o'zingiz yozasiz.

Usul Runtime tekshiruv TS narrowing
as T (37–38-darslar) ❌ yo'q ✅ (ko'r-ko'rona)
boolean qaytaruvchi funksiya ✅ ❌
x is T type guard ✅ ✅

Eng ko'p uchraydigan xato

Guard to'liq tekshirmaydi, lekin TS unga to'liq ishonadi.

type Buyurtma = { id: number; summa: number; manzil: string };

function buyurtmami(x: unknown): x is Buyurtma {
  return typeof x === "object" && x !== null && "id" in x; // faqat id tekshirildi
}

const data: unknown = await (await fetch("/api/buyurtma/7")).json();
if (buyurtmami(data)) {
  console.log(data.manzil.toUpperCase());
  // server { id: 7, xato: "Topilmadi" } qaytarsa:
  // 💥 TypeError: Cannot read properties of undefined (reading 'toUpperCase')
}

Nega bunday bo'ladi? TS guard ichidagi mantiq haqiqatan Buyurtma'ni isbotlashini tekshirmaydi. x is Buyurtma ham as kabi va'da: TS funksiya true qaytarsa, unga to'liq ishonadi. Shuning uchun bu yerda TS hech qanday xato chiqarmaydi.

Ko'pincha guard dastlab to'g'ri yoziladi, keyinchalik buziladi: Buyurtma'ga yangi maydon qo'shiladi, guard esa yangilanmaydi 🐛.

✅ Yechim 1: har bir majburiy maydonni tekshiring

function buyurtmami(x: unknown): x is Buyurtma {
  return (
    typeof x === "object" && x !== null &&
    "id" in x && typeof x.id === "number" &&
    "summa" in x && typeof x.summa === "number" &&
    "manzil" in x && typeof x.manzil === "string"
  );
}

✅ Yechim 2: guard'ni type yonida saqlang

Type va uning guard'i bitta faylda, yonma-yon tursa, type o'zgarganda guard'ni yangilash esdan chiqmaydi.

// buyurtma.ts
export type Buyurtma = { id: number; summa: number; manzil: string };
export function buyurtmami(x: unknown): x is Buyurtma { /* ... */ }

Obyektlar katta va ko'p bo'lsa, guard'larni qo'lda yozish o'rniga schema kutubxonasi (Zod) ishlatiladi: bitta schema'dan ham tekshiruv, ham type olinadi.

Esda tuting: type guard ham as kabi va'da, faqat runtime tekshiruv bilan, shuning uchun u type'dagi har bir majburiy maydonni tekshirishi kerak.