29-avgust, 2025O'zbek

Samarali oqimlar yaratish, o'zgartirish va boshqarish uchun JavaScript Async Generator Helpers kuchini oching. Mustahkam asinxron ilovalar yaratish uchun amaliy misollar va real hayotiy holatlarni o'rganing.

JavaScript Async Generator Helpers: Oqimlarni Yaratish va Boshqarishni O'zlashtirish

JavaScript'dagi asinxron dasturlash yillar davomida sezilarli darajada rivojlandi. Asinxron Generatorlar va Asinxron Iteratorlarning joriy etilishi bilan dasturchilar asinxron ma'lumotlar oqimlarini boshqarish uchun kuchli vositalarga ega bo'lishdi. Endi, JavaScript Async Generator Helpers bu imkoniyatlarni yanada kengaytirib, asinxron ma'lumotlar oqimlarini yaratish, o'zgartirish va boshqarishning soddalashtirilgan va ifodali usulini taqdim etadi. Ushbu qo'llanmada Async Generator Helpers'ning asoslari, ularning funksiyalari chuqur o'rganiladi va aniq misollar bilan ularning amaliy qo'llanilishi ko'rsatiladi.

Asinxron Generatorlar va Iteratorlarni Tushunish

Async Generator Helpers'ga chuqurroq kirishdan oldin, Asinxron Generatorlar va Asinxron Iteratorlarning asosiy tushunchalarini tushunish juda muhim.

Asinxron Generatorlar

Asinxron Generator — bu pauza qilinishi va qayta ishga tushirilishi mumkin bo'lgan, qiymatlarni asinxron tarzda qaytaradigan funksiya. U sizga asosiy oqimni bloklamasdan, vaqt o'tishi bilan qiymatlar ketma-ketligini yaratishga imkon beradi. Asinxron Generatorlar async function* sintaksisi yordamida aniqlanadi.

Misol:


async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Asinxron operatsiyani simulyatsiya qilish
    yield i;
  }
}

// Foydalanish
const sequence = generateSequence(1, 5);

Asinxron Iteratorlar

Asinxron Iterator - bu next() metodini taqdim etadigan obyekt bo'lib, u ketma-ketlikdagi keyingi qiymatni va ketma-ketlik tugaganligini bildiruvchi done xususiyatini o'z ichiga olgan obyektga aylantiriladigan promise qaytaradi. Asinxron Iteratorlar for await...of tsikllari yordamida ishlatiladi.

Misol:


async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500));
    yield i;
  }
}

async function consumeSequence() {
  const sequence = generateSequence(1, 5);
  for await (const value of sequence) {
    console.log(value);
  }
}

consumeSequence();

Async Generator Helpers Bilan Tanishtiruv

Async Generator Helpers — bu Async Generator prototiplarining funksionalligini kengaytiruvchi metodlar to'plami. Ular asinxron ma'lumotlar oqimlarini boshqarishning qulay usullarini taqdim etib, kodni o'qilishi oson va qo'llab-quvvatlanadigan qiladi. Bu yordamchilar "dangasa" (lazily) ishlaydi, ya'ni ular ma'lumotlarni faqat kerak bo'lganda qayta ishlaydi, bu esa ishlash samaradorligini oshirishi mumkin.

Quyidagi Async Generator Helpers odatda mavjud (JavaScript muhiti va polyfill'larga qarab):

map
filter
take
drop
flatMap
reduce
toArray
forEach

Async Generator Helpers'ni Batafsil O'rganish

1. `map()`

map() yordamchisi taqdim etilgan funksiyani qo'llash orqali asinxron ketma-ketlikdagi har bir qiymatni o'zgartiradi. U o'zgartirilgan qiymatlarni qaytaradigan yangi Async Generator'ni qaytaradi.

Sintaksis:


asyncGenerator.map(callback)

Misol: Sonlar oqimini ularning kvadratlariga aylantirish.


async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const squares = numbers.map(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100)); // Asinxron operatsiyani simulyatsiya qilish
    return num * num;
  });

  for await (const square of squares) {
    console.log(square);
  }
}

processNumbers();

