JavaScript Async Generator segítők: Adatfolyamok létrehozása és kezelése mesterfokon

Az aszinkron programozás a JavaScriptben jelentősen fejlődött az évek során. Az Aszinkron Generátorok és Aszinkron Iterátorok bevezetésével a fejlesztők hatékony eszközöket kaptak az aszinkron adatfolyamok kezelésére. Most a JavaScript Async Generator segítők tovább bővítik ezeket a képességeket, egy letisztultabb és kifejezőbb módot kínálva az aszinkron adatfolyamok létrehozására, átalakítására és kezelésére. Ez az útmutató bemutatja az Async Generator segítők alapjait, elmélyül a funkcionalitásukban, és világos példákkal demonstrálja gyakorlati alkalmazásaikat.

Az Aszinkron Generátorok és Iterátorok megértése

Mielőtt belemerülnénk az Async Generator segítőkbe, kulcsfontosságú megérteni az Aszinkron Generátorok és Aszinkron Iterátorok alapkoncepcióit.

Aszinkron Generátorok

Az Aszinkron Generátor egy olyan függvény, amely szüneteltethető és folytatható, és aszinkron módon ad vissza (yield) értékeket. Lehetővé teszi értékek sorozatának generálását az idő múlásával, anélkül, hogy blokkolná a fő szálat. Az Aszinkron Generátorokat az async function* szintaxissal definiáljuk.

Példa:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Aszinkron művelet szimulálása
    yield i;
  }
}

// Használat
const sequence = generateSequence(1, 5);

Aszinkron Iterátorok

Az Aszinkron Iterátor egy olyan objektum, amely egy next() metódust biztosít, ami egy promise-t ad vissza. Ez a promise egy olyan objektumra oldódik fel, amely a sorozat következő értékét és egy done tulajdonságot tartalmaz, jelezve, hogy a sorozat kimerült-e. Az Aszinkron Iterátorokat for await...of ciklusokkal fogyasztjuk.

Példa:

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

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

consumeSequence();

Az Aszinkron Generátor segítők bemutatása

Az Aszinkron Generátor segítők olyan metódusok összessége, amelyek kiterjesztik az Aszinkron Generátor prototípusok funkcionalitását. Kényelmes módszereket biztosítanak az aszinkron adatfolyamok manipulálására, olvashatóbbá és karbantarthatóbbá téve a kódot. Ezek a segítők lustán (lazily) működnek, ami azt jelenti, hogy csak akkor dolgozzák fel az adatokat, amikor arra szükség van, ami javíthatja a teljesítményt.

A következő Aszinkron Generátor segítők általában elérhetők (a JavaScript környezettől és a polyfillektől függően):

• map
• filter
• take
• drop
• flatMap
• reduce
• toArray
• forEach

Az Aszinkron Generátor segítők részletes bemutatása

1. `map()`

A map() segítő átalakítja az aszinkron sorozat minden egyes értékét egy megadott függvény alkalmazásával. Egy új Aszinkron Generátort ad vissza, amely a transzformált értékeket szolgáltatja.

Szintaxis:

asyncGenerator.map(callback)

Példa: Számok adatfolyamának átalakítása a négyzeteikre.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const squares = numbers.map(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100)); // Aszinkron művelet szimulálása
    return num * num;
  });

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

processNumbers();

Valós felhasználási eset: Képzelje el, hogy több API-ból kér le felhasználói adatokat, és azokat egységes formátumra kell alakítania. A map() segítségével aszinkron módon alkalmazhat egy átalakító függvényt minden felhasználói objektumra.

async function* fetchUsersFromMultipleAPIs(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const response = await fetch(endpoint);
    const data = await response.json();
    for (const user of data) {
      yield user;
    }
  }
}

async function processUsers() {
  const apiEndpoints = [
    'https://api.example.com/users1',
    'https://api.example.com/users2'
  ];

  const users = fetchUsersFromMultipleAPIs(apiEndpoints);

  const normalizedUsers = users.map(async (user) => {
    // Felhasználói adatformátum normalizálása
    return {
      id: user.userId || user.id,
      name: user.fullName || user.name,
      email: user.emailAddress || user.email
    };
  });

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

2. `filter()`

A filter() segítő egy új Aszinkron Generátort hoz létre, amely csak azokat az értékeket szolgáltatja az eredeti sorozatból, amelyek megfelelnek egy adott feltételnek. Lehetővé teszi az értékek szelektív bevonását az eredményül kapott adatfolyamba.

Szintaxis:

asyncGenerator.filter(callback)

Példa: Számok adatfolyamának szűrése, hogy csak a páros számokat tartalmazza.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 10);
  const evenNumbers = numbers.filter(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return num % 2 === 0;
  });

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

