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.