Series: TypeScript Basics Lesson 31

Callback typing

TypeScript'da callback'larni type'lash: inline va alias type, contextual typing, kamroq parametr qoidasi, void qaytaradigan callback, error-first callback va optional parametr xatosi.

31-dars

Callback typing

Callback — boshqa funksiyaga argument sifatida beriladigan funksiya. Uning type'i aniq yozilmasa, TS na callback'ni chaqirish tomonini, na uni yozish tomonini tekshira oladi.

// ❌ Muammo: callback type'i juda keng
function loadUser(id: number, onDone: Function) {
  const user = { id, name: "Ali" };
  onDone("xato", 42, true); // TS indamaydi — istalgan argument ketadi
}

loadUser(1, (user) => {
  // ❌ Parameter 'user' implicitly has an 'any' type.
  console.log(user.nmae); // 🐛 imlo xatosi ham ushlanmaydi
});

Function type'i "qandaydir funksiya" degani xolos. Parametrlar ham, qaytariladigan qiymat ham any bo'lib qoladi.

// ✅ Yechim: callback'ning to'liq "shakli"ni yozamiz
type User = { id: number; name: string };

function loadUser(id: number, onDone: (user: User) => void) {
  const user: User = { id, name: "Ali" };
  onDone(user);           // ✅ to'g'ri
  // onDone("xato");      // ❌ Argument of type 'string' is not assignable to parameter of type 'User'.
}

loadUser(1, (user) => {
  console.log(user.name); // ✅ user avtomatik User bo'ldi
  // user.nmae            // ❌ Property 'nmae' does not exist on type 'User'. Did you mean 'name'?
});

Endi ikki tomon ham himoyalangan: funksiya callback'ni to'g'ri argument bilan chaqiradi, callback esa to'g'ri type'dagi qiymatni oladi.

Qanday ishlaydi?

1. Inline callback type

Eng oddiy usul: parametr type'i o'rniga to'g'ridan-to'g'ri function type yoziladi.

function eachItem(
  items: string[],
  cb: (item: string, index: number) => void
) {
  for (let i = 0; i < items.length; i++) {
    cb(items[i], i);
  }
}

eachItem(["olma", "nok"], (item, index) => {
  console.log(`${index}: ${item.toUpperCase()}`);
});

2. Type alias bilan qayta ishlatish

Callback type'i uzun bo'lsa yoki bir necha joyda ishlatilsa, uni alias'ga chiqaramiz.

type OnSuccess = (data: User) => void;
type OnError = (error: Error) => void;

function fetchUser(id: number, onSuccess: OnSuccess, onError: OnError) {
  if (id <= 0) {
    onError(new Error("Noto'g'ri id"));
    return;
  }
  onSuccess({ id, name: "Vali" });
}

Alias funksiya imzosini o'qishni osonlashtiradi: fetchUser nima qilishi parametr nomlaridan ko'rinib turadi.

3. Contextual typing: callback parametrlari o'zi aniqlanadi

Callback'ga annotatsiya yozish shart emas. TS parametr type'larini callback berilayotgan joydan oladi.

eachItem(["a", "b"], (item, index) => {
  // item: string, index: number — avtomatik
  // item.toFixed(2); // ❌ Property 'toFixed' does not exist on type 'string'.
});

// Annotatsiya yozsangiz, u kutilgan type bilan mos bo'lishi kerak
eachItem(["a"], (item: number) => {});
// ❌ Argument of type '(item: number) => void' is not assignable to parameter of type '(item: string, index: number) => void'.
//      Types of parameters 'item' and 'item' are incompatible.

Lekin callback alohida o'zgaruvchiga olinsa, kontekst yo'qoladi:

const handler = (item) => {}; // ❌ Parameter 'item' implicitly has an 'any' type.

// ✅ O'zgaruvchiga callback type'ini beramiz
const handler2: (item: string, index: number) => void = (item) => {
  console.log(item.length);
};

4. Callback kamroq parametr olishi mumkin, chaqiruvchi esa yo'q

Callback kutilganidan kamroq parametr e'lon qilishi mumkin.

eachItem(["x", "y"], (item) => console.log(item)); // ✅ index kerak emas, yozmaymiz
eachItem(["x", "y"], () => console.log("salom"));  // ✅ hech narsa olmaydi

[1, 2, 3].map((n) => n * 2); // ✅ map 3 ta argument beradi, biz 1 tasini olamiz

