ابزارهای کمکی ژنراتور ناهمگام جاوا اسکریپت: تسلط بر ایجاد و مدیریت جریان‌ها

برنامه‌نویسی ناهمگام در جاوا اسکریپت در طول سال‌ها به طور قابل توجهی تکامل یافته است. با معرفی ژنراتورهای ناهمگام و پیمایشگرهای ناهمگام، توسعه‌دهندگان ابزارهای قدرتمندی برای مدیریت جریان‌های داده ناهمگام به دست آوردند. اکنون، ابزارهای کمکی ژنراتور ناهمگام جاوا اسکریپت این قابلیت‌ها را بیشتر تقویت کرده و روشی ساده‌تر و گویاتر برای ایجاد، تبدیل و مدیریت جریان‌های داده ناهمگام فراهم می‌کنند. این راهنما به بررسی اصول ابزارهای کمکی ژنراتور ناهمگام، عملکرد آن‌ها و کاربردهای عملی با مثال‌های واضح می‌پردازد.

درک ژنراتورها و پیمایشگرهای ناهمگام

قبل از پرداختن به ابزارهای کمکی ژنراتور ناهمگام، درک مفاهیم اساسی ژنراتورهای ناهمگام و پیمایشگرهای ناهمگام بسیار مهم است.

ژنراتورهای ناهمگام

یک ژنراتور ناهمگام تابعی است که می‌تواند متوقف و از سر گرفته شود و مقادیر را به صورت ناهمگام تولید (yield) کند. این ویژگی به شما امکان می‌دهد تا دنباله‌ای از مقادیر را در طول زمان و بدون مسدود کردن رشته اصلی تولید کنید. ژنراتورهای ناهمگام با استفاده از سینتکس async function* تعریف می‌شوند.

مثال:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // شبیه‌سازی عملیات ناهمگام
    yield i;
  }
}

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

پیمایشگرهای ناهمگام

یک پیمایشگر ناهمگام (Async Iterator) شیئی است که متد next() را فراهم می‌کند. این متد یک promise برمی‌گرداند که به شیئی شامل مقدار بعدی در دنباله و یک ویژگی done که نشان‌دهنده پایان دنباله است، resolve می‌شود. پیمایشگرهای ناهمگام با استفاده از حلقه‌های for await...of مصرف می‌شوند.

مثال:

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) مجموعه‌ای از متدها هستند که عملکرد پروتوتایپ‌های ژنراتور ناهمگام را گسترش می‌دهند. آن‌ها روش‌های مناسبی برای دستکاری جریان‌های داده ناهمگام فراهم می‌کنند و کد را خواناتر و قابل نگهداری‌تر می‌سازند. این ابزارها به صورت تنبل (lazily) عمل می‌کنند، به این معنی که داده‌ها را فقط در صورت نیاز پردازش می‌کنند که می‌تواند عملکرد را بهبود بخشد.

ابزارهای کمکی ژنراتور ناهمگام زیر معمولاً در دسترس هستند (بسته به محیط جاوا اسکریپت و polyfill‌ها):

• map
• filter
• take
• drop
• flatMap
• reduce
• toArray
• forEach

بررسی دقیق ابزارهای کمکی ژنراتور ناهمگام

۱. `map()`

ابزار کمکی map() هر مقدار در دنباله ناهمگام را با اعمال یک تابع مشخص، تبدیل می‌کند. این متد یک ژنراتور ناهمگام جدید برمی‌گرداند که مقادیر تبدیل‌شده را تولید می‌کند.

سینتکس:

asyncGenerator.map(callback)

مثال: تبدیل جریانی از اعداد به مربع آن‌ها.

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)); // شبیه‌سازی عملیات ناهمگام
    return num * num;
  });

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

processNumbers();

کاربرد در دنیای واقعی: تصور کنید داده‌های کاربران را از چندین API دریافت می‌کنید و نیاز دارید آن‌ها را به یک فرمت یکپارچه تبدیل کنید. می‌توان از map() برای اعمال یک تابع تبدیل بر روی هر شیء کاربر به صورت ناهمگام استفاده کرد.

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) => {
    // نرمال‌سازی فرمت داده کاربر
    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);
  }
}

۲. `filter()`

ابزار کمکی filter() یک ژنراتور ناهمگام جدید ایجاد می‌کند که فقط مقادیری از دنباله اصلی را که شرط مشخصی را برآورده می‌کنند، تولید می‌کند. این ابزار به شما امکان می‌دهد تا مقادیر را به صورت انتخابی در جریان حاصل قرار دهید.

