Async / Await sintaksisi

Async/Await dasturiga kirish

Async/await - bu Node.js-da asinxron operatsiyalarni boshqarishning zamonaviy usuli bo‘lib, yanada o‘qilishi mumkin bo‘lgan kod yaratish uchun Promiselar ustiga qurilgan.

Node.js 7.6 da taqdim etilgan va ES2017 da standartlashtirilgan async/await sizga ko‘proq sinxron kodga o‘xshab ko‘rinadigan va o‘zini tutadigan asinxron kod yozish imkonini beradi.

Async/await asosan o‘qilishi mumkin bo‘lgan sintaksisga ega va’dalardir. Bu sizning kodingizni toza va barqaror qiladi.

async/await asinxron kodni ko‘rinishga olib keladi va ko‘proq sinxron kod kabi his qiladi. U asosiy oqimni bloklamaydi, lekin uni kuzatish va tushunish oson.

Sintaksis va foydalanish

Sintaksis ikkita kalit so‘zdan iborat:

async : Promise-ni qaytaradigan asinxron funksiyani e’lon qilish uchun foydalaniladi
await : Promise hal qilinmaguncha bajarishni to‘xtatib turish uchun foydalaniladi, faqat asinxronizatsiya funksiyalarida foydalanish mumkin

Misol: Asosiy Async/Await

async function getData() {
  console.log('Starting...');
  const result = await someAsyncOperation();
  console.log(`Result: ${result}`);
  return result;
}

function someAsyncOperation() {
  return new Promise(resolve => {
    setTimeout(() => resolve('Operation completed'), 1000);
  });
}

// Call the async function
getData().then(data => console.log('Final data:', data));

Misolni ishga tushirish »

Misol: async/await bilan faylni o‘qish

Misolni ishga tushirish »

Try/Catch bilan ishlashda xatolik

Async/await ning afzalliklaridan biri shundaki, siz xatolarni qayta ishlash uchun an’anaviy try/catch bloklaridan foydalanishingiz mumkin, bu esa kodingizni o‘qilishi mumkin bo‘ladi.

Misol: Async/Await bilan ishlashda xatolik

async function fetchUserData() {
  try {
    const response = await fetch('https://api.example.com/users/1');
    if (!response.ok) {
      throw new Error(`HTTP error: ${response.status}`);
    }
    const user = await response.json();
    console.log('User data:', user);
    return user;
  } catch (error) {
    console.error('Error fetching user data:', error);
    throw error; // Re-throw the error if needed
  }
}

Shuningdek, turli stsenariylar uchun async/await ni Promise .catch() bilan aralashtirishingiz mumkin:

// Using catch with an async function
fetchUserData().catch(error => {
console.log('Caught outside of async function:', error.message);
});

Misolni ishga tushirish »

Parallel Promiselarni bajarish

Garchi async/await kodni sinxron ko‘rinishga olib kelsa-da, ba’zida yaxshi ishlash uchun operatsiyalarni parallel ravishda bajarishingiz kerak bo‘ladi.

Misol: ketma-ket va parallel operatsiyalar

// Helper function to simulate an API call
function fetchData(id) {
  return new Promise(resolve => {
    setTimeout(() => resolve(`Data for ID ${id}`), 1000);
  });
}

// Sequential operation - takes ~3 seconds
async function fetchSequential() {
  console.time('sequential');
  const data1 = await fetchData(1);
  const data2 = await fetchData(2);
  const data3 = await fetchData(3);
  console.timeEnd('sequential');
  return [data1, data2, data3];
}

// Parallel operation - takes ~1 second
async function fetchParallel() {
  console.time('parallel');
  const results = await Promise.all([
    fetchData(1),
    fetchData(2),
    fetchData(3)
  ]);
  console.timeEnd('parallel');
  return results;
}

// Demo
async function runDemo() {
  console.log('Running sequentially...');
  const seqResults = await fetchSequential();
  console.log(seqResults);

  console.log('\nRunning in parallel...');
  const parResults = await fetchParallel();
  console.log(parResults);
}

runDemo();

Misolni ishga tushirish »

Async/Await vs Promises vs Backbacks

Keling, bir xil vazifa turli xil asinxron naqshlar bilan qanday bajarilishini ko‘rib chiqaylik:

Callback-lar bilan

O‘zingiz sinab ko‘ring »

Promiselar bilan

O‘zingiz sinab ko‘ring »

Async/Await bilan

// Using async/await
async function getUserAndPosts() {
  try {
    const user = await getUserPromise(1);
    console.log('User:', user);

    const posts = await getUserPostsPromise(user);
    console.log('Posts:', posts);
  } catch (error) {
    console.error(error);
  }
}

getUserAndPosts();

O‘zingiz sinab ko‘ring »

Naqsh	Pros	Kamchiliklari
Callback-lar	- Tushunish oson - Keng qo‘llab-quvvatlanadi	- Callback hell - Xatolarni qayta ishlash murakkab - Bu haqda mulohaza yuritish qiyin
Promiselar	- .then() bilan zanjir hosil qilish - Xatolarni yaxshiroq qayta ishlash - Birlashtirish qulay	- Hali ham murakkab streamlar uchun joylashtirishni talab qiladi - Async/await kabi o‘qish mumkin emas
Async/Kuting	- Toza, sinxronga o‘xshash kod - Urinish/catch yordamida xatoliklarni oson hal qilish - Nosozliklarni tuzatish osonroq	- Promiselarni tushunishni talab qiladi - Ijroni tasodifan blokirovka qilish oson

Eng yaxshi amaliyotlar

Node.js da async/await bilan ishlashda quyidagi eng yaxshi amaliyotlarga amal qiling:

Remember that async functions always return Promises

async function myFunction() {
return 'Hello';
}

// This returns a Promise that resolves to 'Hello', not the string 'Hello' directly
const result = myFunction();
console.log(result); // Promise { 'Hello' }

// You need to await it or use .then()
myFunction().then(message => console.log(message)); // Hello
Use Promise.all for concurrent operations
Agar operatsiyalar parallel ravishda bajarilsa, unumdorlikni oshirish uchun Promise.all dan foydalaning.
Always handle errors
Sinash/catch bloklaridan foydalaning yoki asinxron funksiya chaqiruviga .catch() zanjirlang.
Avoid mixing async/await with callbacks
Callback-ga asoslangan funksiyalarni util.promisify yoki maxsus o‘ramlardan foydalanib Promisesga aylantiring.

const util = require('util');
const fs = require('fs');

// Convert callback-based function to Promise-based
const readFile = util.promisify(fs.readFile);

async function readFileContents() {
const data = await readFile('file.txt', 'utf8');
return data;
}
Create clean async functions
Sinxronlashtirilgan funksiyalarni bitta mas’uliyatga yo‘naltiring.

Eng yaxshi amaliyot: Node.js 14.8.0 va undan yuqori versiyalarida ECMAScript modullarida (ESM) mavjud bo‘lgan “yuqori darajadagi kutish” funksiyasidan xabardor bo‘ling, bu modul darajasida asinxronizatsiya funksiyalaridan tashqari kutishdan foydalanish imkonini beradi.

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tish Kirish