# JavaScript Promise nima va qanday ishlaydi

> Promise: pending, fulfilled va rejected holatlari, then va catch zanjiri, Promise yaratish hamda callback hell'dan qutulish. Amaliy misollar bilan.

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

[Callback hell](https://learncode.uz/javascript/callback) — ichma-ich callback'lardan iborat
o'qib bo'lmaydigan kod. **Promise** shu muammoni hal qiladi: asinxron
natijani obyekt sifatida ifodalaydi va zanjir bilan yozishga imkon beradi.

## Promise nima

Promise — "kelajakda keladigan qiymat" uchun idish. Buyurtma chekiga o'xshaydi:
ovqat hali tayyor emas, lekin qo'lingizda **keyin olishingiz** haqidagi
kafolat bor.

> **Atama**
>
> **Promise** ("va'da") — asinxron amalning natijasini ifodalovchi obyekt. U
> uch holatdan birida bo'ladi: **pending** (kutilmoqda), **fulfilled**
> (bajarildi, qiymat bor) yoki **rejected** (rad etildi, xato bor).
> Holat bir marta o'zgaradi va **orqaga qaytmaydi**.

## then bilan natijani olish

```js
const promise = new Promise((resolve) => {
  setTimeout(() => {
    resolve("Ma'lumot keldi");
  }, 500);
});

console.log(promise);

promise.then((result) => {
  console.log(result);
});

console.log("Bu oldin chiqadi");
```

Birinchi `console.log` `Promise { <pending> }` ko'rsatdi — javob hali yo'q.
`then` esa natija tayyor bo'lganda chaqiriladigan callback'ni qayd qiladi.

## Promise yaratish

`new Promise` ikkita funksiya beradi: birinchisi muvaffaqiyat, ikkinchisi xato
uchun:

```js
function divide(a, b) {
  return new Promise((resolve, reject) => {
    if (b === 0) {
      reject(new Error("Nolga bo'lib bo'lmaydi"));
    } else {
      resolve(a / b);
    }
  });
}

divide(10, 2).then((n) => console.log("Natija:", n));

divide(10, 0).catch((e) => console.log("Xato:", e.message));
```

An'anaviy nomlar — `resolve` va `reject`. Bu yerda ma'nosi ko'rinishi uchun
o'zbekcha nomlangan; ular oddiy parametr, nomi ixtiyoriy.

## catch — xatoni ushlash

```js
const promise = new Promise((resolve, reject) => {
  reject(new Error("Server response bermadi"));
});

promise
  .then((n) => console.log("Bu bajarilmaydi", n))
  .catch((e) => console.log("Ushlandi:", e.message));
```

Xato yuz berganda `then` **o'tkazib yuboriladi** va boshqaruv `catch` ga
tushadi — [try/catch](https://learncode.uz/javascript/xatolar) mantig'i bilan bir xil.

## Zanjir — callback hell yechimi

`then` yangi Promise qaytaradi, shuning uchun ularni **ketma-ket** ulash
mumkin:

```js
function delay(value, ms) {
  return new Promise((resolve) => setTimeout(() => resolve(value), ms));
}

delay(5, 200)
  .then((n) => {
    console.log("1-qadam:", n);
    return n * 2;
  })
  .then((n) => {
    console.log("2-qadam:", n);
    return delay(n + 1, 200);
  })
  .then((n) => {
    console.log("3-qadam:", n);
  })
  .catch((e) => console.log("Xato:", e.message));
```

Chuqurlik oshmadi — qadamlar **tekis** ro'yxat bo'lib qoldi. Callback
variantini eslang: har qadam bir daraja ichkariga kirardi.

`then` ichida nima qaytarilsa, keyingi `then` shuni oladi. Promise
qaytarilsa — zanjir uning javobini **kutadi**.

<Callout type="warning" title="return unutilmasin">
`then` ichida Promise qaytarmasangiz, zanjir uni kutmaydi:

```js
.then(n => { delay(n, 500); })   // ❌ kutmaydi
.then(n => delay(n, 500))        // ✅ kutadi
```
</Callout>

## finally

Natija qanday bo'lishidan qat'i nazar bajariladigan blok:

```js
Promise.reject(new Error("error"))
  .then(() => console.log("done"))
  .catch((e) => console.log("ushlandi:", e.message))
  .finally(() => console.log("yakunlandi"));
```

Odatda yuklanish belgisini o'chirish uchun ishlatiladi.

## Promise.all — parallel kutish

Bir nechta amalni **bir vaqtda** boshlab, hammasini kutish:

```js
function delay(value, ms) {
  return new Promise((resolve) => setTimeout(() => resolve(value), ms));
}

Promise.all([
  delay("A", 300),
  delay("B", 100),
  delay("C", 200),
]).then((natijalar) => {
  console.log(natijalar);
});
```

Natija massivi **berilgan tartibda** qaytadi, tugash tartibida emas. Umumiy
vaqt — eng uzunining vaqti (300 ms), yig'indisi (600 ms) emas.

Bittasi rad etilsa, butun `all` rad etiladi. Hammasining natijasi kerak
bo'lsa — `Promise.allSettled` ishlatiladi:

```js
Promise.allSettled([
  Promise.resolve("done"),
  Promise.reject(new Error("reject etildi")),
]).then((natijalar) => {
  for (const n of natijalar) {
    console.log(n.status, n.value ?? n.reason.message);
  }
});
```

## Tayyor Promise

```js
Promise.resolve(42).then((n) => console.log(n));

Promise.reject(new Error("darhol xato"))
  .catch((e) => console.log(e.message));
```

Qiymat allaqachon ma'lum bo'lganda, uni Promise ichiga o'rash uchun.

## Amaliy mashq

1. 1 soniyadan keyin matn qaytaradigan Promise yozing;
2. shartga qarab `resolve` yoki `reject` chaqiradigan funksiya tuzing;
3. uch qadamli `then` zanjiri yasang — har qadam qiymatni o'zgartirsin;
4. zanjirga `catch` va `finally` qo'shing;
5. `Promise.all` bilan uchta kechikishni parallel ishlatib, vaqtni chamalang;
6. `then` ichida `return` ni olib tashlab, natija qanday buzilishini ko'ring.

6-qadam zanjirdagi eng ko'p uchraydigan xatoni ko'rsatadi.

## Qisqacha xulosa

- **Promise** — kelajakdagi natija uchun obyekt: pending → fulfilled/rejected.
- `then` natijani, `catch` xatoni, `finally` har ikki holatni ushlaydi.
- `then` yangi Promise qaytaradi — shuning uchun zanjir tuziladi.
- Zanjirda Promise qaytarilsa, keyingi qadam uni kutadi.
- `Promise.all` parallel kutadi; `allSettled` hammasining holatini beradi.
- Holat bir marta o'rnatiladi va keyin o'zgarmaydi.

Keyingi darsda [async va await](https://learncode.uz/javascript/async-await) — Promise'ni yanada
sodda yozish usuli.