Assertion functions
TypeScript'da assertion function'lar: asserts x is T, asserts shart, generic versiya, type guard bilan farqi, ichida throw tekshirilmasligi va arrow function bilan e'lon qilish xatosi.
48-dars
Assertion functions
find() natijasiga ! qo'yish xavfli ekanini ko'rgan edik:
type Foydalanuvchi = { id: number; ism: string };
const foydalanuvchilar: Foydalanuvchi[] = [/* ... */];
// ❌ ! — "topiladi" deb va'da, tekshiruv yo'q
const u = foydalanuvchilar.find((f) => f.id === 42)!;
console.log(u.ism);
// 42 topilmasa: 💥 TypeError: Cannot read properties of undefined (reading 'ism')
Xatoning o'zi emas, uning joyi muammo: crash find() qatorida emas, keyinroq, boshqa joyda bo'ladi va xabarda nima topilmagani yozilmaydi. To'g'ri tekshiruv esa har safar takrorlanadi:
const u = foydalanuvchilar.find((f) => f.id === 42);
if (!u) {
throw new Error("Foydalanuvchi topilmadi: 42");
}
console.log(u.ism); // ✅ u: Foydalanuvchi
// ... va shu 3 qator har bir find()'dan keyin
Assertion function shu "tekshir, bo'lmasa xato ot" mantiqini qayta ishlatiladigan funksiyaga chiqaradi. Funksiya muvaffaqiyatli tugasa, TS chaqirilgan joydan pastda type'ni toraytiradi:
// ✅ asserts u is Foydalanuvchi — "bu funksiyadan o'tib ketilgan bo'lsa, u — Foydalanuvchi"
function topildi(
u: Foydalanuvchi | undefined,
id: number
): asserts u is Foydalanuvchi {
if (u === undefined) {
throw new Error(`Foydalanuvchi topilmadi: ${id}`);
}
}
const u = foydalanuvchilar.find((f) => f.id === 42);
topildi(u, 42);
console.log(u.ism); // ✅ u: Foydalanuvchi
Xato aniq joyda, aniq xabar bilan otiladi. Pastdagi kodda esa na !, na if kerak.
Qanday ishlaydi?
1. asserts x is T — if emas, "o'tdi yoki to'xtadi"
Type guard true/false qaytaradi va if ichida ishlatiladi. Assertion function hech narsa qaytarmaydi (void): u yoki jimgina tugaydi, yoki xato otadi. Shuning uchun narrowing chaqiruvdan keyingi butun pastki kodga ta'sir qiladi:
function stringBolsin(x: unknown, nom: string): asserts x is string {
if (typeof x !== "string") {
throw new TypeError(`${nom} string bo'lishi kerak, keldi: ${typeof x}`);
}
}
function sozlamaniOqi(xom: unknown) {
stringBolsin(xom, "API_URL");
// bu yerdan pastda xom: string
return new URL(xom);
}
2. asserts shart — istalgan shart uchun
is T qismisiz yozilsa, funksiya o'ziga uzatilgan shart to'g'ri ekanini kafolatlaydi. TS esa o'sha shartdan kelib chiqib toraytiradi (Node.js'ning assert() funksiyasi shunday ishlaydi):
function tasdiqla(shart: unknown, xabar: string): asserts shart {
if (!shart) {
throw new Error(xabar);
}
}
function chegirma(foiz: number | null, summa: unknown) {
tasdiqla(foiz !== null, "Chegirma foizi yo'q");
tasdiqla(typeof summa === "number", "Summa son emas");
return summa * (1 - foiz / 100); // ✅ foiz: number, summa: number
}
Bitta universal tasdiqla loyihadagi ko'plab oddiy tekshiruvlarni qoplaydi.
3. Har qanday type uchun bitta funksiya
Yuqoridagi topildi faqat Foydalanuvchi uchun. Har bir type uchun alohida yozmaslik uchun generic versiya ishlatiladi:
function mavjud<T>(qiymat: T | null | undefined, xabar: string): asserts qiymat is T {
if (qiymat == null) throw new Error(xabar); // == null — null va undefined birdaniga (44-dars)
}
const mahsulot = mahsulotlar.find((m) => m.kod === kod);
mavjud(mahsulot, `Mahsulot topilmadi: ${kod}`);
mahsulot.narx; // ✅
Hozircha <T>'ni "istalgan type" deb tushunish kifoya.
4. Qachon guard, qachon assertion
Type guard (x is T) |
Assertion (asserts x is T) |
|
|---|---|---|
| Qaytaradi | boolean |
hech narsa (void) |
| Mos kelmasa | false, kod davom etadi |
xato otiladi, kod to'xtaydi |
| Narrowing qayerda | if ichida |
chaqiruvdan pastda |
| Qachon ishlatiladi | Ikkala holat ham normal (forma, tanlov) | Mos kelmasligi — bug yoki buzilgan ma'lumot |
Masalan, foydalanuvchi kiritgan email noto'g'ri bo'lishi normal holat, shuning uchun guard ishlatiladi. Konfiguratsiyada API_URL yo'qligi esa ilovani ishga tushirib bo'lmaydigan xato, shuning uchun assertion ishlatiladi.
5. TS funksiya ichida throw borligini tekshirmaydi 🐛
asserts ham is kabi va'da. Funksiya ichida xato otish esdan chiqsa, TS indamaydi:
function raqamBolsin(x: unknown): asserts x is number {
if (typeof x !== "number") {
console.warn("Raqam emas!"); // 🐛 throw yo'q — funksiya jimgina tugaydi
}
}
raqamBolsin("abc");
// TS fikricha: endi number. Aslida: "abc"
Assertion function'da tekshiruv muvaffaqiyatsiz bo'lgan har bir yo'l throw bilan tugashi shart.
Eng ko'p uchraydigan xato
Assertion'ni arrow function qilib yozish. Loyihadagi boshqa yordamchi funksiyalar kabi const + arrow ko'rinishida yozasiz:
const mavjudBolsin = (x: unknown, xabar: string): asserts x => {
if (!x) throw new Error(xabar);
};
const sozlama = localStorage.getItem("mavzu");
mavjudBolsin(sozlama, "Mavzu saqlanmagan");
// ❌ Assertions require every name in the call target to be declared with an explicit type annotation.
Obyekt ichidagi metod sifatida ham xuddi shunday:
const utils = {
mavjudBolsin(x: unknown, xabar: string): asserts x {
if (!x) throw new Error(xabar);
},
};
utils.mavjudBolsin(sozlama, "...");
// ❌ Assertions require every name in the call target to be declared with an explicit type annotation.
Nega bunday bo'ladi? Assertion narrowing'ni TS control-flow analysis bosqichida qiladi. Bu bosqichda TS chaqirilayotgan narsaning type'ini qo'shimcha hisoblamasdan, darhol bilishi kerak. function deklaratsiyasining type'i doim aniq. const va obyektning type'i esa qiymatdan chiqariladi, TS bu yerda buni qilmaydi. Shuning uchun u "type'ni o'zingiz yozing" deb talab qiladi.
✅ Yechim 1: function deklaratsiyasi (eng oddiy)
function mavjudBolsin(x: unknown, xabar: string): asserts x {
if (!x) throw new Error(xabar);
}
mavjudBolsin(sozlama, "Mavzu saqlanmagan");
sozlama.toUpperCase(); // ✅ sozlama: string
✅ Yechim 2: arrow kerak bo'lsa — const'ga type yozing
type MavjudBolsin = (x: unknown, xabar: string) => asserts x;
const mavjudBolsin: MavjudBolsin = (x, xabar) => {
if (!x) throw new Error(xabar);
};
mavjudBolsin(sozlama, "Mavzu saqlanmagan"); // ✅
Obyekt bo'lsa, obyektning o'ziga type yoziladi: const utils: { mavjudBolsin: MavjudBolsin } = { ... }.
Esda tuting: assertion function'ni function bilan e'lon qiling, arrow yoki obyekt metodi bo'lsa, o'zgaruvchining type'ini qo'lda yozing.