Real hayotiy misol: Bir nechta API'lardan foydalanuvchi ma'lumotlarini olish va ma'lumotlarni yagona formatga aylantirish kerakligini tasavvur qiling. map() har bir foydalanuvchi obyektiga asinxron ravishda o'zgartirish funksiyasini qo'llash uchun ishlatilishi mumkin.


async function* fetchUsersFromMultipleAPIs(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const response = await fetch(endpoint);
    const data = await response.json();
    for (const user of data) {
      yield user;
    }
  }
}

async function processUsers() {
  const apiEndpoints = [
    'https://api.example.com/users1',
    'https://api.example.com/users2'
  ];

  const users = fetchUsersFromMultipleAPIs(apiEndpoints);

  const normalizedUsers = users.map(async (user) => {
    // Foydalanuvchi ma'lumotlari formatini normallashtirish
    return {
      id: user.userId || user.id,
      name: user.fullName || user.name,
      email: user.emailAddress || user.email
    };
  });

  for await (const normalizedUser of normalizedUsers) {
    console.log(normalizedUser);
  }
}

2. `filter()`

filter() yordamchisi asl ketma-ketlikdan faqat berilgan shartni qanoatlantiradigan qiymatlarni qaytaradigan yangi Async Generator yaratadi. Bu natijaviy oqimga qiymatlarni tanlab kiritish imkonini beradi.

Sintaksis:


asyncGenerator.filter(callback)

Misol: Faqat juft sonlarni o'z ichiga olish uchun sonlar oqimini filtrlash.


async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 10);
  const evenNumbers = numbers.filter(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return num % 2 === 0;
  });

  for await (const evenNumber of evenNumbers) {
    console.log(evenNumber);
  }
}

processNumbers();

Real hayotiy misol: Jurnal yozuvlari oqimini qayta ishlash va yozuvlarni ularning jiddiylik darajasiga qarab filtrlash. Masalan, faqat xatolar va ogohlantirishlarni qayta ishlash.


async function* readLogFile(filePath) {
  // Log faylini satrma-satr asinxron o'qishni simulyatsiya qilish
  const logEntries = [
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' },
    { timestamp: '...', level: 'WARNING', message: '...' },
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' }
  ];

  for (const entry of logEntries) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield entry;
  }
}

async function processLogs() {
  const logEntries = readLogFile('path/to/log/file.log');
  const errorAndWarningLogs = logEntries.filter(async (entry) => {
    return entry.level === 'ERROR' || entry.level === 'WARNING';
  });

  for await (const log of errorAndWarningLogs) {
    console.log(log);
  }
}

3. `take()`

take() yordamchisi asl ketma-ketlikdan faqat birinchi n ta qiymatni qaytaradigan yangi Async Generator yaratadi. Bu potentsial cheksiz yoki juda katta oqimdan qayta ishlanadigan elementlar sonini cheklash uchun foydalidir.

Sintaksis:


asyncGenerator.take(n)

Misol: Sonlar oqimidan birinchi 3 ta sonni olish.


async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);
  const firstThree = numbers.take(3);

  for await (const num of firstThree) {
    console.log(num);
  }
}

processNumbers();

Real hayotiy misol: Asinxron qidiruv API'sidan eng yaxshi 5 ta qidiruv natijasini ko'rsatish.


async function* search(query) {
  // API'dan qidiruv natijalarini olishni simulyatsiya qilish
  const results = [
    { title: 'Natija 1', url: '...' },
    { title: 'Natija 2', url: '...' },
    { title: 'Natija 3', url: '...' },
    { title: 'Natija 4', url: '...' },
    { title: 'Natija 5', url: '...' },
    { title: 'Natija 6', url: '...' }
  ];

  for (const result of results) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield result;
  }
}

async function displayTopSearchResults(query) {
  const searchResults = search(query);
  const top5Results = searchResults.take(5);

  for await (const result of top5Results) {
    console.log(result);
  }
}

4. `drop()`

drop() yordamchisi asl ketma-ketlikdan birinchi n ta qiymatni o'tkazib yuboradigan va qolgan qiymatlarni qaytaradigan yangi Async Generator yaratadi. Bu take()'ning teskarisi va oqimning boshlang'ich qismlarini e'tiborsiz qoldirish uchun foydalidir.

