জাভাস্ক্রিপ্ট অ্যাসিঙ্ক ইটারেটর কম্বিনেটরস: গ্লোবাল ডেভেলপারদের জন্য স্ট্রিম অপারেশন আয়ত্ত করা

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simulate async delay
    yield i;
  }
}

const generator = asyncNumberGenerator(5);

async function consumeGenerator() {
  let result;
  while (!(result = await generator.next()).done) {
    console.log(result.value);
  }
}

consumeGenerator();

            

              
                Copy
              
            
          

            async function* fetchUsers() {
  // Simulate fetching user data from a global API endpoint
  const users = [
    { id: 1, name: 'Alice', address: { street: '123 Main St', city: 'Metropolis', country: 'USA' } },
    { id: 2, name: 'Bob', address: { street: '456 Oak Ave', city: 'London', country: 'UK' } },
    { id: 3, name: 'Chandra', address: { street: '789 Pine Ln', city: 'Mumbai', country: 'India' } }
  ];
  for (const user of users) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield user;
  }
}

// A helper function to create a map combinator (conceptual)
function asyncMap(iterator, transformFn) {
  return (async function*() {
    let result;
    while (!(result = await iterator.next()).done) {
      yield transformFn(result.value);
    }
  })();
}

const formattedAddressesIterator = asyncMap(fetchUsers(), user =>
  `${user.address.street}, ${user.address.city}, ${user.address.country}`
);

async function displayAddresses() {
  console.log('--- Formatted Addresses ---');
  for await (const address of formattedAddressesIterator) {
    console.log(address);
  }
}

displayAddresses();

            

              
                Copy
              
            
          

            async function* fetchTransactions() {
  // Simulate fetching financial transactions with currency and amount
  const transactions = [
    { id: 'T1', amount: 150.75, currency: 'USD', region: 'North America' },
    { id: 'T2', amount: 80.50, currency: 'EUR', region: 'Europe' },
    { id: 'T3', amount: 250.00, currency: 'JPY', region: 'Asia' },
    { id: 'T4', amount: 45.20, currency: 'USD', region: 'North America' },
    { id: 'T5', amount: 180.00, currency: 'GBP', region: 'Europe' },
    { id: 'T6', amount: 300.00, currency: 'INR', region: 'Asia' }
  ];
  for (const tx of transactions) {
    await new Promise(resolve => setTimeout(resolve, 60));
    yield tx;
  }
}

// A helper function to create a filter combinator (conceptual)
function asyncFilter(iterator, predicateFn) {
  return (async function*() {
    let result;
    while (!(result = await iterator.next()).done) {
      if (predicateFn(result.value)) {
        yield result.value;
      }
    }
  })();
}

const highValueUsdTransactionsIterator = asyncFilter(fetchTransactions(), tx =>
  tx.currency === 'USD' && tx.amount > 100
);

async function displayFilteredTransactions() {
  console.log('\n--- High Value USD Transactions ---');
  for await (const tx of highValueUsdTransactionsIterator) {
    console.log(`ID: ${tx.id}, Amount: ${tx.amount} ${tx.currency}`);
  }
}

displayFilteredTransactions();

            

              
                Copy
              
            
          

            // Using the same fetchTransactions iterator from the filter example

// A helper function to create a reduce combinator (conceptual)
async function asyncReduce(iterator, reducerFn, initialValue) {
  let accumulator = initialValue;
  let result;
  while (!(result = await iterator.next()).done) {
    accumulator = await reducerFn(accumulator, result.value);
  }
  return accumulator;
}

async function calculateTotalValue() {
  const totalValue = await asyncReduce(
    fetchTransactions(),
    (sum, tx) => sum + tx.amount,
    0 // Initial sum
  );
  console.log(`\n--- Total Transaction Value ---`);
  console.log(`Total value across all transactions: ${totalValue.toFixed(2)}`);
}

calculateTotalValue();

// Example: Summing amounts for a specific currency
async function calculateUsdTotal() {
  const usdTransactions = asyncFilter(fetchTransactions(), tx => tx.currency === 'USD');
  const usdTotal = await asyncReduce(
    usdTransactions,
    (sum, tx) => sum + tx.amount,
    0
  );
  console.log(`Total value for USD transactions: ${usdTotal.toFixed(2)}`);
}

