Series: TypeScript Basics Lesson 32

Optional callback

TypeScript'da ixtiyoriy callback'lar: ?.() bilan chaqirish, if va typeof narrowing, no-op default, cb?: va cb: F | undefined farqi, options obyekti va ! operatori xavfi.

32-dars

Optional callback

Ko'p funksiyalarda callback majburiy emas: foydalanuvchi natijani bilmoqchi bo'lsa beradi, bo'lmasa yo'q. Bunday holatda callback'ni majburiy qilish chaqiruvchini bo'sh funksiya yozishga majburlaydi.

// ❌ Muammo: callback majburiy, lekin ko'pincha kerak emas
function saveFile(name: string, onSaved: () => void) {
  console.log(`${name} saqlandi`);
  onSaved();
}

saveFile("a.txt", () => {}); // har safar bo'sh funksiya yozish kerak
saveFile("b.txt");
// ❌ Expected 2 arguments, but got 1.
// ✅ Yechim: callback'ni optional qilamiz va chaqirishdan oldin tekshiramiz
function saveFile(name: string, onSaved?: () => void) {
  console.log(`${name} saqlandi`);
  onSaved?.(); // bor bo'lsa chaqiriladi, yo'q bo'lsa hech narsa bo'lmaydi
}

saveFile("a.txt");                              // ✅
saveFile("b.txt", () => console.log("Tayyor")); // ✅

Qanday ishlaydi?

1. ? belgisi callback'ni | undefined qiladi

Optional parametr qoidasi callback'larga ham tegishli: onSaved?: () => void aslida (() => void) | undefined type'iga ega bo'ladi. Shuning uchun uni to'g'ridan-to'g'ri chaqirib bo'lmaydi.

function saveFile(name: string, onSaved?: () => void) {
  onSaved();
  // ❌ Cannot invoke an object which is possibly 'undefined'.
}

Bu xato faqat strictNullChecks yoqilganda chiqadi. U o'chiq bo'lsa, TS indamaydi va dastur runtime'da TypeError: onSaved is not a function bilan yiqiladi.

2. Chaqirishning uch usuli

function handle(data: string, onDone?: (result: string) => void) {
  const result = data.toUpperCase();

  // 1-usul: optional call
  onDone?.(result);

  // 2-usul: if bilan narrowing
  if (onDone) {
    onDone(result); // bu yerda onDone: (result: string) => void
  }

  // 3-usul: typeof tekshiruvi
  if (typeof onDone === "function") {
    onDone(result);
  }
}

Ko'p hollarda ?.() eng qisqa va o'qilishi oson usul. if esa callback chaqirilishidan oldin yoki keyin boshqa ish ham qilish kerak bo'lganda qulay.

3. Default qiymat bilan: bo'sh funksiya (no-op)

Callback ko'p joyda chaqirilsa, har safar tekshirish o'rniga default qiymat berish mumkin:

function upload(
  file: string,
  onProgress: (percent: number) => void = () => {} // no-op default
) {
  onProgress(0);   // ✅ tekshiruv shart emas — u doim funksiya
  onProgress(50);
  onProgress(100);
}

upload("rasm.png");                               // ✅ default ishlaydi
upload("video.mp4", (p) => console.log(`${p}%`)); // ✅

Funksiya ichida onProgress endi undefined bo'lmaydi, chunki default qiymat o'rnini egallaydi.

4. cb?: va cb: F | undefined farqi

Ikkalasi ichkarida bir xil type beradi, lekin chaqiruvchi uchun farq bor.

function a(onDone?: () => void) {}
function b(onDone: (() => void) | undefined) {}

a();          // ✅ argumentni umuman bermasa ham bo'ladi
b();          // ❌ Expected 1 arguments, but got 0.
b(undefined); // ✅ undefined'ni aniq yozish shart
Yozilishi Argumentsiz chaqirish Ichkaridagi type Tekshiruv kerakmi?
cb?: F ✅ F | undefined ✅ ha
cb: F | undefined ❌ F | undefined ✅ ha
cb: F = () => {} ✅ F ❌ yo'q