Sintaksis:


asyncGenerator.drop(n)

Misol: Sonlar oqimidan birinchi 2 ta sonni o'tkazib yuborish.


async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const remainingNumbers = numbers.drop(2);

  for await (const num of remainingNumbers) {
    console.log(num);
  }
}

processNumbers();

Real hayotiy misol: API'dan olingan katta ma'lumotlar to'plamini sahifalarga bo'lish, allaqachon ko'rsatilgan natijalarni o'tkazib yuborish.


async function* fetchData(url, pageSize, pageNumber) {
  const offset = (pageNumber - 1) * pageSize;
  // Ofset bilan ma'lumotlarni olishni simulyatsiya qilish
  const data = [
    { id: 1, name: 'Element 1' },
    { id: 2, name: 'Element 2' },
    { id: 3, name: 'Element 3' },
    { id: 4, name: 'Element 4' },
    { id: 5, name: 'Element 5' },
    { id: 6, name: 'Element 6' },
    { id: 7, name: 'Element 7' },
    { id: 8, name: 'Element 8' }
  ];

  const pageData = data.slice(offset, offset + pageSize);

  for (const item of pageData) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield item;
  }
}

async function displayPage(pageNumber) {
  const pageSize = 3;
  const allData = fetchData('api/data', pageSize, pageNumber);
  const page = allData.drop((pageNumber - 1) * pageSize);  // oldingi sahifalardagi elementlarni o'tkazib yuborish

  const results = page.take(pageSize);


  for await (const item of results) {
    console.log(item);
  }
}

// Foydalanish misoli
displayPage(2);

5. `flatMap()`

flatMap() yordamchisi asinxron ketma-ketlikdagi har bir qiymatni Async Iterable qaytaradigan funksiyani qo'llash orqali o'zgartiradi. So'ngra natijaviy Async Iterable'ni yagona Async Generator'ga tekislaydi. Bu har bir qiymatni qiymatlar oqimiga aylantirish va keyin bu oqimlarni birlashtirish uchun foydalidir.

Sintaksis:


asyncGenerator.flatMap(callback)

Misol: Gaplar oqimini so'zlar oqimiga aylantirish.


async function* generateSentences() {
  const sentences = [
    'Bu birinchi gap.',
    'Bu ikkinchi gap.',
    'Bu uchinchi gap.'
  ];

  for (const sentence of sentences) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield sentence;
  }
}

async function* stringToWords(sentence) {
    const words = sentence.split(' ');
    for (const word of words) {
        await new Promise(resolve => setTimeout(resolve, 50));
        yield word;
    }
}

async function processSentences() {
  const sentences = generateSentences();
  const words = sentences.flatMap(async (sentence) => {
      return stringToWords(sentence);
  });

  for await (const word of words) {
    console.log(word);
  }
}

processSentences();

Real hayotiy misol: Bir nechta blog postlari uchun sharhlarni olish va ularni qayta ishlash uchun yagona oqimga birlashtirish.


async function* fetchBlogPostIds() {
  const blogPostIds = [1, 2, 3]; // API'dan blog postlari ID'larini olishni simulyatsiya qilish
  for (const id of blogPostIds) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield id;
  }
}

async function* fetchCommentsForPost(postId) {
  // API'dan blog posti uchun sharhlarni olishni simulyatsiya qilish
  const comments = [
    { postId: postId, text: `${postId}-post uchun 1-sharh` },
    { postId: postId, text: `${postId}-post uchun 2-sharh` }
  ];
  for (const comment of comments) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield comment;
  }
}

async function processComments() {
  const postIds = fetchBlogPostIds();
  const allComments = postIds.flatMap(async (postId) => {
    return fetchCommentsForPost(postId);
  });

  for await (const comment of allComments) {
    console.log(comment);
  }
}

6. `reduce()`

reduce() yordamchisi akkumulyatorga va Async Generator'ning har bir qiymatiga (chapdan o'ngga) nisbatan funksiyani qo'llab, uni bitta qiymatga qisqartiradi. Bu asinxron oqimdan ma'lumotlarni agregatsiya qilish uchun foydalidir.

