Series: TypeScript Basics Lesson 39

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.