Teskari tomon esa qat'iy: callback'ni chaqirayotgan funksiya hamma majburiy argumentlarni berishi kerak.

function eachItemBad(items: string[], cb: (item: string, index: number) => void) {
  for (const item of items) {
    cb(item); // ❌ Expected 2 arguments, but got 1.
  }
}
Tomon Kamroq parametr Ko'proq parametr
Callback yozuvchi (e'lon qiladi) ✅ mumkin ❌ mumkin emas
Callback chaqiruvchi (argument beradi) ❌ mumkin emas ❌ mumkin emas

5. void qaytaradigan callback'ga qiymat qaytaradigan funksiya berish

Callback type'i => void bo'lsa, unga qiymat qaytaradigan funksiyani ham berish mumkin. void bu yerda "qaytgan qiymat ishlatilmaydi" degani.

const result: number[] = [];
[1, 2, 3].forEach((n) => result.push(n)); // ✅ push number qaytaradi, lekin forEach uni e'tiborsiz qoldiradi

Shuning uchun qaytgan qiymat sizga kerak bo'lsa, callback type'ini void qilib qo'ymang — TS uni ishlatishga yo'l qo'ymaydi:

function runCheck(check: (value: number) => void) {
  const ok = check(10); // ok: void
  if (ok) {
    // ❌ An expression of type 'void' cannot be tested for truthiness.
    console.log("O'tdi");
  }
}

// ✅ Natija kerak bo'lsa, uni type'da aniq yozamiz
function runCheck2(check: (value: number) => boolean) {
  if (check(10)) console.log("O'tdi");
}

runCheck2((v) => v > 5);   // ✅
// runCheck2((v) => {});   // ❌ Type 'void' is not assignable to type 'boolean'.

6. Error-first callback (Node.js uslubi)

Eski Node.js API'larida birinchi argument — xato, ikkinchisi — natija.

type NodeCallback = (err: Error | null, data: string | null) => void;

function readConfig(path: string, cb: NodeCallback) {
  if (path === "") {
    cb(new Error("Yo'l bo'sh"), null);
    return;
  }
  cb(null, "port=3000");
}

readConfig("app.conf", (err, data) => {
  if (err) {
    console.error(err.message);
    return;
  }
  // data.trim(); // ❌ 'data' is possibly 'null'.
  console.log(data?.trim());
});

TS err tekshirilgandan keyin data albatta bor ekanini bilmaydi, chunki ikki parametr bir-biriga bog'lanmagan. Bu muammoni discriminated union va Result pattern to'liq hal qiladi.

Eng ko'p uchraydigan xato

Callback type'idagi parametrni "ehtiyot shart" optional qilish. Dasturchi shunday o'ylaydi: "Callback yozadigan odamga index kerak bo'lmasligi mumkin, demak uni ? bilan optional qilay." Natijada:

// ❌ index? — xato fikr
function eachItem(items: string[], cb: (item: string, index?: number) => void) {
  items.forEach((item, i) => cb(item, i));
}

eachItem(["a", "b"], (item, index) => {
  console.log(index.toFixed(0));
  // ❌ 'index' is possibly 'undefined'.
});

Nega bunday bo'ladi? Callback type'idagi index? "callback'ni chaqiruvchi indexni bermasligi mumkin" degan ma'noni bildiradi. Siz esa aslida "callback yozuvchi indexni olmasligi mumkin" demoqchi edingiz. Buning uchun hech narsa qilish kerak emas, chunki kamroq parametr e'lon qilish allaqachon ruxsat etilgan. Natijada index har doim berilsa ham, callback ichida u number | undefined bo'lib qoladi va har safar tekshirishga to'g'ri keladi.

// ✅ Yechim: chaqiruvchi doim beradigan parametrni majburiy qilamiz
function eachItem(items: string[], cb: (item: string, index: number) => void) {
  items.forEach((item, i) => cb(item, i));
}

eachItem(["a"], (item, index) => console.log(index.toFixed(0))); // ✅ index: number
eachItem(["a"], (item) => console.log(item));                    // ✅ index'ni olmasa ham bo'ladi

Parametr faqat chaqiruvchi uni haqiqatan ham ba'zan bermasa optional bo'lishi kerak. Bu holda callback ichidagi tekshiruv ham asosli bo'ladi.

Esda tuting: callback type'idagi ? chaqiruvchi haqida gapiradi, callback yozuvchi haqida emas; kamroq parametr olish uchun hech qachon ? kerak emas.