processNumbers();

Valós felhasználási eset: Naplóbejegyzések adatfolyamának feldolgozása és a bejegyzések súlyossági szint alapján történő szűrése. Például csak a hibák és figyelmeztetések feldolgozása.

async function* readLogFile(filePath) {
  // Naplófájl soronkénti aszinkron olvasásának szimulálása
  const logEntries = [
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' },
    { timestamp: '...', level: 'WARNING', message: '...' },
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' }
  ];

  for (const entry of logEntries) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield entry;
  }
}

async function processLogs() {
  const logEntries = readLogFile('path/to/log/file.log');
  const errorAndWarningLogs = logEntries.filter(async (entry) => {
    return entry.level === 'ERROR' || entry.level === 'WARNING';
  });

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

3. `take()`

A take() segítő egy új Aszinkron Generátort hoz létre, amely csak az első n értéket szolgáltatja az eredeti sorozatból. Hasznos a potenciálisan végtelen vagy nagyon nagy adatfolyamból feldolgozott elemek számának korlátozására.

Szintaxis:

asyncGenerator.take(n)

Példa: Az első 3 szám vétele egy számfolyamból.

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);
  const firstThree = numbers.take(3);

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

processNumbers();

Valós felhasználási eset: Az első 5 keresési találat megjelenítése egy aszinkron kereső API-ból.

async function* search(query) {
  // Keresési eredmények API-ból való lekérésének szimulálása
  const results = [
    { title: 'Result 1', url: '...' },
    { title: 'Result 2', url: '...' },
    { title: 'Result 3', url: '...' },
    { title: 'Result 4', url: '...' },
    { title: 'Result 5', url: '...' },
    { title: 'Result 6', url: '...' }
  ];

  for (const result of results) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield result;
  }
}

async function displayTopSearchResults(query) {
  const searchResults = search(query);
  const top5Results = searchResults.take(5);

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

4. `drop()`

A drop() segítő egy új Aszinkron Generátort hoz létre, amely kihagyja az első n értéket az eredeti sorozatból, és a fennmaradó értékeket szolgáltatja. Ez a take() ellentéte, és hasznos egy adatfolyam kezdeti részének figyelmen kívül hagyására.

Szintaxis:

asyncGenerator.drop(n)

Példa: Az első 2 szám eldobása egy számfolyamból.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const remainingNumbers = numbers.drop(2);

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

processNumbers();

Valós felhasználási eset: Lapozás egy API-ból lekérdezett nagy adathalmazon, a már megjelenített eredmények kihagyásával.

async function* fetchData(url, pageSize, pageNumber) {
  const offset = (pageNumber - 1) * pageSize;
  // Adatok lekérésének szimulálása offsettel
  const data = [
    { id: 1, name: 'Item 1' },
    { id: 2, name: 'Item 2' },
    { id: 3, name: 'Item 3' },
    { id: 4, name: 'Item 4' },
    { id: 5, name: 'Item 5' },
    { id: 6, name: 'Item 6' },
    { id: 7, name: 'Item 7' },
    { id: 8, name: 'Item 8' }
  ];

  const pageData = data.slice(offset, offset + pageSize);

  for (const item of pageData) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield item;
  }
}

async function displayPage(pageNumber) {
  const pageSize = 3;
  const allData = fetchData('api/data', pageSize, pageNumber);
  const page = allData.drop((pageNumber - 1) * pageSize);  // előző oldalak elemeinek kihagyása

  const results = page.take(pageSize);


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

// Példa használat
displayPage(2);

5. `flatMap()`

A flatMap() segítő átalakítja az aszinkron sorozat minden egyes értékét egy olyan függvény alkalmazásával, amely egy Aszinkron Iterálhatót ad vissza. Ezután az eredményül kapott Aszinkron Iterálhatót egyetlen Aszinkron Generátorrá lapítja. Ez akkor hasznos, ha minden értéket egy értékfolyammá alakítunk, majd ezeket az adatfolyamokat egyesítjük.

Szintaxis:

asyncGenerator.flatMap(callback)

Példa: Mondatok adatfolyamának átalakítása szavak adatfolyamává.

async function* generateSentences() {
  const sentences = [
    'This is the first sentence.',
    'This is the second sentence.',
    'This is the third sentence.'
  ];

  for (const sentence of sentences) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield sentence;
  }
}