Sintaksis:


asyncGenerator.reduce(callback, initialValue)

Misol: Oqimdagi sonlar yig'indisini hisoblash.


async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const sum = await numbers.reduce(async (accumulator, num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return accumulator + num;
  }, 0);

  console.log('Yig\'indi:', sum);
}

processNumbers();

Real hayotiy misol: Bir qator API chaqiruvlarining o'rtacha javob vaqtini hisoblash.


async function* fetchResponseTimes(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const startTime = Date.now();
    try {
      await fetch(endpoint);
      const endTime = Date.now();
      const responseTime = endTime - startTime;
      await new Promise(resolve => setTimeout(resolve, 50));
      yield responseTime;
    } catch (error) {
      console.error(`${endpoint} manzilidan yuklashda xatolik: ${error}`);
      yield 0; // Yoki xatolikni mos ravishda boshqaring
    }
  }
}

async function calculateAverageResponseTime() {
  const apiEndpoints = [
    'https://api.example.com/endpoint1',
    'https://api.example.com/endpoint2',
    'https://api.example.com/endpoint3'
  ];
  const responseTimes = fetchResponseTimes(apiEndpoints);

  let count = 0;
  const sum = await responseTimes.reduce(async (accumulator, time) => {
    count++;
    return accumulator + time;
  }, 0);

  const average = count > 0 ? sum / count : 0;
  console.log(`O'rtacha javob vaqti: ${average} ms`);
}

7. `toArray()`

toArray() yordamchisi Async Generator'ni iste'mol qiladi va generator tomonidan qaytarilgan barcha qiymatlarni o'z ichiga olgan massivga aylanadigan promise qaytaradi. Bu oqimdan barcha qiymatlarni keyingi qayta ishlash uchun yagona massivga yig'ish kerak bo'lganda foydalidir.

Sintaksis:


asyncGenerator.toArray()

Misol: Oqimdan sonlarni massivga yig'ish.


async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const numberArray = await numbers.toArray();

  console.log('Sonlar massivi:', numberArray);
}

processNumbers();

Real hayotiy misol: Mijoz tomonida filtrlash yoki saralash uchun sahifalangan API'dan barcha elementlarni bitta massivga yig'ish.


async function* fetchAllItems(apiEndpoint) {
    let pageNumber = 1;
    const pageSize = 100;  // API'ning sahifalash chegaralariga qarab sozlang

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

        if (!data || data.length === 0) {
            break; // Boshqa ma'lumot yo'q
        }

        for (const item of data) {
            await new Promise(resolve => setTimeout(resolve, 50));
            yield item;
        }

        pageNumber++;
    }
}

async function processAllItems() {
    const apiEndpoint = 'https://api.example.com/items';
    const allItems = fetchAllItems(apiEndpoint);
    const itemsArray = await allItems.toArray();

    console.log(`${itemsArray.length} ta element yuklandi.`);
    // Keyingi qayta ishlash `itemsArray` ustida bajarilishi mumkin
}

8. `forEach()`

forEach() yordamchisi Async Generator'dagi har bir qiymat uchun berilgan funksiyani bir marta bajaradi. Boshqa yordamchilardan farqli o'laroq, forEach() yangi Async Generator qaytarmaydi; u har bir qiymatda qo'shimcha effektlarni (side effects) bajarish uchun ishlatiladi.

Sintaksis:


asyncGenerator.forEach(callback)

Misol: Oqimdagi har bir sonni konsolga chiqarish.


async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  await numbers.forEach(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log('Son:', num);
  });
}

processNumbers();

Real hayotiy misol: Ma'lumotlar oqimdan qayta ishlanayotganda foydalanuvchi interfeysiga real vaqtda yangilanishlarni yuborish.


async function* fetchRealTimeData(dataSource) {
    //Real vaqtdagi ma'lumotlarni (masalan, aksiya narxlarini) olishni simulyatsiya qilish.
    const dataStream = [
      { timestamp: new Date(), price: 100 },
      { timestamp: new Date(), price: 101 },
      { timestamp: new Date(), price: 102 }
    ];
    for (const dataPoint of dataStream) {
      await new Promise(resolve => setTimeout(resolve, 500));
      yield dataPoint;
    }
}

