Générateurs Asynchrones JavaScript : Maîtriser les Modèles de Traitement de Flux

            
async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simule un délai asynchrone
    yield i;
  }
}

            

              
                Copy
              
            
          

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

consumeSequence(); // Sortie : 1 (après 500ms), 2 (après 1000ms), 3 (après 1500ms), 4 (après 2000ms), 5 (après 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(`Erreur HTTP ! statut : ${response.status}`);
    }

    const data = await response.json();

    if (data.length === 0) {
      return; // Plus de données
    }

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

    page++;
  }
}

async function processUsers() {
  const userGenerator = fetchUsers('https://api.example.com/users'); // Remplacez par le point de terminaison de votre API
  for await (const user of userGenerator) {
    console.log(user.name);
    // Traiter chaque utilisateur
  }
}

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) {
  // Simulation de la lecture asynchrone de journaux depuis un fichier
  const logs = [
    { timestamp: '2024-01-01T00:00:00', level: 'INFO', message: 'Système démarré' },
    { timestamp: '2024-01-01T00:00:05', level: 'WARN', message: 'Avertissement de mémoire faible' },
    { timestamp: '2024-01-01T00:00:10', level: 'ERROR', message: 'Échec de la connexion à la base de données' },
  ];

  for (const log of logs) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simule une lecture asynchrone
    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) {
  // Simule le traitement d'image
  await new Promise(resolve => setTimeout(resolve, 200));
  console.log(`Image traitée : ${imageUrl}`);
  return `Traité : ${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(() => {
            // Supprime la promesse terminée du tableau
            processingPromises.splice(processingPromises.indexOf(processingPromise), 1);
            // Commence le traitement de l'image suivante si possible
            if (processingPromises.length < concurrencyLimit) {
                processNextImage();
            }
        });

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

    // Lance les processus concurrents initiaux
    for (let i = 0; i < concurrencyLimit && i < imageUrls.length; i++) {
        processNextImage();
    }

    // Attend que toutes les promesses soient résolues avant de retourner
    await Promise.all(processingPromises);
    console.log('Toutes les images ont été traitées.');
}

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)); // Simule un producteur rapide
    yield `Donnée ${i++}`;
  }
}

async function consumeData() {
  const dataGenerator = generateData();
  const rateLimitedData = applyRateLimit(dataGenerator, 500); // Limite à un élément toutes les 500ms

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

// consumeData(); // Attention, ceci s'exécutera indéfiniment

            

              
                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 {
    // Opérations asynchrones qui pourraient lever des erreurs
    const data = await fetchData();
    yield data;
  } catch (error) {
    console.error('Erreur dans le générateur :', error);
    // Produire optionnellement une valeur d'erreur ou terminer le générateur
    yield { error: error.message };
    return; // Arrêter le générateur
  }
}

            

              
                Copy
              
            
          

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

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

async function consumeData() {
  const dataGenerator = fetchWithCancellation('https://api.example.com/data', signal); // Remplacez par le point de terminaison de votre API

  setTimeout(() => {
    controller.abort(); // Annule le fetch après 2 secondes
  }, 2000);

  try {
    for await (const data of dataGenerator) {
      console.log(data);
    }
  } catch (error) {
    console.error('Erreur pendant la consommation :', 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) {
    // Traite chaque ligne comme un enregistrement CSV
    const record = line.split(',');
    yield record;
  }
}

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

// processCSV();

            

              
                Copy