async function* stringToWords(sentence) {
    const words = sentence.split(' ');
    for (const word of words) {
        await new Promise(resolve => setTimeout(resolve, 50));
        yield word;
    }
}

async function processSentences() {
  const sentences = generateSentences();
  const words = sentences.flatMap(async (sentence) => {
      return stringToWords(sentence);
  });

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

processSentences();

Valós felhasználási eset: Több blogbejegyzéshez tartozó kommentek lekérése és azok egyetlen adatfolyamba való egyesítése feldolgozás céljából.

async function* fetchBlogPostIds() {
  const blogPostIds = [1, 2, 3]; // Blogbejegyzés ID-k API-ból való lekérésének szimulálása
  for (const id of blogPostIds) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield id;
  }
}

async function* fetchCommentsForPost(postId) {
  // Kommentek lekérésének szimulálása egy blogbejegyzéshez API-ból
  const comments = [
    { postId: postId, text: `Comment 1 for post ${postId}` },
    { postId: postId, text: `Comment 2 for post ${postId}` }
  ];
  for (const comment of comments) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield comment;
  }
}

async function processComments() {
  const postIds = fetchBlogPostIds();
  const allComments = postIds.flatMap(async (postId) => {
    return fetchCommentsForPost(postId);
  });

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

6. `reduce()`

A reduce() segítő egy függvényt alkalmaz egy akkumulátorra és az Aszinkron Generátor minden egyes értékére (balról jobbra), hogy azt egyetlen értékre redukálja. Ez hasznos az adatok aggregálására egy aszinkron adatfolyamból.

Szintaxis:

asyncGenerator.reduce(callback, initialValue)

Példa: Egy adatfolyamban lévő számok összegének kiszámítása.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const sum = await numbers.reduce(async (accumulator, num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return accumulator + num;
  }, 0);

  console.log('Sum:', sum);
}

processNumbers();

Valós felhasználási eset: API hívások sorozatának átlagos válaszidejének kiszámítása.

async function* fetchResponseTimes(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const startTime = Date.now();
    try {
      await fetch(endpoint);
      const endTime = Date.now();
      const responseTime = endTime - startTime;
      await new Promise(resolve => setTimeout(resolve, 50));
      yield responseTime;
    } catch (error) {
      console.error(`Error fetching ${endpoint}: ${error}`);
      yield 0; // Vagy kezelje a hibát megfelelően
    }
  }
}

async function calculateAverageResponseTime() {
  const apiEndpoints = [
    'https://api.example.com/endpoint1',
    'https://api.example.com/endpoint2',
    'https://api.example.com/endpoint3'
  ];
  const responseTimes = fetchResponseTimes(apiEndpoints);

  let count = 0;
  const sum = await responseTimes.reduce(async (accumulator, time) => {
    count++;
    return accumulator + time;
  }, 0);

  const average = count > 0 ? sum / count : 0;
  console.log(`Average response time: ${average} ms`);
}

7. `toArray()`

A toArray() segítő elfogyasztja az Aszinkron Generátort, és egy olyan promise-t ad vissza, amely egy tömbre oldódik fel, ami a generátor által szolgáltatott összes értéket tartalmazza. Ez akkor hasznos, ha az adatfolyam összes értékét egyetlen tömbbe kell gyűjteni további feldolgozás céljából.

Szintaxis:

asyncGenerator.toArray()

Példa: Számok gyűjtése egy adatfolyamból egy tömbbe.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const numberArray = await numbers.toArray();

  console.log('Number Array:', numberArray);
}

processNumbers();

Valós felhasználási eset: Egy lapozott API-ból származó összes elem összegyűjtése egyetlen tömbbe kliensoldali szűrés vagy rendezés céljából.