سینتکس:

asyncGenerator.filter(callback)

مثال: فیلتر کردن جریانی از اعداد برای شامل کردن فقط اعداد زوج.

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();

کاربرد در دنیای واقعی: پردازش جریانی از رکوردهای لاگ و فیلتر کردن آن‌ها بر اساس سطح اهمیت. به عنوان مثال، فقط پردازش خطاها و هشدارها.

async function* readLogFile(filePath) {
  // شبیه‌سازی خواندن یک فایل لاگ به صورت خط به خط و ناهمگام
  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);
  }
}

۳. `take()`

ابزار کمکی take() یک ژنراتور ناهمگام جدید ایجاد می‌کند که تنها n مقدار اول از دنباله اصلی را تولید می‌کند. این ابزار برای محدود کردن تعداد آیتم‌های پردازش‌شده از یک جریان بالقوه بی‌نهایت یا بسیار بزرگ مفید است.

سینتکس:

asyncGenerator.take(n)

مثال: گرفتن ۳ عدد اول از یک جریان اعداد.

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();

کاربرد در دنیای واقعی: نمایش ۵ نتیجه برتر جستجو از یک API جستجوی ناهمگام.

async function* search(query) {
  // شبیه‌سازی دریافت نتایج جستجو از یک API
  const results = [
    { title: 'Result 1', url: '...' },
    { title: 'Result 2', url: '...' },
    { title: 'Result 3', url: '...' },
    { title: 'Result 4', url: '...' },
    { title: 'Result 5', url: '...' },
    { title: 'Result 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);
  }
}

۴. `drop()`

ابزار کمکی drop() یک ژنراتور ناهمگام جدید ایجاد می‌کند که n مقدار اول از دنباله اصلی را نادیده گرفته و مقادیر باقی‌مانده را تولید می‌کند. این متد برعکس take() عمل می‌کند و برای نادیده گرفتن بخش‌های اولیه یک جریان مفید است.

سینتکس:

asyncGenerator.drop(n)

مثال: حذف ۲ عدد اول از یک جریان اعداد.

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();

کاربرد در دنیای واقعی: صفحه‌بندی در یک مجموعه داده بزرگ که از یک API دریافت شده است، با نادیده گرفتن نتایجی که قبلاً نمایش داده شده‌اند.

async function* fetchData(url, pageSize, pageNumber) {
  const offset = (pageNumber - 1) * pageSize;
  // شبیه‌سازی دریافت داده با offset
  const data = [
    { id: 1, name: 'Item 1' },
    { id: 2, name: 'Item 2' },
    { id: 3, name: 'Item 3' },
    { id: 4, name: 'Item 4' },
    { id: 5, name: 'Item 5' },
    { id: 6, name: 'Item 6' },
    { id: 7, name: 'Item 7' },
    { id: 8, name: 'Item 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);  // نادیده گرفتن آیتم‌های صفحات قبلی

  const results = page.take(pageSize);


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

// مثال استفاده
displayPage(2);

۵. `flatMap()`

ابزار کمکی flatMap() هر مقدار در دنباله ناهمگام را با اعمال تابعی که یک Async Iterable برمی‌گرداند، تبدیل می‌کند. سپس، Async Iterable حاصل را به یک ژنراتور ناهمگام واحد مسطح (flatten) می‌کند. این ابزار برای تبدیل هر مقدار به جریانی از مقادیر و سپس ترکیب آن جریان‌ها مفید است.

سینتکس:

asyncGenerator.flatMap(callback)

مثال: تبدیل جریانی از جملات به جریانی از کلمات.

async function* generateSentences() {
  const sentences = [
    'This is the first sentence.',
    'This is the second sentence.',
    'This is the third sentence.'
  ];

  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();

کاربرد در دنیای واقعی: دریافت نظرات برای چندین پست وبلاگ و ترکیب آن‌ها در یک جریان واحد برای پردازش.

async function* fetchBlogPostIds() {
  const blogPostIds = [1, 2, 3]; // شبیه‌سازی دریافت شناسه‌های پست وبلاگ از یک API
  for (const id of blogPostIds) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield id;
  }
}

async function* fetchCommentsForPost(postId) {
  // شبیه‌سازی دریافت نظرات برای یک پست وبلاگ از یک API
  const comments = [
    { postId: postId, text: `Comment 1 for post ${postId}` },
    { postId: postId, text: `Comment 2 for post ${postId}` }
  ];
  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);
  }
}

۶. `reduce()`

ابزار کمکی reduce() یک تابع را بر روی یک انباشتگر (accumulator) و هر مقدار از ژنراتور ناهمگام (از چپ به راست) اعمال می‌کند تا آن را به یک مقدار واحد کاهش دهد. این ابزار برای تجمیع داده‌ها از یک جریان ناهمگام مفید است.

سینتکس:

asyncGenerator.reduce(callback, initialValue)

مثال: محاسبه مجموع اعداد در یک جریان.

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('Sum:', sum);
}

processNumbers();

کاربرد در دنیای واقعی: محاسبه میانگین زمان پاسخ‌دهی یک سری از فراخوانی‌های API.

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(`Error fetching ${endpoint}: ${error}`);
      yield 0; // یا خطا را به روش مناسب مدیریت کنید
    }
  }
}

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(`Average response time: ${average} ms`);
}

