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.