async function* fetchAllItems(apiEndpoint) {
    let pageNumber = 1;
    const pageSize = 100;  // Az API lapozási korlátai alapján állítsa be

    while (true) {
        const url = `${apiEndpoint}?page=${pageNumber}&pageSize=${pageSize}`;
        const response = await fetch(url);
        const data = await response.json();

        if (!data || data.length === 0) {
            break; // Nincs több adat
        }

        for (const item of data) {
            await new Promise(resolve => setTimeout(resolve, 50));
            yield item;
        }

        pageNumber++;
    }
}

async function processAllItems() {
    const apiEndpoint = 'https://api.example.com/items';
    const allItems = fetchAllItems(apiEndpoint);
    const itemsArray = await allItems.toArray();

    console.log(`Fetched ${itemsArray.length} items.`);
    // További feldolgozás végezhető az `itemsArray`-en
}

8. `forEach()`

A forEach() segítő egy megadott függvényt hajt végre egyszer az Aszinkron Generátor minden egyes értékére. Más segítőkkel ellentétben a forEach() nem ad vissza új Aszinkron Generátort; mellékhatások végrehajtására használatos minden értéken.

Szintaxis:

asyncGenerator.forEach(callback)

Példa: Minden szám naplózása a konzolra egy adatfolyamban.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  await numbers.forEach(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log('Number:', num);
  });
}

processNumbers();

Valós felhasználási eset: Valós idejű frissítések küldése egy felhasználói felületre, ahogy az adatok feldolgozásra kerülnek egy adatfolyamból.

async function* fetchRealTimeData(dataSource) {
    //Valós idejű adatok (pl. részvényárak) lekérésének szimulálása.
    const dataStream = [
      { timestamp: new Date(), price: 100 },
      { timestamp: new Date(), price: 101 },
      { timestamp: new Date(), price: 102 }
    ];
    for (const dataPoint of dataStream) {
      await new Promise(resolve => setTimeout(resolve, 500));
      yield dataPoint;
    }
}

async function updateUI() {
  const realTimeData = fetchRealTimeData('stock-api');
  await realTimeData.forEach(async (data) => {
    //A felhasználói felület frissítésének szimulálása
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log(`Updating UI with data: ${JSON.stringify(data)}`);
    // A tényleges UI frissítő kód ide kerülne.
  });
}

Aszinkron Generátor segítők kombinálása komplex adatcsővezetékekhez

Az Aszinkron Generátor segítők valódi ereje abban rejlik, hogy láncba fűzhetők, hogy komplex adatcsővezetékeket hozzanak létre. Ez lehetővé teszi több átalakítás és művelet végrehajtását egy aszinkron adatfolyamon tömör és olvasható módon.

Példa: Számok adatfolyamának szűrése csak a páros számokra, majd azok négyzetre emelése, és végül az első 3 eredmény vétele.

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);

  const processedNumbers = numbers
    .filter(async (num) => num % 2 === 0)
    .map(async (num) => num * num)
    .take(3);

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

processNumbers();

Valós felhasználási eset: Felhasználói adatok lekérdezése, a felhasználók szűrése helyszín alapján, adataik átalakítása csak a releváns mezők megtartásával, majd az első 10 felhasználó megjelenítése egy térképen.

async function* fetchUsers() {
  // Felhasználók lekérdezésének szimulálása adatbázisból vagy API-ból
  const users = [
    { id: 1, name: 'John Doe', location: 'New York', email: 'john.doe@example.com' },
    { id: 2, name: 'Jane Smith', location: 'London', email: 'jane.smith@example.com' },
    { id: 3, name: 'Ken Tan', location: 'Singapore', email: 'ken.tan@example.com' },
    { id: 4, name: 'Alice Jones', location: 'New York', email: 'alice.jones@example.com' },
    { id: 5, name: 'Bob Williams', location: 'London', email: 'bob.williams@example.com' },
    { id: 6, name: 'Siti Rahman', location: 'Singapore', email: 'siti.rahman@example.com' },
    { id: 7, name: 'Ahmed Khan', location: 'Dubai', email: 'ahmed.khan@example.com' },
    { id: 8, name: 'Maria Garcia', location: 'Madrid', email: 'maria.garcia@example.com' },
    { id: 9, name: 'Li Wei', location: 'Shanghai', email: 'li.wei@example.com' },
    { id: 10, name: 'Hans Müller', location: 'Berlin', email: 'hans.muller@example.com' },
    { id: 11, name: 'Emily Chen', location: 'Sydney', email: 'emily.chen@example.com' }
  ];

  for (const user of users) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield user;
  }
}

