Les Generators : Simplifier le traitement des flux de données

function* feelingGenerator() {
yield "I";
yield "love";
yield "coding";
}

const g = feelingGenerator();
console.log(g.next().value); // "I"
console.log(g.next().value); // "love"
console.log(g.next().value); // "coding"
console.log(g.next().value); // undefined

Dans cet exemple, la fonction feelingGenerator utilise le mot clé yield pour retourner successivement les valeurs “I”, “love”, et “coding”.
À chaque appel de next(), le generator reprend là où il s’était arrêté.

const iterator = iterable[Symbol.iterator]();
console.log(iterator.next()); // { value: 'Hello', done: false }
console.log(iterator.next()); // { value: 'World', done: false }
console.log(iterator.next()); // { value: undefined, done: true }

const iterable = {
    [Symbol.iterator]: function() {
        let step = 0;
        return {
            next: function() {
                step++;
                if (step === 1) {
                    return { value: 'Hello', done: false };
                } else if (step === 2) {
                    return { value: 'World', done: false };
                }
                    return { value: undefined, done: true };
                }
            };
        }
    }
};

for (const value of iterable) {
    console.log(value); // Hello, World
}

Pagination de données asynchrones

async function* generateRandomNumbers() {
    while (true) {
        await new Promise(resolve => setTimeout(resolve, 1000)); // Attente d'une seconde
        yield Math.random();
    }
}

const generator = generateRandomNumbers();

async function handleGenerator(gen) {
    for await (let number of gen) {
        handleRandom(number);
        if (someCondition) {
            gen.return();
        }
    }
}

handleGenerator(generator);

Ce generator génère une suite de nombre aléatoire de manière infini.

Ce type de flux est particulièrement utile lorsqu’on veut simuler ou surveiller un flux de données en continu.

index.js

async function bootstrap() {
  const file = await fs.open(path.join(import.meta.dirname, "./assets/athletes.txt"));
  const stream = file.readLines();

  for await (const chunk of stringifier(addCountryDetails(parser(stream)))) {
    console.log(chunk)
  }
}

generators.js

export const parser = async function* (input) {
  for await (const chunk of input) {
    yield JSON.parse(chunk);
  }
}

export async function* stringifier(input) {
  for await (const chunk of input) {
    const { country, sport, lastName, firstName } = chunk;
    yield `[${country.name}] [${sport}] ${firstName} ${lastName.toUpperCase()}`
  }
}

export const addCountryDetails = async function* (input) {
  for await (const chunk of input) {
    const { country: countryId, ...rest } = chunk ;
    const country = await getCountryById(countryId);
    yield { ...rest, country }
  }
}

/**
 * Build a generator that apply fn passed on each data from input that will received
 * 
 * @param {Function} fn 
 * @returns {AsyncGenerator} generator
 */
export function toConsumerGenerator(fn) {
  return async function* (input) {
    for await (const chunk of input) {
      yield fn(chunk);
    }
  }
}

/**
 * Stringify with defined format data passed
 */
function stringifier(data) {
  const { country, sport, lastName, firstName } = data;
  return `[${country.name}] [${sport}] ${firstName} ${lastName.toUpperCase()}`
}

export const stringifierGenerator = toConsumerGenerator(stringifier);

/**
 * Chain list of generators and return result
 * 
 * @param  {...(GeneratorFunction|AsyncGeneratorFunction)} fns - ordered array of operations
 * @returns result data (array or unique data)
 */
export async function chain(...fns) {
  const dataPipe = fns.filter(Boolean).reduce(
    (accumulatedData, fn) => fn(accumulatedData),
    undefined
  );

  let results = [];
  for await (const result of dataPipe) {
    results.push(result);
  }

  return results.length === 1 ? results[0] : results;
}

async function bootstrap() {
  const file = await fs.open(path.join(import.meta.dirname, "./assets/athletes.txt"));
  const stream = file.readLines();

  await chain(
    stream,
    parser,
    addCountryDetails,
    stringifier,
    logger // méthode console.log wrappé dans toConsumerGenerator
  );
}

L’intégralité des exemples se trouve sur mon repo github: nesimer/talks/Generators Lab