Non-null assertion !
TypeScript'da ! operatori: null va undefined'ni olib tashlash, runtime'da tekshiruv yo'qligi, qachon o'rinli ekani, ?. va ?? bilan taqqoslash, definite assignment va find() natijasiga ! qo'yish xatosi.
39-dars
Non-null assertion !
strictNullChecks yoqilganda TS null yoki undefined bo'lishi mumkin bo'lgan qiymatni tekshirmasdan ishlatishga yo'l qo'ymaydi. Lekin ba'zan dasturchi qiymat albatta borligini biladi, TS esa buni ko'ra olmaydi.
// ❌ Muammo: kalit borligini tekshirdik, lekin TS buni "unutadi"
const groups = new Map<string, string[]>();
function addToGroup(key: string, item: string) {
if (!groups.has(key)) {
groups.set(key, []);
}
groups.get(key).push(item);
// ❌ 'groups.get(...)' is possibly 'undefined'.
}
Biz bilamizki, shu qatorga kelganda kalit albatta bor. Lekin TS has() va get() o'rtasidagi bog'liqlikni tushunmaydi: uning uchun get() doim string[] | undefined qaytaradi.
// ✅ Yechim: ! bilan "bu yerda undefined emas" deymiz
function addToGroup(key: string, item: string) {
if (!groups.has(key)) {
groups.set(key, []);
}
groups.get(key)!.push(item); // ✅ string[]
}
! — type assertion'ning maxsus, qisqa shakli: u faqat null va undefinedni olib tashlaydi.
Qanday ishlaydi?
1. ! type'dan null va undefined'ni olib tashlaydi
Ifodadan keyin qo'yilgan ! boshqa hech narsani o'zgartirmaydi — faqat shu ikkitasini.
declare const a: string | null;
declare const b: number | undefined;
declare const c: string | number | null | undefined;
a!; // string
b!; // number
c!; // string | number — faqat null | undefined ketdi
Bu as bilan yozishning qisqa varianti:
const el1 = document.getElementById("app")!; // HTMLElement
const el2 = document.getElementById("app") as HTMLElement; // xuddi shu natija
2. Runtime'da hech qanday tekshiruv yo'q
as kabi, ! ham kompilyatsiyadan keyin o'chib ketadi.
// TypeScript
const app = document.getElementById("app")!;
app.innerHTML = "Salom";
// Kompilyatsiyadan keyingi JavaScript
const app = document.getElementById("app");
app.innerHTML = "Salom";
🐛 HTML'da id="app" element bo'lmasa (yoki skript element yuklanishidan oldin ishlasa), xato runtime'da chiqadi:
// 💥 Cannot set properties of null (setting 'innerHTML')
! xatoni yo'q qilmaydi — faqat uni compile-time'dan runtime'ga ko'chiradi.
3. Qachon ! o'rinli
! faqat qiymat mantiqan albatta mavjud bo'lsa-yu, TS buni ko'ra olmasa ishlatiladi.
// 1) Map: has() va get() bog'liqligi (yuqoridagi misol)
groups.get(key)!.push(item);
// 2) HTML'da albatta bor va skript undan keyin yuklanadigan element
const root = document.getElementById("root")!;
// 3) Bir qatorda yaratilib, keyingi qatorda ishlatiladigan qiymat
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d")!; // yangi canvas'da 2d context brauzerlarda doim mavjud
Hamma holatda savol bitta: "Bu null bo'lishi uchun dasturda xato bo'lishi kerakmi?" Ha bo'lsa — ! mumkin. Agar null normal holat bo'lsa (foydalanuvchi topilmadi, ma'lumot hali kelmadi) — ! emas, tekshiruv kerak.
4. ! va boshqa usullar
null/undefined bilan ishlashning to'rt usuli bor, ularning har biri boshqa vaziyat uchun.
declare const user: { name: string } | undefined;
user!.name; // "bor, ishon" — tekshiruvsiz
user?.name; // bor bo'lsa name, yo'q bo'lsa undefined
user?.name ?? "Mehmon"; // yo'q bo'lsa — default qiymat
if (user) user.name; // tekshirib, keyin ishlatish
| Usul | Runtime tekshiruv | undefined bo'lsa nima bo'ladi |
Qachon |
|---|---|---|---|
x! |
❌ | 💥 xato | qiymat mantiqan doim bor |
x?.prop |
✅ | undefined qaytadi |
yo'q bo'lishi normal |
x ?? def |
✅ | default ishlatiladi | o'rinbosar qiymat bor |
if (x) |
✅ | blok bajarilmaydi | ikki holat uchun turli mantiq |
5. Definite assignment: let x!: Type
!ning yana bir ishlatilishi bor — o'zgaruvchi nomidan keyin. Bu boshqa ma'no: "bu o'zgaruvchiga ishlatilishidan oldin albatta qiymat beriladi".
type Config = { port: number };
let config: Config;
initConfig();
console.log(config.port);
// ❌ Variable 'config' is used before being assigned.
function initConfig() {
config = { port: 3000 };
}
TS initConfig() ichida qiymat berilishini kuzatmaydi — u chaqirilgan funksiyalar ichiga kirib qaramaydi, faqat joriy kod oqimini tahlil qiladi.
// ✅ Definite assignment assertion
let config!: Config;
initConfig();
console.log(config.port); // ✅
| Yozilish | Joyi | Ma'nosi |
|---|---|---|
value! |
ifodadan keyin | "bu null/undefined emas" |
let value!: T |
o'zgaruvchi nomidan keyin | "bunga oldinroq qiymat beriladi" |
6. Ko'p ! — ogohlantiruvchi belgi
Bir qatorda bir nechta ! bo'lsa, odatda type'lar noto'g'ri tuzilgan yoki tekshiruv yetishmayapti.
// 🐛 Har bir ! — runtime'dagi potensial xato nuqtasi
const city = user!.profile!.address!.city;
// ✅ Optional chaining — biror bo'g'in yo'q bo'lsa, undefined
const city2 = user?.profile?.address?.city;
Ko'p jamoalar ESLint'dagi no-non-null-assertion qoidasi bilan !ni umuman taqiqlaydi yoki har bir ishlatilishiga izoh talab qiladi.
Eng ko'p uchraydigan xato
find() natijasiga ! qo'yish.
type User = { id: number; name: string };
const users: User[] = [
{ id: 1, name: "Ali" },
{ id: 2, name: "Vali" },
];
function getUserName(id: number) {
const user = users.find((u) => u.id === id);
return user.name;
// ❌ 'user' is possibly 'undefined'.
}
Dasturchi o'ylaydi: "id doim mavjud foydalanuvchidan keladi" va ! qo'yadi:
function getUserName(id: number) {
const user = users.find((u) => u.id === id)!; // 🐛 TS jim
return user.name;
}
getUserName(3); // 💥 Cannot read properties of undefined (reading 'name')
Nega bunday bo'ladi? find() topmasa undefined qaytaradi — bu xato emas, normal natija. Bugun id haqiqatan doim mavjud bo'lishi mumkin, lekin keyinroq: foydalanuvchi o'chiriladi, id URL'dan keladi, ma'lumot serverdan hali yuklanmagan bo'ladi. ! bu holatlarning hammasini yashiradi va xato ilova "qulagan" joyda emas, ancha keyin, tushunarsiz xabar bilan chiqadi.
// ✅ 1-yechim: topilmagan holatni ishlash
function getUserName(id: number): string {
const user = users.find((u) => u.id === id);
if (!user) return "Noma'lum foydalanuvchi";
return user.name; // user: User
}
// ✅ 2-yechim: topilmasa — tushunarli xato (haqiqatan bo'lmasligi kerak bo'lsa)
function getUserNameStrict(id: number): string {
const user = users.find((u) => u.id === id);
if (!user) throw new Error(`Foydalanuvchi topilmadi: id=${id}`);
return user.name;
}
// ✅ 3-yechim: undefined'ni yuqoriga qaytarish — qaror chaqiruvchida
function findUserName(id: number): string | undefined {
return users.find((u) => u.id === id)?.name;
}
2-yechim ! bilan bir xil "bo'lishi kerak emas" fikrini bildiradi, lekin farqi katta: xato aynan sabab bo'lgan joyda, aniq xabar bilan chiqadi. Bu tekshiruvni keyinchalik qayta ishlatiladigan funksiyaga (assertion function) chiqarish ham mumkin.
Esda tuting: ! faqat "null bo'lishi — dasturdagi xato" degan joyda o'rinli; null normal natija bo'lsa, uni ! bilan yashirmasdan ishlang.