Equality-based narrowing
TypeScript'da tenglik orqali narrowing: literal qiymat bilan ===, !== va else, switch, ikki o'zgaruvchini solishtirish, == null va .includes() narrowing bermasligi.
44-dars
Equality-based narrowing
Ko'p qiymatlar cheklangan variantlardan birini oladi: buyurtma holati, tarif nomi, foydalanuvchi roli. Ularni oddiy string bilan saqlasak, xato yozilgan qiymat jimgina hech qachon mos kelmaydi:
// ❌ string — har qanday matn "to'g'ri"
function oylikNarx(tarif: string): number {
if (tarif === "bepul") return 0;
if (tarif === "Pro") return 99_000; // 🐛 aslida "pro" kichik harf bilan keladi
return 299_000;
}
oylikNarx("pro"); // 299 000 — pro foydalanuvchi biznes narxini to'laydi
Literal union va === birga ishlaganda, TS ham xatoni ushlaydi, ham har bir tarmoqda type'ni toraytiradi:
// ✅ Literal union + ===
type Tarif = "bepul" | "pro" | "biznes";
function oylikNarx(tarif: Tarif): number {
if (tarif === "Pro") return 99_000;
// ❌ This comparison appears to be unintentional because the types 'Tarif' and '"Pro"' have no overlap.
if (tarif === "bepul") return 0; // tarif: "bepul"
if (tarif === "pro") return 99_000; // tarif: "pro"
return 299_000; // tarif: "biznes" — yagona qolgan variant
}
Qanday ishlaydi?
1. Literal qiymat bilan ===
Aniq qiymat bilan solishtirilganda, true tarmog'ida o'zgaruvchi type'i shu qiymatning literal type'iga torayadi:
type Javob = "ha" | "yo'q" | null;
function tasdiqla(j: Javob) {
if (j === "ha") {
j; // "ha"
} else {
j; // "yo'q" | null
}
}
Bu nafaqat string'lar uchun: === 0, === true, === undefined ham xuddi shunday ishlaydi.
2. !== va else — qolgan variantlar
Chiqarib tashlash usuli guard clause bilan yaxshi ishlaydi:
type Holat = "yangi" | "jarayonda" | "yetkazildi" | "bekor";
function bekorQilishMumkinmi(h: Holat): boolean {
if (h === "yetkazildi" || h === "bekor") {
return false;
}
h; // "yangi" | "jarayonda"
return true;
}
3. switch ham === bilan ishlaydi
Har bir case aslida === solishtiruvi, shuning uchun narrowing har bir case ichida ishlaydi. Mavjud bo'lmagan case ham xato beradi:
function rang(h: Holat): string {
switch (h) {
case "yangi":
return "ko'k"; // h: "yangi"
case "jarayonda":
return "sariq"; // h: "jarayonda"
case "yetkazilgan":
// ❌ Type '"yetkazilgan"' is not comparable to type 'Holat'.
return "yashil";
default:
return "kulrang"; // h: "yetkazildi" | "bekor"
}
}
4. Ikki o'zgaruvchini bir-biri bilan solishtirish
Ikkala o'zgaruvchi teng bo'lsa, ular faqat umumiy type'da bo'lishi mumkin. TS ikkalasini ham shu umumiy qismga toraytiradi:
function solishtir(a: string | number, b: string | boolean) {
if (a === b) {
// ikkalasining yagona umumiy type'i — string
a.toUpperCase(); // a: string
b.toUpperCase(); // b: string
}
}
Amalda ko'pincha null bo'lishi mumkin bo'lgan qiymatni aniq qiymat bilan solishtirganda uchraydi:
function tanlanganmi(id: string, tanlangan: string | null) {
if (id === tanlangan) {
tanlangan; // string — null id'ga teng bo'la olmaydi
}
}
5. == null — null va undefined'ni birdaniga chiqaradi
Odatda === tavsiya qilinadi, lekin == null bitta foydali istisno: u ham null, ham undefined uchun true qaytaradi:
function ismChiqar(ism: string | null | undefined) {
if (ism != null) {
ism.trim(); // ism: string — ikkalasi ham chiqib ketdi
}
}
| Tekshiruv | null |
undefined |
Natija type'i (string | null | undefined uchun) |
|---|---|---|---|
x !== null |
chiqadi | qoladi | string | undefined |
x !== undefined |
qoladi | chiqadi | string | null |
x != null |
chiqadi | chiqadi | string ✅ |
Shu bilan birga 0 va "" chiqib ketmaydi. Truthiness tekshiruvidan (if (x)) farqi shunda.
Eng ko'p uchraydigan xato
.includes() bilan tekshirib, narrowing kutish. Ruxsat etilgan qiymatlar ro'yxati bor va URL yoki formadan kelgan string'ni tekshirmoqchisiz:
type Rol = "admin" | "muharrir" | "oquvchi";
const ROLLAR: Rol[] = ["admin", "muharrir", "oquvchi"];
function rolOrnat(kirish: string) {
if (ROLLAR.includes(kirish)) {
// ❌ Argument of type 'string' is not assignable to parameter of type 'Rol'.
saqlash(kirish);
}
}
function saqlash(rol: Rol) { /* ... */ }
Nega bunday bo'ladi? Ikki sabab bor. Birinchidan, Rol[]'ning includes metodi faqat Rol qabul qiladi, string emas. Ikkinchidan, xato bo'lmagan holatda ham .includes() oddiy metod, === emas. TS uning true qaytarishidan kirish haqida xulosa chiqarmaydi va kirish stringligicha qoladi.
Ko'pchilik buni as bilan "yopadi":
if (ROLLAR.includes(kirish as Rol)) {
saqlash(kirish as Rol); // ishlaydi, lekin ikki marta TS'ga "ishon" deyildi
}
✅ Yechim 1: variantlar kam bo'lsa — to'g'ridan-to'g'ri ===
function rolOrnat(kirish: string) {
if (kirish === "admin" || kirish === "muharrir" || kirish === "oquvchi") {
saqlash(kirish); // ✅ kirish: Rol
}
}
✅ Yechim 2: switch — o'qilishi oson, har bir rolga alohida mantiq qo'shish mumkin
function rolOrnat(kirish: string) {
switch (kirish) {
case "admin":
case "muharrir":
case "oquvchi":
saqlash(kirish); // ✅ kirish: Rol
break;
default:
console.warn(`Noma'lum rol: ${kirish}`);
}
}
Ro'yxat katta bo'lsa yoki bu tekshiruv ko'p joyda kerak bo'lsa, uni qayta ishlatiladigan isRol(x): x is Rol funksiyasiga chiqarish mumkin.
Esda tuting: narrowing'ni ===, !== va switch beradi, .includes() esa faqat true/false qaytaradi va type'ni o'zgartirmaydi.