۷. `toArray()`

ابزار کمکی toArray() ژنراتور ناهمگام را مصرف کرده و یک promise برمی‌گرداند که به آرایه‌ای حاوی تمام مقادیر تولید شده توسط ژنراتور، resolve می‌شود. این ابزار زمانی مفید است که نیاز دارید تمام مقادیر از جریان را در یک آرایه واحد برای پردازش بیشتر جمع‌آوری کنید.

سینتکس:

asyncGenerator.toArray()

مثال: جمع‌آوری اعداد از یک جریان در یک آرایه.

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('Number Array:', numberArray);
}

processNumbers();

کاربرد در دنیای واقعی: جمع‌آوری تمام آیتم‌ها از یک API صفحه‌بندی‌شده در یک آرایه واحد برای فیلتر یا مرتب‌سازی در سمت کلاینت.

async function* fetchAllItems(apiEndpoint) {
    let pageNumber = 1;
    const pageSize = 100;  // بر اساس محدودیت‌های صفحه‌بندی API تنظیم شود

    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; // داده دیگری وجود ندارد
        }

        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(`Fetched ${itemsArray.length} items.`);
    // پردازش بیشتر می‌تواند روی `itemsArray` انجام شود
}

۸. `forEach()`

ابزار کمکی forEach() یک تابع مشخص را برای هر مقدار در ژنراتور ناهمگام یک بار اجرا می‌کند. برخلاف سایر ابزارهای کمکی، forEach() یک ژنراتور ناهمگام جدید برنمی‌گرداند؛ این متد برای انجام عملیات جانبی (side effects) بر روی هر مقدار استفاده می‌شود.

سینتکس:

asyncGenerator.forEach(callback)

مثال: ثبت هر عدد از یک جریان در کنسول.

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('Number:', num);
  });
}

processNumbers();

کاربرد در دنیای واقعی: ارسال به‌روزرسانی‌های بی‌درنگ به رابط کاربری همزمان با پردازش داده‌ها از یک جریان.

async function* fetchRealTimeData(dataSource) {
    //شبیه‌سازی دریافت داده‌های بی‌درنگ (مثلاً قیمت سهام).
    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) => {
    //شبیه‌سازی به‌روزرسانی رابط کاربری
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log(`Updating UI with data: ${JSON.stringify(data)}`);
    // کد اصلی برای به‌روزرسانی UI در اینجا قرار می‌گیرد.
  });
}

ترکیب ابزارهای کمکی ژنراتور ناهمگام برای پایپ‌لاین‌های داده پیچیده

قدرت واقعی ابزارهای کمکی ژنراتور ناهمگام از قابلیت زنجیره‌ای کردن آن‌ها برای ایجاد پایپ‌لاین‌های داده پیچیده ناشی می‌شود. این امکان به شما اجازه می‌دهد تا چندین تبدیل و عملیات را بر روی یک جریان ناهمگام به روشی مختصر و خوانا انجام دهید.

مثال: فیلتر کردن یک جریان اعداد برای شامل کردن فقط اعداد زوج، سپس به توان دو رساندن آن‌ها و در نهایت گرفتن ۳ نتیجه اول.

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();

کاربرد در دنیای واقعی: دریافت داده‌های کاربران، فیلتر کردن کاربران بر اساس موقعیت مکانی آن‌ها، تبدیل داده‌هایشان برای شامل کردن فقط فیلدهای مرتبط و سپس نمایش ۱۰ کاربر اول بر روی نقشه.

