# JavaScript callback funksiyalar

> Callback nima: funksiyani argument sifatida uzatish, sinxron va asinxron callback, setTimeout hamda callback hell muammosi va undan chiqish yo'li.

Manba: https://learncode.uz/javascript/callback/
Sana: 2026-06-01

JavaScript'da funksiya ham qiymat: uni o'zgaruvchiga berish, massivga solish
va **boshqa funksiyaga uzatish** mumkin. Oxirgisi — callback, va u asinxron
kodning poydevori.

## Funksiya — qiymat

```js
function greet() {
  return "Salom!";
}

console.log(greet);
console.log(greet());

const copy = greet;
console.log(copy());
```

Qavssiz `greet` — funksiyaning **o'zi**; qavs bilan `greet()` — uni
**chaqirish natijasi**. Bu farq callback'da hal qiluvchi.

## Callback uzatish

```js
function run(task) {
  console.log("Boshlandi");
  task();
  console.log("Tugadi");
}

run(() => {
  console.log("  → asosiy ish");
});
```

`run` funksiyasi o'ziga berilgan funksiyani **o'zi chaqiradi**. Bu qachon
va necha marta chaqirishni tashqaridagi funksiya hal qilishini anglatadi.

> **Atama**
>
> **Callback** — boshqa funksiyaga argument sifatida uzatiladigan va o'sha
> funksiya tomonidan keyin chaqiriladigan funksiya. Nomi "qayta chaqirish"
> degani: siz bermaysiz-u chaqirmaysiz — chaqirishni boshqasiga topshirasiz.

## Callback bilan moslashuvchan funksiya

Callback bir funksiyani turli vazifalarga moslaydi:

```js
function mapWith(arr, action) {
  const result = [];
  for (const el of arr) {
    result.push(action(el));
  }
  return result;
}

const numbers = [1, 2, 3, 4];

console.log(mapWith(numbers, n => n * 2));
console.log(mapWith(numbers, n => n * n));
console.log(mapWith(numbers, n => "№" + n));
```

Bitta `qayta` funksiyasi — uch xil natija. Aynan shu tamoyil ustiga
[massiv metodlari](https://learncode.uz/javascript/massiv-metodlari) qurilgan.

## Asinxron callback — setTimeout

Shu paytgacha kod yuqoridan pastga ketma-ket bajarildi. `setTimeout` esa
callback'ni **keyinroq** chaqiradi:

```js
console.log("1 — birinchi");

setTimeout(() => {
  console.log("3 — bir soniyadan keyin");
}, 1000);

console.log("2 — ikkinchi");
```

Tartibga e'tibor bering: `2` `3` dan oldin chiqdi. `setTimeout` kodni
**to'xtatmaydi** — u callback'ni navbatga qo'yadi va keyingi qatorga o'tadi.

> **Millisekund**
>
> Ikkinchi argument — **millisekund**: `1000` = 1 soniya. Bu "aynan shuncha
> vaqtdan keyin" emas, "shuncha vaqtdan keyin **eng erta**" degani — asosiy
> kod band bo'lsa, callback kutadi.

## Natijani callback orqali qaytarish

Asinxron funksiya natijani `return` bilan qaytara olmaydi:

```js
function loadData() {
  setTimeout(() => {
    return "ma'lumot";
  }, 500);
}

console.log(loadData());
```

`undefined` chiqdi — `malumotOl` `setTimeout` ni ishga tushirib, javob
kelishini kutmasdan tugadi. Yechim: natijani callback'ga **uzatish**:

```js
function loadData(callback) {
  setTimeout(() => {
    callback("ma'lumot");
  }, 500);
}

loadData((result) => {
  console.log("Keldi:", result);
});
```

## Xatoni ham uzatish

An'anaviy yondashuv — callback'ning **birinchi** argumenti xato:

```js
function divide(a, b, callback) {
  if (b === 0) {
    callback("Nolga bo'lib bo'lmaydi", null);
    return;
  }
  callback(null, a / b);
}

divide(10, 2, (error, result) => {
  if (error) console.log("Xato:", error);
  else console.log("Natija:", result);
});

divide(10, 0, (error, result) => {
  if (error) console.log("Xato:", error);
  else console.log("Natija:", result);
});
```

## Callback hell

Bir necha asinxron amal ketma-ket kerak bo'lsa, callback'lar ichma-ich
joylashadi:

```js
loadData((user) => {
  buyurtmalarOl(user, (buyurtmalar) => {
    tafsilotOl(buyurtmalar[0], (tafsilot) => {
      console.log(tafsilot);
    });
  });
});
```

Har qadamda chuqurlik oshadi, xato ushlash qiyinlashadi. Bu naqsh
**callback hell** (yoki "halokat piramidasi") deb ataladi.

Aynan shu muammoni hal qilish uchun [Promise](https://learncode.uz/javascript/promise)
yaratilgan — keyingi darsning mavzusi.

## Amaliy mashq

1. Funksiyani o'zgaruvchiga bering va o'zgaruvchi orqali chaqiring;
2. massivdagi har elementga callback qo'llaydigan funksiya yozing;
3. `setTimeout` bilan 2 soniyadan keyin xabar chiqaring;
4. callback'ga natija uzatadigan asinxron funksiya yozing;
5. `(xato, natija)` naqshi bilan yoshni tekshiruvchi funksiya tuzing;
6. `setTimeout` ni `0` ms bilan yozib, u baribir oxirida chiqishini ko'ring.

6-qadam JavaScript'ning navbat tizimini ko'rsatadi.

## Qisqacha xulosa

- Funksiya — qiymat: uzatish, saqlash va qaytarish mumkin.
- **Callback** — boshqa funksiyaga uzatiladigan va u chaqiradigan funksiya.
- Qavssiz `f` — funksiyaning o'zi, `f()` — chaqiruv natijasi.
- `setTimeout` callback'ni navbatga qo'yadi, kodni to'xtatmaydi.
- Asinxron natija `return` bilan emas, callback orqali qaytariladi.
- Ichma-ich callback'lar **callback hell** ga olib keladi.

Keyingi darsda [Promise](https://learncode.uz/javascript/promise) — shu muammoning yechimi.