Combinatori di Iteratori Asincroni JavaScript: Padroneggiare le Operazioni di Flusso per Sviluppatori Globali

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simula un ritardo asincrono
    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() {
  // Simula il recupero dei dati utente da un endpoint API globale
  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;
  }
}

// Una funzione di supporto per creare un combinatore map (concettuale)
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('--- Indirizzi Formattati ---');
  for await (const address of formattedAddressesIterator) {
    console.log(address);
  }
}

displayAddresses();

            

              
                Copy
              
            
          

            async function* fetchTransactions() {
  // Simula il recupero di transazioni finanziarie con valuta e importo
  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;
  }
}

// Una funzione di supporto per creare un combinatore filter (concettuale)
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--- Transazioni USD di Alto Valore ---');
  for await (const tx of highValueUsdTransactionsIterator) {
    console.log(`ID: ${tx.id}, Importo: ${tx.amount} ${tx.currency}`);
  }
}

displayFilteredTransactions();

            

              
                Copy
              
            
          

            // Usando lo stesso iteratore fetchTransactions dell'esempio del filtro

// Una funzione di supporto per creare un combinatore reduce (concettuale)
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 // Somma iniziale
  );
  console.log(`\n--- Valore Totale delle Transazioni ---`);
  console.log(`Valore totale di tutte le transazioni: ${totalValue.toFixed(2)}`);
}

calculateTotalValue();

// Esempio: Somma degli importi per una valuta specifica
async function calculateUsdTotal() {
  const usdTransactions = asyncFilter(fetchTransactions(), tx => tx.currency === 'USD');
  const usdTotal = await asyncReduce(
    usdTransactions,
    (sum, tx) => sum + tx.amount,
    0
  );
  console.log(`Valore totale per le transazioni in USD: ${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;
  }
}

// Una funzione di supporto per creare un combinatore concat (concettuale)
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--- Tutti i Prodotti (Concatenati) ---');
  for await (const product of allProductsIterator) {
    console.log(`ID: ${product.id}, Nome: ${product.name}, Origine: ${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;
  }
}

// Merge concettuale: non un'implementazione completa, ma illustra l'idea.
// Un'implementazione reale gestirebbe più iteratori simultaneamente.
async function* conceptualAsyncMerge(...iterators) {
  // Questa versione semplificata itera attraverso gli iteratori in sequenza,
  // ma un vero merge gestirebbe tutti gli iteratori in concorrenza.
  // Per la dimostrazione, immaginate di recuperare dati da server con ritardi diversi.
  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;
  }));

  // Appiattisce e produce tutti i risultati (un vero merge li intercalerebbe)
  for (const serverResults of results) {
    for (const value of serverResults) {
      yield value;
    }
  }
}

// Per dimostrare veramente il merge, servirebbe una gestione più sofisticata della coda/event loop.
// Per semplicità, simuleremo osservando ritardi diversi.

async function observeConcurrentFeeds() {
  console.log('\n--- Osservazione dei Flussi Concorrenti ---');
  // Simula il recupero da server con tempi di risposta diversi
  const server1 = fetchFromServer('ServerA', 200);
  const server2 = fetchFromServer('ServerB', 100);
  const server3 = fetchFromServer('ServerC', 150);

  // Un vero merge produrrebbe prima 'ServerB-data-1', poi 'ServerC-data-1', ecc.
  // Il nostro merge concettuale li elaborerà nell'ordine in cui terminano.
  // Per un'implementazione pratica, librerie come 'ixjs' forniscono un merge robusto.

  // Esempio semplificato usando Promise.all e poi appiattendo (non un vero interleaving)
  const allData = await Promise.all([
      Array.fromAsync(server1),
      Array.fromAsync(server2),
      Array.fromAsync(server3)
  ]);

  const mergedData = allData.flat();
  // Nota: L'ordine qui non è garantito che sia intercalato come in un vero merge
  // senza un meccanismo di gestione delle Promise più complesso.
  mergedData.forEach(data => console.log(data));
}

// Nota: Array.fromAsync è un'aggiunta moderna per lavorare con iteratori asincroni.
// Assicurati che il tuo ambiente lo supporti o usa un polyfill/libreria.
// Se Array.fromAsync non è disponibile, è necessaria l'iterazione manuale.

// Usiamo un approccio manuale se Array.fromAsync non è supportato universalmente
async function observeConcurrentFeedsManual() {
  console.log('\n--- Osservazione dei Flussi Concorrenti (Iterazione Manuale) ---');
  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);

      // Recupera l'elemento successivo dallo stesso iteratore e aggiorna la sua promise
      const currentIterator = iterators[index];
      const nextPromise = (async () => {
        const next = await currentIterator.next();
        return { iterator: currentIterator, index: index, nextResult: next };
      })();
      // Sostituisci la promise in pendingPromises con quella nuova
      const promiseIndex = pendingPromises.findIndex(p => p.then(res => res.index === index));
      pendingPromises[promiseIndex] = nextPromise;
    } else {
      // Rimuovi la promise per l'iteratore completato
      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: 'Problema urgente', status: 'Aperto' };
  }
}

// Una funzione di supporto per creare un combinatore take (concettuale)
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--- Primi 5 Ticket di Supporto ---');
  for await (const ticket of top5TicketsIterator) {
    console.log(`ID: ${ticket.id}, Oggetto: ${ticket.subject}`);
  }
}

displayTopTickets();

            

              
                Copy
              
            
          

            async function* streamSystemLogs() {
  const logs = [
    'Avvio del sistema...', 'Inizializzazione dei servizi...', 'Connessione al database...',
    'Utente connesso: admin', 'Elaborazione richiesta ID 123', 'Richiesta elaborata con successo',
    'Utente connesso: guest', 'Elaborazione richiesta ID 124', 'Richiesta elaborata con successo'
  ];
  for (const log of logs) {
    await new Promise(resolve => setTimeout(resolve, 30));
    yield log;
  }
}

// Una funzione di supporto per creare un combinatore skip (concettuale)
function asyncSkip(iterator, count) {
  return (async function*() {
    let skippedCount = 0;
    let result;
    while (skippedCount < count && !(result = await iterator.next()).done) {
      skippedCount++;
    }
    // Ora continuiamo a produrre da dove ci eravamo interrotti
    while (!(result = await iterator.next()).done) {
      yield result.value;
    }
  })();
}

const relevantLogsIterator = asyncSkip(streamSystemLogs(), 3); // Salta i messaggi iniziali

async function displayRelevantLogs() {
  console.log('\n--- Log di Sistema Rilevanti ---');
  for await (const log of relevantLogsIterator) {
    console.log(log);
  }
}

displayRelevantLogs();

            

              
                Copy
              
            
          

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

async function* fetchCategories() {
  const categories = ['Elettronica', 'Libri', 'Abbigliamento'];
  for (const category of categories) {
    await new Promise(resolve => setTimeout(resolve, 50));
    // Produce un iteratore asincrono per i prodotti di questa categoria
    yield fetchProductsForCategory(category);
  }
}

// Una funzione di supporto per creare un combinatore flatten (concettuale)
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--- Tutti i Prodotti (Appiattiti) ---');
  for await (const product of allProductsFlattenedIterator) {
    console.log(`Prodotto: ${product.name}, Prezzo: ${product.price}`);
  }
}

displayFlattenedProducts();

            

              
                Copy
              
            
          

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

// Questa catena prima mappa gli utenti per aggiungere un fullName, poi filtra il primo utente,
// e infine prende i primi 3 degli utenti rimanenti.

            

              
                Copy