calculateUsdTotal();

            

              
                Copy
              
            
          

            async function* fetchProductsFromEu() {
  const products = [
    { id: 'E1', name: 'Laptop', price: 1200, origin: 'EU' },
    { id: 'E2', name: 'Keyboard', price: 75, origin: 'EU' }
  ];
  for (const prod of products) {
    await new Promise(resolve => setTimeout(resolve, 40));
    yield prod;
  }
}

async function* fetchProductsFromAsia() {
  const products = [
    { id: 'A1', name: 'Monitor', price: 300, origin: 'Asia' },
    { id: 'A2', name: 'Mouse', price: 25, origin: 'Asia' }
  ];
  for (const prod of products) {
    await new Promise(resolve => setTimeout(resolve, 45));
    yield prod;
  }
}

// A helper function to create a concat combinator (conceptual)
function asyncConcat(...iterators) {
  return (async function*() {
    for (const iterator of iterators) {
      let result;
      while (!(result = await iterator.next()).done) {
        yield result.value;
      }
    }
  })();
}

const allProductsIterator = asyncConcat(fetchProductsFromEu(), fetchProductsFromAsia());

async function displayAllProducts() {
  console.log('\n--- All Products (Concatenated) ---');
  for await (const product of allProductsIterator) {
    console.log(`ID: ${product.id}, Name: ${product.name}, Origin: ${product.origin}`);
  }
}

displayAllProducts();

            

              
                Copy
              
            
          

            async function* fetchFromServer(serverName, delay) {
  const data = [`${serverName}-data-1`, `${serverName}-data-2`, `${serverName}-data-3`];
  for (const item of data) {
    await new Promise(resolve => setTimeout(resolve, delay));
    yield item;
  }
}

// Conceptual merge: Not a full implementation, but illustrates the idea.
// A real implementation would manage multiple iterators simultaneously.
async function* conceptualAsyncMerge(...iterators) {
  // This simplified version iterates through iterators sequentially,
  // but a true merge would handle all iterators concurrently.
  // For demonstration, imagine fetching from servers with different delays.
  const results = await Promise.all(iterators.map(async (it) => {
    const values = [];
    let result;
    while (!(result = await it.next()).done) {
      values.push(result.value);
    }
    return values;
  }));

  // Flatten and yield all results (a true merge would interleave)
  for (const serverResults of results) {
    for (const value of serverResults) {
      yield value;
    }
  }
}

// To truly demonstrate merge, you'd need a more sophisticated queue/event loop management.
// For simplicity, we'll simulate by observing different delays.

async function observeConcurrentFeeds() {
  console.log('\n--- Observing Concurrent Feeds ---');
  // Simulate fetching from servers with different response times
  const server1 = fetchFromServer('ServerA', 200);
  const server2 = fetchFromServer('ServerB', 100);
  const server3 = fetchFromServer('ServerC', 150);

  // A real merge would yield 'ServerB-data-1' first, then 'ServerC-data-1', etc.
  // Our conceptual merge will process them in the order they complete.
  // For a practical implementation, libraries like 'ixjs' provide robust merge.

  // Simplified example using Promise.all and then flattening (not true interleaving)
  const allData = await Promise.all([
      Array.fromAsync(server1),
      Array.fromAsync(server2),
      Array.fromAsync(server3)
  ]);

  const mergedData = allData.flat();
  // Note: The order here is not guaranteed to be interleaved as in a true merge
  // without a more complex Promise handling mechanism.
  mergedData.forEach(data => console.log(data));
}

// Note: Array.fromAsync is a modern addition to work with async iterators.
// Ensure your environment supports it or use a polyfill/library.
// If Array.fromAsync is not available, manual iteration is needed.

// Let's use a manual approach if Array.fromAsync isn't universally supported
async function observeConcurrentFeedsManual() {
  console.log('\n--- Observing Concurrent Feeds (Manual Iteration) ---');
  const iterators = [
    fetchFromServer('ServerX', 300),
    fetchFromServer('ServerY', 150),
    fetchFromServer('ServerZ', 250)
  ];

  const pendingPromises = iterators.map(async (it, index) => ({
    iterator: it,
    index: index,
    nextResult: await it.next()
  }));

  const results = [];
  while (pendingPromises.length > 0) {
    const { index, nextResult } = await Promise.race(pendingPromises.map(p => p.then(res => res)));

    if (!nextResult.done) {
      results.push(nextResult.value);
      console.log(nextResult.value);

      // Fetch the next item from the same iterator and update its promise
      const currentIterator = iterators[index];
      const nextPromise = (async () => {
        const next = await currentIterator.next();
        return { iterator: currentIterator, index: index, nextResult: next };
      })();
      // Replace the promise in pendingPromises with the new one
      const promiseIndex = pendingPromises.findIndex(p => p.then(res => res.index === index));
      pendingPromises[promiseIndex] = nextPromise;
    } else {
      // Remove the promise for the completed iterator
      const promiseIndex = pendingPromises.findIndex(p => p.then(res => res.index === index));
      pendingPromises.splice(promiseIndex, 1);
    }
  }
}