async function* fetchUsers() {
  // شبیه‌سازی دریافت کاربران از یک پایگاه داده یا API
  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(`Displaying up to ${maxUsers} users from ${location} on the map:`);
  for await (const user of usersForMap) {
    console.log(user);
  }
}

// مثال‌های استفاده:
displayUsersOnMap('New York', 2);
displayUsersOnMap('London', 5);

پشتیبانی مرورگر و Polyfillها

پشتیبانی از ابزارهای کمکی ژنراتور ناهمگام بسته به محیط جاوا اسکریپت می‌تواند متفاوت باشد. اگر نیاز به پشتیبانی از مرورگرها یا محیط‌های قدیمی‌تر دارید، ممکن است لازم باشد از polyfillها استفاده کنید. یک polyfill با پیاده‌سازی قابلیت‌های از دست رفته در جاوا اسکریپت، آن‌ها را فراهم می‌کند. چندین کتابخانه polyfill برای ابزارهای کمکی ژنراتور ناهمگام مانند core-js در دسترس است.

مثال با استفاده از core-js:

// وارد کردن polyfill‌های لازم
require('core-js/features/async-iterator/map');
require('core-js/features/async-iterator/filter');
// ... وارد کردن سایر ابزارهای کمکی مورد نیاز

مدیریت خطا

هنگام کار با عملیات ناهمگام، مدیریت صحیح خطاها بسیار مهم است. با ابزارهای کمکی ژنراتور ناهمگام، مدیریت خطا را می‌توان با استفاده از بلوک‌های try...catch درون توابع ناهمگامی که در این ابزارها استفاده می‌شوند، انجام داد.

مثال: مدیریت خطا هنگام دریافت داده در یک عملیات map().

async function* fetchData(urls) {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      const data = await response.json();
      yield data;
    } catch (error) {
      console.error(`Error fetching data from ${url}: ${error}`);
      yield null; // یا خطا را به روش مناسب مدیریت کنید، مثلاً با تولید یک شیء خطا
    }
  }
}

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; // انتشار خطا
    }
    // پردازش داده‌ها
    return data;
  });

  for await (const item of processedData) {
    if (item === null) {
      console.log('Skipping item due to error');
      continue;
    }
    console.log('Processed Item:', item);
  }
}

processData();

بهترین شیوه‌ها و ملاحظات

• ارزیابی تنبل (Lazy Evaluation): ابزارهای کمکی ژنراتور ناهمگام به صورت تنبل ارزیابی می‌شوند، یعنی داده‌ها را فقط زمانی که درخواست شوند پردازش می‌کنند. این می‌تواند به ویژه هنگام کار با مجموعه‌داده‌های بزرگ، عملکرد را بهبود بخشد.
• مدیریت خطا: همیشه خطاها را به درستی در توابع ناهمگامی که در این ابزارها استفاده می‌شوند مدیریت کنید.
• Polyfillها: در صورت لزوم برای پشتیبانی از مرورگرها یا محیط‌های قدیمی‌تر از polyfillها استفاده کنید.
• خوانایی: از نام‌های متغیر توصیفی و کامنت‌ها برای خواناتر و قابل نگهداری‌تر کردن کد خود استفاده کنید.
• عملکرد: به پیامدهای عملکردی زنجیره‌ای کردن چندین ابزار کمکی توجه داشته باشید. در حالی که تنبلی به بهبود عملکرد کمک می‌کند، زنجیره‌ای کردن بیش از حد همچنان می‌تواند سربار ایجاد کند.

نتیجه‌گیری

ابزارهای کمکی ژنراتور ناهمگام جاوا اسکریپت روشی قدرتمند و زیبا برای ایجاد، تبدیل و مدیریت جریان‌های داده ناهمگام فراهم می‌کنند. با بهره‌گیری از این ابزارها، توسعه‌دهندگان می‌توانند کدی مختصرتر، خواناتر و قابل نگهداری‌تر برای مدیریت عملیات پیچیده ناهمگام بنویسند. درک اصول ژنراتورها و پیمایشگرهای ناهمگام، به همراه عملکرد هر یک از ابزارهای کمکی، برای استفاده موثر از این ابزارها در برنامه‌های کاربردی واقعی ضروری است. چه در حال ساخت پایپ‌لاین‌های داده، پردازش داده‌های بی‌درنگ، یا مدیریت پاسخ‌های ناهمگام API باشید، ابزارهای کمکی ژنراتور ناهمگام می‌توانند کد شما را به طور قابل توجهی ساده کرده و کارایی کلی آن را بهبود بخشند.