Qavslarga e'tibor bering: () => void | undefined — bu "void | undefined qaytaradigan funksiya". Callback'ning o'zi undefined bo'lishi uchun (() => void) | undefined deb qavsga olish kerak.

5. Options obyekti ichidagi optional callback'lar

Callback'lar ko'payganda ularni bitta obyektga yig'ish odatiy usul:

type FetchOptions = {
  url: string;
  onSuccess?: (data: string) => void;
  onError?: (error: Error) => void;
  onFinally?: () => void;
};

function request({ url, onSuccess, onError, onFinally }: FetchOptions) {
  try {
    const data = `Javob: ${url}`;
    onSuccess?.(data);
  } catch (e) {
    onError?.(e as Error);
  } finally {
    onFinally?.();
  }
}

request({ url: "/users" });                                   // ✅
request({ url: "/users", onSuccess: (d) => console.log(d) }); // ✅ d: string — contextual typing

React'dagi onClick?, onChange? kabi props aynan shu tarzda ishlaydi.

6. Optional callback'ning qaytgan qiymati

Callback qiymat qaytarsa, ?.() natijasi undefined bo'lishi ham mumkin.

function format(value: number, formatter?: (n: number) => string) {
  const text = formatter?.(value); // text: string | undefined
  return text ?? String(value);    // ✅ formatter yo'q bo'lsa — oddiy string
}

🐛 Mantiqiy xato: funksiyani if ichida chaqirishni unutish.

function run(isReady: () => boolean) {
  if (isReady) {
    // ❌ This condition will always return true since this function is always defined. Did you mean to call it instead?
    console.log("Boshlandi");
  }
}

Bu yerda TS yordam beradi. Lekin isReady optional bo'lsa (isReady?: () => boolean), if (isReady) to'g'ri tekshiruv hisoblanadi va TS indamaydi. Shunda funksiya bor-yo'qligi tekshiriladi, natijasi esa hech qachon olinmaydi:

function run(isReady?: () => boolean) {
  if (isReady) {
    console.log("Boshlandi"); // 🐛 isReady false qaytarsa ham ishlaydi
  }

  // ✅ Natijani tekshirish kerak
  if (isReady?.()) {
    console.log("Boshlandi");
  }
}

Eng ko'p uchraydigan xato

Optional callback'dagi xatoni ! bilan "o'chirish". Dasturchi callback'ni optional qiladi, keyin uni chaqirganda xatoga duch keladi:

function deleteUser(id: number, onDeleted?: (id: number) => void) {
  // ... o'chirish
  onDeleted(id);
  // ❌ Cannot invoke an object which is possibly 'undefined'.
}

Va eng tez "yechim"ni tanlaydi:

function deleteUser(id: number, onDeleted?: (id: number) => void) {
  onDeleted!(id); // 🐛 TS jim, lekin runtime'da yiqiladi
}

deleteUser(5); // 💥 TypeError: onDeleted is not a function

Nega bunday bo'ladi? Non-null assertion ! TS'ga "menga ishon, bu undefined emas" deydi. Lekin callback'ni optional qilgansiz, demak undefined bo'lishi rejalashtirilgan holat. ! xatoni yo'qotmaydi, faqat uni compile-time'dan runtime'ga ko'chiradi. Bu odatda testda emas, birinchi marta callback'siz chaqirilganda chiqadi.

// ✅ 1-yechim: optional call
function deleteUser(id: number, onDeleted?: (id: number) => void) {
  onDeleted?.(id);
}

// ✅ 2-yechim: default no-op
function deleteUser2(id: number, onDeleted: (id: number) => void = () => {}) {
  onDeleted(id);
}

// ✅ 3-yechim: callback haqiqatan kerak bo'lsa — uni majburiy qiling
function deleteUser3(id: number, onDeleted: (id: number) => void) {
  onDeleted(id);
}

Agar ! yozishga qo'lingiz borayotgan bo'lsa, o'zingizga savol bering: callback haqiqatan optionalmi? Yo'q bo'lsa, ?ni olib tashlang. Ha bo'lsa, ?.() yozing.

Esda tuting: optional callback'ni ?.(), if yoki default qiymat bilan chaqiring — ! uni xavfsiz qilmaydi, faqat xatoni yashiradi.