JavaScript Asinxron Generatorlari: Zamonaviy Ilovalar Uchun Oqimli Ma'lumotlarni Qayta Ishlash

Doimiy rivojlanib borayotgan JavaScript ishlab chiqish olamida asinxron ma'lumotlar oqimlarini samarali boshqarish juda muhimdir. An'anaviy yondashuvlar katta hajmdagi ma'lumotlar to'plamlari yoki real vaqtdagi ma'lumotlar bilan ishlashda qiyinchilik tug'dirishi mumkin. Aynan shu yerda Asinxron Generatorlar o'zini namoyon qilib, oqimli ma'lumotlarni qayta ishlash uchun kuchli va nafis yechimni taqdim etadi.

Asinxron Generatorlar Nima?

Asinxron Generatorlar bu qiymatlarni asinxron ravishda, birma-bir yaratishga imkon beruvchi maxsus turdagi JavaScript funksiyasidir. Ular ikkita kuchli konsepsiyaning birikmasidir: Asinxron Dasturlash va Generatorlar.

• Asinxron Dasturlash: Bloklanmaydigan operatsiyalarni amalga oshiradi, bu esa kodingizga uzoq davom etadigan vazifalar (masalan, tarmoq so'rovlari yoki fayllarni o'qish) tugashini kutayotganda ishlashni davom ettirishga imkon beradi.
• Generatorlar: To'xtatilishi va davom ettirilishi mumkin bo'lgan, qiymatlarni iterativ ravishda qaytaradigan funksiyalar.

Asinxron Generatorni asinxron ravishda qiymatlar ketma-ketligini ishlab chiqaradigan, har bir qiymat qaytarilgandan so'ng ijroni to'xtatib turadigan va keyingi qiymat so'ralganda davom ettiradigan funksiya deb tasavvur qiling.

Asinxron Generatorlarning Asosiy Xususiyatlari:

• Asinxron Qaytarish: Qiymatlarni ishlab chiqarish uchun yield kalit so'zidan va generator ichidagi asinxron operatsiyalarni boshqarish uchun await kalit so'zidan foydalaning.
• Iteratsiya Qilinishi: Asinxron Generatorlar Asinxron Iteratorni qaytaradi, uni for await...of sikllari yordamida iste'mol qilish mumkin.
• "Dangasa" Baholash (Lazy Evaluation): Qiymatlar faqat so'ralganda yaratiladi, bu esa, ayniqsa, katta ma'lumotlar to'plamlari bilan ishlashda unumdorlik va xotiradan foydalanishni yaxshilaydi.
• Xatoliklarni Boshqarish: Generator funksiyasi ichidagi xatoliklarni try...catch bloklari yordamida boshqarishingiz mumkin.

Asinxron Generatorlarni Yaratish

Asinxron Generator yaratish uchun siz async function* sintaksisidan foydalanasiz:

            
async function* myAsyncGenerator() {
  yield await Promise.resolve(1);
  yield await Promise.resolve(2);
  yield await Promise.resolve(3);
}

            

              
                Copy
              
            
          

Keling, bu misolni tahlil qilaylik:

• async function* myAsyncGenerator(): myAsyncGenerator nomli Asinxron Generator funksiyasini e'lon qiladi.
• yield await Promise.resolve(1): Asinxron ravishda 1 qiymatini qaytaradi. await kalit so'zi qiymat qaytarilishidan oldin "promise" bajarilishini ta'minlaydi.

Asinxron Generatorlardan Foydalanish

Siz Asinxron Generatorlardan for await...of sikli yordamida foydalanishingiz mumkin:

            
async function consumeGenerator() {
  for await (const value of myAsyncGenerator()) {
    console.log(value);
  }
}

consumeGenerator(); // Natija: 1, 2, 3 (asinxron ravishda chop etiladi)

            

              
                Copy
              
            
          

for await...of sikli Asinxron Generator tomonidan qaytarilgan qiymatlar bo'yicha iteratsiya qiladi va keyingi iteratsiyaga o'tishdan oldin har bir qiymatning asinxron ravishda bajarilishini kutadi.

Oqimli Qayta Ishlashda Asinxron Generatorlarning Amaliy Misollari

Asinxron Generatorlar ayniqsa oqimli qayta ishlashni o'z ichiga olgan stsenariylar uchun juda mos keladi. Keling, ba'zi amaliy misollarni ko'rib chiqaylik:

1. Katta Fayllarni Asinxron O'qish

Katta fayllarni xotiraga o'qish samarasiz va ko'p xotira talab qilishi mumkin. Asinxron Generatorlar fayllarni bo'laklarga bo'lib ishlashga imkon beradi, bu esa xotira sarfini kamaytiradi va unumdorlikni oshiradi.

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

async function* readFileByLines(filePath) {
  const fileStream = fs.createReadStream(filePath);

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

async function processFile(filePath) {
  for await (const line of readFileByLines(filePath)) {
    // Faylning har bir qatorini qayta ishlash
    console.log(line);
  }
}

processFile('path/to/your/largefile.txt');

            

              
                Copy
              
            
          

Ushbu misolda:

• readFileByLines - bu readline modulidan foydalanib faylni satr-ma-satr o'qiydigan Asinxron Generator.
• fs.createReadStream fayldan o'qish mumkin bo'lgan oqim yaratadi.
• readline.createInterface oqimni satr-ma-satr o'qish uchun interfeys yaratadi.
• for await...of sikli fayl satrlari bo'yicha iteratsiya qilib, har bir satrni asinxron ravishda qaytaradi.
• processFile Asinxron Generatorni iste'mol qiladi va har bir satrni qayta ishlaydi.

Bu yondashuv log fayllari, ma'lumotlar to'plamlari yoki har qanday katta hajmdagi matnga asoslangan ma'lumotlarni qayta ishlash uchun juda foydalidir.

2. API'lardan Sahifalarga Bo'lingan Ma'lumotlarni Olish

Ko'pgina API'lar sahifalash (pagination) ni amalga oshirib, ma'lumotlarni qismlarga bo'lib qaytaradi. Asinxron Generatorlar bir nechta sahifalar bo'ylab ma'lumotlarni olish va qayta ishlash jarayonini soddalashtirishi mumkin.

            
async function* fetchPaginatedData(url, pageSize) {
  let page = 1;
  let hasMore = true;

  while (hasMore) {
    const response = await fetch(`${url}?page=${page}&pageSize=${pageSize}`);
    const data = await response.json();

    if (data.items.length === 0) {
      hasMore = false;
      break;
    }

    for (const item of data.items) {
      yield item;
    }

    page++;
  }
}

async function processData() {
  for await (const item of fetchPaginatedData('https://api.example.com/data', 20)) {
    // Har bir elementni qayta ishlash
    console.log(item);
  }
}

processData();

            

              
                Copy
              
            
          

Ushbu misolda:

• fetchPaginatedData - bu API'dan ma'lumotlarni olib, sahifalashni avtomatik ravishda boshqaradigan Asinxron Generator.
• U har bir sahifadan ma'lumotlarni oladi va har bir elementni alohida qaytaradi.
• Sikl API bo'sh sahifa qaytarguncha davom etadi, bu esa boshqa elementlar yo'qligini bildiradi.
• processData Asinxron Generatorni iste'mol qiladi va har bir elementni qayta ishlaydi.

Bu naqsh Twitter API, GitHub API yoki katta ma'lumotlar to'plamlarini boshqarish uchun sahifalashdan foydalanadigan har qanday API bilan ishlashda keng tarqalgan.

3. Real Vaqtdagi Ma'lumotlar Oqimlarini Qayta Ishlash (masalan, WebSockets)

Asinxron Generatorlar WebSockets yoki Server-Sent Events (SSE) kabi manbalardan real vaqtdagi ma'lumotlar oqimlarini qayta ishlash uchun ishlatilishi mumkin.

            
async function* processWebSocketStream(url) {
  const ws = new WebSocket(url);

  ws.onmessage = (event) => {
    // Odatda, bu yerda ma'lumotlarni navbatga qo'shasiz
    // va `onmessage` ishlovchisini bloklamaslik uchun
    // navbatdan `yield` qilasiz. Oddiylik uchun to'g'ridan-to'g'ri `yield` qilamiz.
    yield JSON.parse(event.data);
  };

  ws.onerror = (error) => {
    console.error('WebSocket xatosi:', error);
  };

  ws.onclose = () => {
    console.log('WebSocket ulanishi yopildi.');
  };

  // Ulanish yopilguncha generatorni faol saqlash.
  // Bu soddalashtirilgan yondashuv; navbatdan foydalanishni
  // va generatorga tugatish signali berish mexanizmini ko'rib chiqing.
  await new Promise(resolve => ws.onclose = resolve); 
}

async function consumeWebSocketData() {
  for await (const data of processWebSocketStream('wss://example.com/websocket')) {
    // Real vaqtdagi ma'lumotlarni qayta ishlash
    console.log(data);
  }
}

consumeWebSocketData();

            

              
                Copy
              
            
          

WebSocket Oqimlari Uchun Muhim Fikrlar:

• Qarshi Bosim (Backpressure): Real vaqtdagi oqimlar iste'molchi qayta ishlay oladiganidan tezroq ma'lumotlarni ishlab chiqarishi mumkin. Iste'molchiga ortiqcha yuk tushishining oldini olish uchun qarshi bosim mexanizmlarini amalga oshiring. Keng tarqalgan yondashuvlardan biri - kiruvchi ma'lumotlarni buferlash uchun navbatdan foydalanish va navbat to'lganida WebSocket'ga ma'lumot yuborishni to'xtatish uchun signal berishdir.
• Xatoliklarni Boshqarish: Ulanish xatolari va ma'lumotlarni tahlil qilish xatolari kabi WebSocket xatolarini to'g'ri boshqaring.
• Ulanishni Boshqarish: Agar ulanish uzilsa, WebSocket'ga avtomatik ravishda qayta ulanish uchun qayta ulanish mantig'ini amalga oshiring.
• Buferlash: Yuqorida aytib o'tilganidek, navbatdan foydalanish, websocket'ga kelayotgan ma'lumotlar tezligini ularning qayta ishlanish tezligidan ajratishga imkon beradi. Bu ma'lumotlar tezligidagi qisqa muddatli keskin o'sishlar tufayli yuzaga keladigan xatolardan himoya qiladi.

Bu misol soddalashtirilgan stsenariyni ko'rsatadi. Yanada mustahkamroq amalga oshirish kiruvchi xabarlarni boshqarish va qarshi bosimni samarali boshqarish uchun navbatni o'z ichiga oladi.

4. Daraxt Tuzilmalarini Asinxron Ravishda Aylanib Chiqish

Asinxron Generatorlar murakkab daraxt tuzilmalarini aylanib chiqish uchun ham foydalidir, ayniqsa har bir tugun asinxron operatsiyani talab qilishi mumkin bo'lganda (masalan, ma'lumotlar bazasidan ma'lumotlarni olish).

            
async function* traverseTree(node) {
  yield node;

  if (node.children) {
    for (const child of node.children) {
      yield* traverseTree(child); // Boshqa generatorga topshirish uchun yield* dan foydalaning
    }
  }
}

// Daraxt tuzilmasi misoli
const tree = {
  value: 'A',
  children: [
    { value: 'B', children: [{value: 'D'}] },
    { value: 'C' }
  ]
};

async function processTree() {
  for await (const node of traverseTree(tree)) {
    console.log(node.value); // Natija: A, B, D, C
  }
}

processTree();

            

              
                Copy
              
            
          

Ushbu misolda:

• traverseTree - bu daraxt tuzilmasini rekursiv ravishda aylanib chiqadigan Asinxron Generator.
• U daraxtdagi har bir tugunni qaytaradi.
• yield* kalit so'zi boshqa generatorga topshiradi, bu esa rekursiv chaqiruvlar natijalarini yoyish imkonini beradi.
• processTree Asinxron Generatorni iste'mol qiladi va har bir tugunni qayta ishlaydi.

Asinxron Generatorlar Bilan Xatoliklarni Boshqarish

Asinxron operatsiyalar davomida yuzaga kelishi mumkin bo'lgan xatoliklarni boshqarish uchun Asinxron Generatorlar ichida try...catch bloklaridan foydalanishingiz mumkin.

            
async function* myAsyncGeneratorWithErrors() {
  try {
    const result = await someAsyncFunction();
    yield result;
  } catch (error) {
    console.error('Generatordagi xato:', error);
    // Xatolikni qayta tashlashni yoki maxsus xatolik qiymatini qaytarishni tanlashingiz mumkin
    yield { error: error.message }; // Xatolik obyektini qaytarish
  }

  yield await Promise.resolve('Xatodan keyin davom etish (agar qayta tashlanmasa)');
}

async function consumeGeneratorWithErrors() {
  for await (const value of myAsyncGeneratorWithErrors()) {
    if (value.error) {
      console.error('Generatordan xato qabul qilindi:', value.error);
    } else {
      console.log(value);
    }
  }
}

consumeGeneratorWithErrors();

            

              
                Copy
              
            
          

Ushbu misolda:

• try...catch bloki await someAsyncFunction() chaqiruvi paytida yuzaga kelishi mumkin bo'lgan har qanday xatolarni ushlaydi.
• catch bloki xatoni qayd qiladi va xatolik obyektini qaytaradi.
• Iste'molchi error xususiyatini tekshirishi va xatoni mos ravishda boshqarishi mumkin.

Oqimli Qayta Ishlash Uchun Asinxron Generatorlardan Foydalanishning Afzalliklari

• Yaxshilangan Unumdorlik: "Dangasa" baholash va asinxron qayta ishlash, ayniqsa, katta ma'lumotlar to'plamlari yoki real vaqtdagi oqimlar bilan ishlashda unumdorlikni sezilarli darajada yaxshilashi mumkin.
• Kamaytirilgan Xotira Sarfi: Ma'lumotlarni bo'laklarga bo'lib ishlash xotira sarfini kamaytiradi, bu esa boshqa hollarda xotiraga sig'maydigan darajada katta bo'lgan ma'lumotlar to'plamlarini qayta ishlashga imkon beradi.
• Yaxshilangan Kod O'qilishi: Asinxron Generatorlar an'anaviy qayta chaqiruv (callback) ga asoslangan yondashuvlarga qaraganda asinxron ma'lumotlar oqimlarini boshqarishning ixchamroq va o'qilishi osonroq usulini taqdim etadi.
• Yaxshiroq Xatoliklarni Boshqarish: Generatorlar ichidagi try...catch bloklari xatoliklarni boshqarishni soddalashtiradi.
• Soddalashtirilgan Asinxron Boshqaruv Oqimi: Generator ichida async/await dan foydalanish boshqa asinxron konstruksiyalarga qaraganda o'qish va kuzatishni ancha osonlashtiradi.

Asinxron Generatorlarni Qachon Ishlatish Kerak

Quyidagi stsenariylarda Asinxron Generatorlardan foydalanishni ko'rib chiqing:

• Katta fayllar yoki ma'lumotlar to'plamlarini qayta ishlash.
• API'lardan sahifalarga bo'lingan ma'lumotlarni olish.
• Real vaqtdagi ma'lumotlar oqimlarini boshqarish (masalan, WebSockets, SSE).
• Murakkab daraxt tuzilmalarini aylanib chiqish.
• Ma'lumotlarni asinxron va iterativ ravishda qayta ishlash zarur bo'lgan har qanday vaziyatda.

Asinxron Generatorlar va Observables (Kuzatiladiganlar)

Asinxron Generatorlar ham, Observables ham asinxron ma'lumotlar oqimlarini boshqarish uchun ishlatiladi, ammo ular turli xususiyatlarga ega:

• Asinxron Generatorlar: Tortishga asoslangan (pull-based), ya'ni iste'molchi generatordan ma'lumotlarni so'raydi.
• Observables: Itarishga asoslangan (push-based), ya'ni ishlab chiqaruvchi ma'lumotlarni iste'molchiga itaradi.

Agar siz ma'lumotlar oqimi ustidan nozik nazoratga ega bo'lishni va ma'lumotlarni ma'lum bir tartibda qayta ishlashni xohlasangiz, Asinxron Generatorlarni tanlang. Agar siz bir nechta obunachilar va murakkab o'zgartirishlar bilan real vaqtdagi oqimlarni boshqarishingiz kerak bo'lsa, Observables'ni tanlang.

Xulosa

JavaScript Asinxron Generatorlari oqimli qayta ishlash uchun kuchli va nafis yechimni taqdim etadi. Asinxron dasturlash va generatorlarning afzalliklarini birlashtirib, ular katta ma'lumotlar to'plamlari va real vaqtdagi oqimlarni samarali boshqara oladigan kengaytiriladigan, sezgir va qo'llab-quvvatlanadigan ilovalar yaratishga imkon beradi. JavaScript ishlab chiqish jarayonida yangi imkoniyatlarni ochish uchun Asinxron Generatorlardan foydalaning.

Qo'shimcha Ma'lumotlar

• MDN Web Docs: async function*
• V8 Blog: Asinxron Iteratsiya
• Node.js Oqimlar Hujjatlari