observeConcurrentFeedsManual();

            

              
                Copy
              
            
          

            async function* streamSupportTickets() {
  let ticketId = 1001;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 75));
    yield { id: ticketId++, subject: 'Urgent issue', status: 'Open' };
  }
}

// A helper function to create a take combinator (conceptual)
function asyncTake(iterator, count) {
  return (async function*() {
    let yieldedCount = 0;
    let result;
    while (yieldedCount < count && !(result = await iterator.next()).done) {
      yield result.value;
      yieldedCount++;
    }
  })();
}

const top5TicketsIterator = asyncTake(streamSupportTickets(), 5);

async function displayTopTickets() {
  console.log('\n--- Top 5 Support Tickets ---');
  for await (const ticket of top5TicketsIterator) {
    console.log(`ID: ${ticket.id}, Subject: ${ticket.subject}`);
  }
}

displayTopTickets();

            

              
                Copy
              
            
          

            async function* streamSystemLogs() {
  const logs = [
    'System starting...', 'Initializing services...', 'Connecting to database...', 
    'User logged in: admin', 'Processing request ID 123', 'Request processed successfully', 
    'User logged in: guest', 'Processing request ID 124', 'Request processed successfully'
  ];
  for (const log of logs) {
    await new Promise(resolve => setTimeout(resolve, 30));
    yield log;
  }
}

// A helper function to create a skip combinator (conceptual)
function asyncSkip(iterator, count) {
  return (async function*() {
    let skippedCount = 0;
    let result;
    while (skippedCount < count && !(result = await iterator.next()).done) {
      skippedCount++;
    }
    // Now continue yielding from where we left off
    while (!(result = await iterator.next()).done) {
      yield result.value;
    }
  })();
}

const relevantLogsIterator = asyncSkip(streamSystemLogs(), 3); // Skip initial messages

async function displayRelevantLogs() {
  console.log('\n--- Relevant System Logs ---');
  for await (const log of relevantLogsIterator) {
    console.log(log);
  }
}

displayRelevantLogs();

            

              
                Copy
              
            
          

            async function* fetchProductsForCategory(categoryName) {
  const products = [
    { name: `${categoryName} Product A`, price: 50 },
    { name: `${categoryName} Product B`, price: 75 }
  ];
  for (const product of products) {
    await new Promise(resolve => setTimeout(resolve, 20));
    yield product;
  }
}

async function* fetchCategories() {
  const categories = ['Electronics', 'Books', 'Clothing'];
  for (const category of categories) {
    await new Promise(resolve => setTimeout(resolve, 50));
    // Yielding an async iterator for products within this category
    yield fetchProductsForCategory(category);
  }
}

// A helper function to create a flatten combinator (conceptual)
function asyncFlatten(iteratorOfIterators) {
  return (async function*() {
    let result;
    while (!(result = await iteratorOfIterators.next()).done) {
      const innerIterator = result.value;
      let innerResult;
      while (!(innerResult = await innerIterator.next()).done) {
        yield innerResult.value;
      }
    }
  })();
}

const allProductsFlattenedIterator = asyncFlatten(fetchCategories());

async function displayFlattenedProducts() {
  console.log('\n--- All Products (Flattened) ---');
  for await (const product of allProductsFlattenedIterator) {
    console.log(`Product: ${product.name}, Price: ${product.price}`);
  }
}

displayFlattenedProducts();

            

              
                Copy
              
            
          

            const processedData = asyncTake(
  asyncFilter(asyncMap(fetchUsers(), user => ({ ...user, fullName: `${user.name} Doe` })), user => user.id > 1),
  3
);

// This chain first maps users to add a fullName, then filters out the first user,
// and finally takes the first 3 of the remaining users.

            

              
                Copy