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.