Asinxron dasturlash

Asinxron dasturlash nima?

Node.js da asinxron operatsiyalar fayl kiritish-chiqarish yoki tarmoq so‘rovlari kabi vazifalar tugashini kutayotganda dasturingizga boshqa ishlarni bajarish imkonini beradi.

Bu bloklanmaydigan yondashuv Node.js-ga minglab bir vaqtda ulanishlarni samarali boshqarish imkonini beradi.

Sinxronizatsiya va Async: asosiy farqlar

Sinxron

Tugallanmaguncha bajarilishini bloklaydi
Tushunish uchun oddiy
Kechikishlarga olib kelishi mumkin
readFileSync kabi funksiyalardan foydalanadi

Asinxron

Bloklanmagan ijro
Yaxshiroq ishlash
Ishlash murakkabroq
Callback-lar, Promiselar yoki sinxronlash/kutishdan foydalanadi

Misol: Sinxron faylni o‘qish

const fs = require('fs');

console.log('1. Starting sync read...');
const data = fs.readFileSync('myfile.txt', 'utf8');
console.log('2. File contents:', data);
console.log('3. Done reading file');

Misolni ishga tushirish »

Chiqish quyidagi tartibda bo‘ladi: 1 → 2 → 3 (har bir qadam orasidagi bloklar)

Misol: Asinxron faylni o‘qish

const fs = require('fs');

console.log('1. Starting async read...');
fs.readFile('myfile.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log('2. File contents:', data);
});

console.log('3. Done starting read operation');

Misolni ishga tushirish »

Chiqish tartibi: 1 → 3 → 2 (faylni o‘qish tugashini kutmaydi)

Callback hell (Callback-lar girdobi) muammosidan qochish

Muammo: o‘rnatilgan callback funksiyasilar (callback funksiyasi jahannami)

getUser(userId, (err, user) => {
  if (err) return handleError(err);
  getOrders(user.id, (err, orders) => {
    if (err) return handleError(err);
    processOrders(orders, (err) => {
      if (err) return handleError(err);
      console.log('All done!');
    });
  });
});

Yechim: Promiselardan foydalaning

getUser(userId)
  .then(user => getOrders(user.id))
  .then(orders => processOrders(orders))
  .then(() => console.log('All done!'))
  .catch(handleError);

Bundan ham yaxshiroq: Asinx/Kutish

async function processUser(userId) {
  try {
    const user = await getUser(userId);
    const orders = await getOrders(user.id);
    await processOrders(orders);
    console.log('All done!');
  } catch (err) {
    handleError(err);
  }
}

Zamonaviy async naqshlari

1. Promiselar

const fs = require('fs').promises;

console.log('1. Reading file...');
fs.readFile('myfile.txt', 'utf8')
  .then(data => {
    console.log('3. File content:', data);
  })
  .catch(err => console.error('Error:', err));

console.log('2. This runs before file is read!');

2. Async/Await (tavsiya etiladi)

async function readFiles() {
  try {
    console.log('1. Starting to read files...');
    const data1 = await fs.readFile('file1.txt', 'utf8');
    const data2 = await fs.readFile('file2.txt', 'utf8');
    console.log('2. Files read successfully!');
    return { data1, data2 };
  } catch (error) {
    console.error('Error reading files:', error);
  }
}

Eng yaxshi amaliyotlar

Buni qiling

// Use async/await for better readability
async function getUserData(userId) {
  try {
    const user = await User.findById(userId);
    const orders = await Order.find({ userId });
    return { user, orders };
  } catch (error) {     console.error('Failed to fetch user data:', error);
    throw error; // Re-throw or handle appropriately
  }
}

Bu emas

// Nested callbacks are hard to read and maintain
User.findById(userId, (err, user) => {
  if (err) return console.error(err);
  Order.find({ userId }, (err, orders) => {
    if (err) return console.error(err);
    // Process orders...
  });
});

Asosiy xulosalar

✅ Yaxshiroq o‘qilishi uchun async/await dan foydalaning
✅ Xatolarni har doim try/catch bilan hal qiling
✅ Promise.all bilan parallel ravishda mustaqil operatsiyalarni bajaring
❌ Sinxronlash va asinx kod namunalarini aralashtirishdan saqlaning
❌ await Promise berishni unutmang

Misol: Parallel bajarish

// Run multiple async operations in parallel
async function fetchAllData() {
  try {
    const [users, products, orders] = await Promise.all([
      User.find(),
      Product.find(),
      Order.find()
    ]);
    return { users, products, orders };
  } catch (error) {
    console.error('Error fetching data:', error);
    throw error;
  }
}

Nima uchun asinxron koddan foydalanish kerak?

Asinxron kod Node.js-ga fayl yoki ma’lumotlar bazasiga kirish kabi sekin operatsiyalarni kutmasdan bir vaqtning o‘zida bir nechta so‘rovlarni bajarishga imkon beradi.

Bu Node.js-ni serverlar va real vaqtda ilovalar uchun ajoyib qiladi.

Xulosa

Node.js da asinxron dasturlash

Node.js bloklanmaydigan kiritish/chiqarish uchun voqea siklidan foydalanadi
Zamonaviy asinxron kod Promiselar bilan async/await dan foydalanadi
Har doim sinxronlash operatsiyalarida xatolar bilan shug‘ullaning
Parallel operatsiyalar uchun Promise.all dan foydalaning
Tegishli async naqshlari bilan callback funksiyasi qilishdan saqlaning

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tish Kirish