Generatori Asincroni JavaScript: Padroneggiare i Pattern di Elaborazione dei Flussi

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

            

              
                Copy
              
            
          

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

consumeSequence(); // Output: 1 (dopo 500ms), 2 (dopo 1000ms), 3 (dopo 1500ms), 4 (dopo 2000ms), 5 (dopo 2500ms)

            

              
                Copy
              
            
          

            
async function* fetchUsers(apiUrl) {
  let page = 1;
  while (true) {
    const url = `${apiUrl}?page=${page}`;
    const response = await fetch(url);

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();

    if (data.length === 0) {
      return; // Non ci sono più dati
    }

    for (const user of data) {
      yield user;
    }

    page++;
  }
}

async function processUsers() {
  const userGenerator = fetchUsers('https://api.example.com/users'); // Sostituisci con il tuo endpoint API
  for await (const user of userGenerator) {
    console.log(user.name);
    // Elabora ogni utente
  }
}

processUsers();

            

              
                Copy
              
            
          

            
async function* filterAndTransformLogs(logGenerator, filterKeyword) {
  for await (const logEntry of logGenerator) {
    if (logEntry.message.includes(filterKeyword)) {
      const transformedEntry = {
        timestamp: logEntry.timestamp,
        level: logEntry.level,
        message: logEntry.message.toUpperCase(),
      };
      yield transformedEntry;
    }
  }
}

async function* readLogsFromFile(filePath) {
  // Simula la lettura asincrona dei log da un file
  const logs = [
    { timestamp: '2024-01-01T00:00:00', level: 'INFO', message: 'System started' },
    { timestamp: '2024-01-01T00:00:05', level: 'WARN', message: 'Low memory warning' },
    { timestamp: '2024-01-01T00:00:10', level: 'ERROR', message: 'Database connection failed' },
  ];

  for (const log of logs) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simula lettura asincrona
    yield log;
  }
}

async function processFilteredLogs() {
  const logGenerator = readLogsFromFile('logs.txt');
  const filteredLogs = filterAndTransformLogs(logGenerator, 'ERROR');

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

processFilteredLogs();

            

              
                Copy
              
            
          

            
async function* generateImagePaths(imageUrls) {
  for (const url of imageUrls) {
    yield url;
  }
}

async function processImage(imageUrl) {
  // Simula l'elaborazione dell'immagine
  await new Promise(resolve => setTimeout(resolve, 200));
  console.log(`Processed image: ${imageUrl}`);
  return `Processed: ${imageUrl}`;
}

async function processImagesConcurrently(imageUrls, concurrencyLimit) {
    const imageGenerator = generateImagePaths(imageUrls);
    const processingPromises = [];

    async function processNextImage() {
        const { value, done } = await imageGenerator.next();

        if (done) {
            return;
        }

        const processingPromise = processImage(value);
        processingPromises.push(processingPromise);

        processingPromise.finally(() => {
            // Rimuove la promise completata dall'array
            processingPromises.splice(processingPromises.indexOf(processingPromise), 1);
            // Inizia l'elaborazione dell'immagine successiva se possibile
            if (processingPromises.length < concurrencyLimit) {
                processNextImage();
            }
        });

        if (processingPromises.length < concurrencyLimit) {
            processNextImage();
        }
    }

    // Avvia i processi concorrenti iniziali
    for (let i = 0; i < concurrencyLimit && i < imageUrls.length; i++) {
        processNextImage();
    }

    // Attende che tutte le promise si risolvano prima di terminare
    await Promise.all(processingPromises);
    console.log('All images processed.');
}

const imageUrls = [
  'https://example.com/image1.jpg',
  'https://example.com/image2.jpg',
  'https://example.com/image3.jpg',
  'https://example.com/image4.jpg',
  'https://example.com/image5.jpg',
];

processImagesConcurrently(imageUrls, 2);

            

              
                Copy
              
            
          

            
async function* applyRateLimit(dataGenerator, interval) {
  for await (const data of dataGenerator) {
    await new Promise(resolve => setTimeout(resolve, interval));
    yield data;
  }
}

async function* generateData() {
  let i = 0;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 10)); // Simula un produttore veloce
    yield `Data ${i++}`;
  }
}

async function consumeData() {
  const dataGenerator = generateData();
  const rateLimitedData = applyRateLimit(dataGenerator, 500); // Limita a un elemento ogni 500ms

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

// consumeData(); // Attenzione, questo ciclo verrà eseguito all'infinito

            

              
                Copy
              
            
          

            
async function* mergeStreams(stream1, stream2) {
  const iterator1 = stream1();
  const iterator2 = stream2();

  let next1 = iterator1.next();
  let next2 = iterator2.next();

  while (!((await next1).done && (await next2).done)) {
    if (!(await next1).done) {
      yield (await next1).value;
      next1 = iterator1.next();
    }
    if (!(await next2).done) {
      yield (await next2).value;
      next2 = iterator2.next();
    }
  }
}

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

async function* generateLetters(limit) {
  const letters = 'abcdefghijklmnopqrstuvwxyz';
  for (let i = 0; i < limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 150));
    yield letters[i];
  }
}

async function processMergedData() {
  const numberStream = () => generateNumbers(5);
  const letterStream = () => generateLetters(3);
  const mergedStream = mergeStreams(numberStream, letterStream);

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

processMergedData();

            

              
                Copy
              
            
          

            
async function* safeGenerator() {
  try {
    // Operazioni asincrone che potrebbero lanciare errori
    const data = await fetchData();
    yield data;
  } catch (error) {
    console.error('Error in generator:', error);
    // Opzionalmente, restituire un valore di errore o terminare il generatore
    yield { error: error.message };
    return; // Ferma il generatore
  }
}

            

              
                Copy
              
            
          

            
async function* fetchWithCancellation(url, signal) {
  try {
    const response = await fetch(url, { signal });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    yield data;
  } catch (error) {
    if (error.name === 'AbortError') {
      console.log('Fetch annullato');
      return;
    }
    throw error;
  }
}

const controller = new AbortController();
const { signal } = controller;

async function consumeData() {
  const dataGenerator = fetchWithCancellation('https://api.example.com/data', signal); // Sostituisci con il tuo endpoint API

  setTimeout(() => {
    controller.abort(); // Annulla il fetch dopo 2 secondi
  }, 2000);

  try {
    for await (const data of dataGenerator) {
      console.log(data);
    }
  } catch (error) {
    console.error('Error during consumption:', error);
  }
}

consumeData();

            

              
                Copy
              
            
          

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

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

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

  for await (const line of rl) {
    // Elabora ogni riga come un record CSV
    const record = line.split(',');
    yield record;
  }
}

async function processCSV() {
  const csvGenerator = readCSV('large_data.csv');
  for await (const record of csvGenerator) {
    // Elabora ogni record
    console.log(record);
  }
}

// processCSV();

            

              
                Copy