# JavaScript async va await

> async/await bilan asinxron kodni sinxrondek yozish: await kutish, try/catch bilan xato ushlash, parallel bajarish va keng uchraydigan xatolar.

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

[Promise](https://learncode.uz/javascript/promise) zanjiri callback'dan yaxshi, lekin baribir
`then` ichida yoziladi. `async/await` esa asinxron kodni **oddiy ketma-ket
kod kabi** yozishga imkon beradi.

## then va await — bir xil ish

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

delay("then bilan", 300).then((n) => console.log(n));

async function start() {
  const n = await delay("await bilan", 300);
  console.log(n);
}

start();
```

`await` Promise oldiga qo'yiladi va uning **natijasini** beradi — `then`
callback'i shart emas.

> **Atama**
>
> **async** — funksiyani asinxron deb belgilaydigan kalit so'z. Bunday funksiya
> har doim Promise qaytaradi. **await** — Promise natijasini kutish; faqat
> `async` funksiya ichida (yoki modul yuqori darajasida) ishlaydi.

## async funksiya Promise qaytaradi

```js
async function value() {
  return 42;
}

console.log(value());

value().then((n) => console.log("then orqali:", n));

async function fetchData() {
  console.log("await orqali:", await value());
}
fetchData();
```

`return 42` yozilsa ham, tashqaridan qaralganda `Promise` chiqadi — `async`
qiymatni avtomatik o'raydi.

## Zanjir o'rniga ketma-ket kod

Oldingi darsdagi uch qadamli zanjirni solishtiring:

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

async function process() {
  const a = await delay(5, 200);
  console.log("1-qadam:", a);

  const b = a * 2;
  console.log("2-qadam:", b);

  const c = await delay(b + 1, 200);
  console.log("3-qadam:", c);

  return c;
}

process().then((n) => console.log("Yakun:", n));
```

`then` yo'q, ichma-ich qavs yo'q — kod yuqoridan pastga o'qiladi. Aynan shu
sabab `async/await` bugungi standart usul.

## Xatoni try/catch bilan ushlash

`await` bilan [try/catch](https://learncode.uz/javascript/xatolar) to'g'ridan-to'g'ri ishlaydi:

```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);
  });
}

async function calculate() {
  try {
    console.log(await divide(10, 2));
    console.log(await divide(10, 0));
    console.log("Bu qator bajarilmaydi");
  } catch (error) {
    console.log("Xato:", error.message);
  } finally {
    console.log("Yakunlandi");
  }
}

calculate();
```

Rad etilgan Promise `await` da **xatoga aylanadi** — sinxron koddagi bilan
bir xil tarzda ushlanadi.

## Parallel bajarish — muhim nuqta

Ketma-ket `await` — ketma-ket kutish demak:

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

async function slow() {
  const startTime = Date.now();

  const a = await delay("A", 300);
  const b = await delay("B", 300);
  const c = await delay("C", 300);

  console.log(a, b, c);
  console.log("Vaqt:", Date.now() - startTime, "ms");
}

slow();
```

~900 ms ketdi. Bu uchta amal bir-biriga **bog'liq bo'lmasa** — isrof.

`Promise.all` bilan parallel:

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

async function quick() {
  const startTime = Date.now();

  const [a, b, c] = await Promise.all([
    delay("A", 300),
    delay("B", 300),
    delay("C", 300),
  ]);

  console.log(a, b, c);
  console.log("Vaqt:", Date.now() - startTime, "ms");
}

quick();
```

~300 ms — uch barobar tez. Natijani
[destructuring](https://learncode.uz/javascript/es6-sintaksis) bilan ajratib olindi.

> **Qoida**
>
> Keyingi amal oldingisining natijasiga **muhtoj bo'lsa** — ketma-ket `await`.
> Muhtoj bo'lmasa — `Promise.all`. Bu veb-ilovalarda eng ko'p uchraydigan
> tezlik xatosi.

## Siklda await

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

async function list() {
  const titles = ["A", "B", "C"];

  for (const title of titles) {
    const n = await delay(title, 200);
    console.log("Keldi:", n);
  }

  console.log("Hammasi tugadi");
}

list();
```

`for...of` bilan `await` kutiladi. Ammo `forEach` bilan **ishlamaydi**:

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

async function error() {
  ["A", "B"].forEach(async (title) => {
    const n = await delay(title, 200);
    console.log("Keldi:", n);
  });

  console.log("Bu birinchi chiqadi — kutilmadi!");
}

error();
```

`forEach` callback'ning Promise'ini kutmaydi. Kutish kerak bo'lsa —
`for...of`, parallel kerak bo'lsa — `map` + `Promise.all`.

## Amaliy mashq

1. 1 soniya kutib matn qaytaradigan `async` funksiya yozing;
2. uni `await` bilan chaqirib, natijani chiqaring;
3. rad etiladigan Promise'ni `try/catch` bilan ushlang;
4. uchta kechikishni ketma-ket, so'ng `Promise.all` bilan bajarib, vaqtni
   solishtiring;
5. `for...of` ichida `await` ishlating;
6. shu siklni `forEach` ga almashtirib, tartib buzilishini ko'ring.

4- va 6-qadamlar `async/await` dagi ikki asosiy tuzoqni ko'rsatadi.

## Qisqacha xulosa

- `async` funksiya har doim **Promise** qaytaradi.
- `await` Promise natijasini kutadi va qiymatini beradi.
- Rad etilgan Promise `await` da xatoga aylanadi — `try/catch` ushlaydi.
- Ketma-ket `await` vaqtni qo'shadi; bog'liq bo'lmagan amallar uchun
  `Promise.all` ishlating.
- `for...of` `await` ni kutadi, `forEach` — yo'q.

Keyingi darsda [fetch](https://learncode.uz/javascript/fetch) — serverdan haqiqiy ma'lumot olish.