async function updateUI() {
  const realTimeData = fetchRealTimeData('stock-api');
  await realTimeData.forEach(async (data) => {
    //UI'ni yangilashni simulyatsiya qilish
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log(`UI'ni yangilash ma'lumotlari: ${JSON.stringify(data)}`);
    // UI'ni haqiqatda yangilaydigan kod shu yerda bo'ladi.
  });
}

Murakkab Ma'lumotlar Quvurlari uchun Async Generator Helpers'ni Birlashtirish

Async Generator Helpers'ning haqiqiy kuchi ularni murakkab ma'lumotlar quvurlarini yaratish uchun bir-biriga zanjir qilib bog'lash qobiliyatidadir. Bu sizga asinxron oqimda bir nechta o'zgartirishlar va operatsiyalarni ixcham va o'qilishi oson tarzda bajarishga imkon beradi.

Misol: Sonlar oqimini faqat juft sonlarni o'z ichiga oladigan qilib filtrlash, so'ng ularni kvadratga oshirish va nihoyat, birinchi 3 ta natijani olish.


async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);

  const processedNumbers = numbers
    .filter(async (num) => num % 2 === 0)
    .map(async (num) => num * num)
    .take(3);

  for await (const num of processedNumbers) {
    console.log(num);
  }
}

processNumbers();

Real hayotiy misol: Foydalanuvchi ma'lumotlarini olish, foydalanuvchilarni ularning joylashuviga qarab filtrlash, ularning ma'lumotlarini faqat tegishli maydonlarni o'z ichiga oladigan qilib o'zgartirish va keyin birinchi 10 foydalanuvchini xaritada ko'rsatish.


async function* fetchUsers() {
  // Ma'lumotlar bazasi yoki API'dan foydalanuvchilarni olishni simulyatsiya qilish
  const users = [
    { id: 1, name: 'John Doe', location: 'New York', email: 'john.doe@example.com' },
    { id: 2, name: 'Jane Smith', location: 'London', email: 'jane.smith@example.com' },
    { id: 3, name: 'Ken Tan', location: 'Singapore', email: 'ken.tan@example.com' },
    { id: 4, name: 'Alice Jones', location: 'New York', email: 'alice.jones@example.com' },
    { id: 5, name: 'Bob Williams', location: 'London', email: 'bob.williams@example.com' },
    { id: 6, name: 'Siti Rahman', location: 'Singapore', email: 'siti.rahman@example.com' },
    { id: 7, name: 'Ahmed Khan', location: 'Dubai', email: 'ahmed.khan@example.com' },
    { id: 8, name: 'Maria Garcia', location: 'Madrid', email: 'maria.garcia@example.com' },
    { id: 9, name: 'Li Wei', location: 'Shanghai', email: 'li.wei@example.com' },
    { id: 10, name: 'Hans Müller', location: 'Berlin', email: 'hans.muller@example.com' },
    { id: 11, name: 'Emily Chen', location: 'Sydney', email: 'emily.chen@example.com' }
  ];

  for (const user of users) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield user;
  }
}

async function displayUsersOnMap(location, maxUsers) {
  const users = fetchUsers();

  const usersForMap = users
    .filter(async (user) => user.location === location)
    .map(async (user) => ({
      id: user.id,
      name: user.name,
      location: user.location
    }))
    .take(maxUsers);

  console.log(`${location} joylashuvidan ${maxUsers} tagacha foydalanuvchini xaritada ko'rsatish:`);
  for await (const user of usersForMap) {
    console.log(user);
  }
}

// Foydalanish misollari:
displayUsersOnMap('New York', 2);
displayUsersOnMap('London', 5);

Polyfill'lar va Brauzer Qo'llab-quvvatlashi

Async Generator Helpers'ni qo'llab-quvvatlash JavaScript muhitiga qarab farq qilishi mumkin. Agar siz eski brauzerlar yoki muhitlarni qo'llab-quvvatlashingiz kerak bo'lsa, polyfill'lardan foydalanishingiz kerak bo'lishi mumkin. Polyfill yetishmayotgan funksionallikni JavaScript'da amalga oshirish orqali ta'minlaydi. Async Generator Helpers uchun bir nechta polyfill kutubxonalari mavjud, masalan, core-js.