async function displayUsersOnMap(location, maxUsers) {
  const users = fetchUsers();

  const usersForMap = users
    .filter(async (user) => user.location === location)
    .map(async (user) => ({
      id: user.id,
      name: user.name,
      location: user.location
    }))
    .take(maxUsers);

  console.log(`Displaying up to ${maxUsers} users from ${location} on the map:`);
  for await (const user of usersForMap) {
    console.log(user);
  }
}

// Használati példák:
displayUsersOnMap('New York', 2);
displayUsersOnMap('London', 5);

Polyfillek és böngészőtámogatás

Az Aszinkron Generátor segítők támogatottsága a JavaScript környezettől függően változhat. Ha régebbi böngészőket vagy környezeteket kell támogatnia, szükség lehet polyfillek használatára. Egy polyfill a hiányzó funkcionalitást biztosítja JavaScriptben implementálva. Számos polyfill könyvtár érhető el az Aszinkron Generátor segítőkhöz, mint például a core-js.

Példa a core-js használatával:

// A szükséges polyfillek importálása
require('core-js/features/async-iterator/map');
require('core-js/features/async-iterator/filter');
// ... egyéb szükséges segítők importálása

Hibakezelés

Aszinkron műveletekkel való munka során kulcsfontosságú a hibák megfelelő kezelése. Az Aszinkron Generátor segítőkkel a hibakezelés try...catch blokkok segítségével végezhető el a segítőkben használt aszinkron függvényeken belül.

Példa: Hibakezelés adatlekérdezés közben egy map() műveleten belül.

async function* fetchData(urls) {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      const data = await response.json();
      yield data;
    } catch (error) {
      console.error(`Error fetching data from ${url}: ${error}`);
      yield null; // Vagy kezelje a hibát megfelelően, pl. egy hiba objektum szolgáltatásával
    }
  }
}

async function processData() {
  const urls = [
    'https://api.example.com/data1',
    'https://api.example.com/data2',
    'https://api.example.com/data3'
  ];

  const dataStream = fetchData(urls);

  const processedData = dataStream.map(async (data) => {
    if (data === null) {
      return null; // A hiba továbbítása
    }
    // Az adat feldolgozása
    return data;
  });

  for await (const item of processedData) {
    if (item === null) {
      console.log('Skipping item due to error');
      continue;
    }
    console.log('Processed Item:', item);
  }
}

processData();

Bevált gyakorlatok és megfontolások

• Lusta kiértékelés (Lazy Evaluation): Az Aszinkron Generátor segítők lustán értékelődnek ki, ami azt jelenti, hogy csak akkor dolgozzák fel az adatokat, amikor arra kérés érkezik. Ez javíthatja a teljesítményt, különösen nagy adathalmazok esetén.
• Hibakezelés: Mindig kezelje megfelelően a hibákat a segítőkben használt aszinkron függvényeken belül.
• Polyfillek: Használjon polyfilleket, ha szükséges a régebbi böngészők vagy környezetek támogatásához.
• Olvashatóság: Használjon leíró változóneveket és kommenteket, hogy a kód olvashatóbbá és karbantarthatóbbá váljon.
• Teljesítmény: Legyen tudatában a több segítő láncba fűzésének teljesítményre gyakorolt hatásainak. Bár a lustaság segít, a túlzott láncolás még mindig okozhat többletterhelést.

Összegzés

A JavaScript Aszinkron Generátor segítők hatékony és elegáns módot kínálnak az aszinkron adatfolyamok létrehozására, átalakítására és kezelésére. Ezen segítők kihasználásával a fejlesztők tömörebb, olvashatóbb és karbantarthatóbb kódot írhatnak a komplex aszinkron műveletek kezelésére. Az Aszinkron Generátorok és Iterátorok alapjainak, valamint az egyes segítők funkcionalitásának megértése elengedhetetlen ezen eszközök hatékony felhasználásához valós alkalmazásokban. Akár adatcsővezetékeket épít, valós idejű adatokat dolgoz fel, vagy aszinkron API válaszokat kezel, az Aszinkron Generátor segítők jelentősen leegyszerűsíthetik a kódját és javíthatják annak általános hatékonyságát.