core-js yordamida misol:


// Kerakli polyfill'larni import qilish
require('core-js/features/async-iterator/map');
require('core-js/features/async-iterator/filter');
// ... boshqa kerakli yordamchilarni import qilish

Xatoliklarni Boshqarish

Asinxron operatsiyalar bilan ishlashda xatoliklarni to'g'ri boshqarish juda muhim. Async Generator Helpers bilan xatoliklarni boshqarish yordamchilarda ishlatiladigan asinxron funksiyalar ichidagi try...catch bloklari yordamida amalga oshirilishi mumkin.

Misol: map() operatsiyasi ichida ma'lumotlarni olishda xatoliklarni boshqarish.


async function* fetchData(urls) {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP xatosi! status: ${response.status}`);
      }
      const data = await response.json();
      yield data;
    } catch (error) {
      console.error(`${url} manzilidan ma'lumot olishda xatolik: ${error}`);
      yield null; // Yoki xatoni mos ravishda boshqaring, masalan, xato obyektini qaytarish orqali
    }
  }
}

async function processData() {
  const urls = [
    'https://api.example.com/data1',
    'https://api.example.com/data2',
    'https://api.example.com/data3'
  ];

  const dataStream = fetchData(urls);

  const processedData = dataStream.map(async (data) => {
    if (data === null) {
      return null; // Xatoni tarqatish
    }
    // Ma'lumotlarni qayta ishlash
    return data;
  });

  for await (const item of processedData) {
    if (item === null) {
      console.log('Xato tufayli element o'tkazib yuborildi');
      continue;
    }
    console.log('Qayta ishlangan element:', item);
  }
}

processData();

Eng Yaxshi Amaliyotlar va Mulohazalar

Dangasa baholash (Lazy Evaluation): Async Generator Helpers dangasa baholanadi, ya'ni ular faqat so'ralganda ma'lumotlarni qayta ishlaydi. Bu, ayniqsa, katta ma'lumotlar to'plamlari bilan ishlashda ishlash samaradorligini oshirishi mumkin.
Xatoliklarni Boshqarish: Har doim yordamchilarda ishlatiladigan asinxron funksiyalar ichida xatoliklarni to'g'ri boshqaring.
Polyfill'lar: Eski brauzerlar yoki muhitlarni qo'llab-quvvatlash uchun zarur bo'lganda polyfill'lardan foydalaning.
O'qilishi osonligi: Kodingizni o'qilishi oson va qo'llab-quvvatlanadigan qilish uchun tavsiflovchi o'zgaruvchi nomlari va izohlardan foydalaning.
Samaradorlik: Bir nechta yordamchilarni zanjir qilib bog'lashning samaradorlikka ta'sirini yodda tuting. Dangasalik yordam bersa-da, haddan tashqari zanjir hosil qilish qo'shimcha yuklanishga olib kelishi mumkin.

Xulosa

JavaScript Async Generator Helpers asinxron ma'lumotlar oqimlarini yaratish, o'zgartirish va boshqarishning kuchli va elegant usulini taqdim etadi. Ushbu yordamchilardan foydalangan holda, dasturchilar murakkab asinxron operatsiyalarni boshqarish uchun yanada ixcham, o'qilishi oson va qo'llab-quvvatlanadigan kod yozishlari mumkin. Asinxron Generatorlar va Iteratorlarning asoslarini, shuningdek, har bir yordamchining funksiyalarini tushunish, ushbu vositalarni real hayotiy ilovalarda samarali ishlatish uchun muhimdir. Ma'lumotlar quvurlarini qurayotgan bo'lsangiz, real vaqtdagi ma'lumotlarni qayta ishlayotgan bo'lsangiz yoki asinxron API javoblarini boshqarayotgan bo'lsangiz, Async Generator Helpers kodingizni sezilarli darajada soddalashtirishi va uning umumiy samaradorligini oshirishi mumkin.