JavaScript Pomočniki za Asinhrone Generatorje: Obvladovanje Ustvarjanja in Upravljanja Podatkovnih Tokov

Asinhrono programiranje v JavaScriptu se je skozi leta močno razvilo. Z uvedbo Asinhronih Generatorjev in Asinhronih Iteratorjev so razvijalci dobili močna orodja za obdelavo tokov asinhronih podatkov. Zdaj pa JavaScript Pomočniki za Asinhrone Generatorje te zmožnosti še dodatno izboljšujejo, saj zagotavljajo bolj poenostavljen in izrazen način ustvarjanja, preoblikovanja in upravljanja asinhronih podatkovnih tokov. Ta vodnik raziskuje osnove Pomočnikov za Asinhrone Generatorje, se poglablja v njihove funkcionalnosti in prikazuje njihovo praktično uporabo z jasnimi primeri.

Razumevanje Asinhronih Generatorjev in Iteratorjev

Preden se poglobimo v Pomočnike za Asinhrone Generatorje, je ključnega pomena razumeti temeljne koncepte Asinhronih Generatorjev in Asinhronih Iteratorjev.

Asinhroni Generatorji

Asinhroni generator je funkcija, ki jo je mogoče zaustaviti in nadaljevati, pri čemer vrednosti vrača asinhrono. Omogoča vam generiranje zaporedja vrednosti skozi čas, ne da bi blokirali glavno nit. Asinhroni generatorji so definirani s sintakso async function*.

Primer:

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

// Uporaba
const sequence = generateSequence(1, 5);

Asinhroni Iteratorji

Asinhroni iterator je objekt, ki ponuja metodo next(), ki vrne obljubo (promise), ki se razreši v objekt, ki vsebuje naslednjo vrednost v zaporedju in lastnost done, ki označuje, ali je bilo zaporedje izčrpano. Asinhroni iteratorji se uporabljajo z zankami for await...of.

Primer:

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();

Predstavitev Pomočnikov za Asinhrone Generatorje

Pomočniki za Asinhrone Generatorje so nabor metod, ki razširjajo funkcionalnost prototipov Asinhronih Generatorjev. Ponujajo priročne načine za manipulacijo asinhronih podatkovnih tokov, s čimer postane koda bolj berljiva in vzdrževana. Ti pomočniki delujejo leno (lazily), kar pomeni, da obdelujejo podatke le, ko so potrebni, kar lahko izboljša zmogljivost.

Naslednji Pomočniki za Asinhrone Generatorje so običajno na voljo (odvisno od JavaScript okolja in polifilov):

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

Podrobna Raziskava Pomočnikov za Asinhrone Generatorje

1. `map()`

Pomočnik map() preoblikuje vsako vrednost v asinhronem zaporedju z uporabo podane funkcije. Vrne nov Asinhroni Generator, ki vrača preoblikovane vrednosti.

Sintaksa:

asyncGenerator.map(callback)

Primer: Pretvorba toka števil v njihove kvadrate.

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)); // Simulacija asinhrone operacije
    return num * num;
  });

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

processNumbers();

Primer uporabe v praksi: Predstavljajte si pridobivanje uporabniških podatkov iz več API-jev in potrebo po preoblikovanju podatkov v dosleden format. map() se lahko uporabi za asinhrono uporabo transformacijske funkcije na vsakem uporabniškem objektu.

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) => {
    // Normalizacija formata uporabniških podatkov
    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()`

Pomočnik filter() ustvari nov Asinhroni Generator, ki vrača samo tiste vrednosti iz prvotnega zaporedja, ki izpolnjujejo podan pogoj. Omogoča vam selektivno vključevanje vrednosti v nastali tok.

Sintaksa:

asyncGenerator.filter(callback)

Primer: Filtriranje toka števil, da se vključijo samo soda števila.

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();

Primer uporabe v praksi: Obdelava toka dnevniških zapisov in filtriranje zapisov glede na njihovo stopnjo resnosti. Na primer, obdelava samo napak in opozoril.

async function* readLogFile(filePath) {
  // Simulacija asinhronega branja dnevniške datoteke vrstico po vrstico
  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()`

Pomočnik take() ustvari nov Asinhroni Generator, ki vrača samo prvih n vrednosti iz prvotnega zaporedja. Uporaben je za omejevanje števila obdelanih elementov iz potencialno neskončnega ali zelo velikega toka.

Sintaksa:

asyncGenerator.take(n)

Primer: Vzemanje prvih 3 števil iz toka števil.

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();

Primer uporabe v praksi: Prikaz prvih 5 rezultatov iskanja iz asinhronega iskalnega API-ja.

async function* search(query) {
  // Simulacija pridobivanja rezultatov iskanja iz API-ja
  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()`

Pomočnik drop() ustvari nov Asinhroni Generator, ki preskoči prvih n vrednosti iz prvotnega zaporedja in vrne preostale vrednosti. Je nasprotje od take() in je uporaben za ignoriranje začetnih delov toka.

Sintaksa:

asyncGenerator.drop(n)

Primer: Izpuščanje prvih 2 števil iz toka števil.

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();

Primer uporabe v praksi: Paginacija skozi velik nabor podatkov, pridobljenih iz API-ja, pri čemer se preskočijo že prikazani rezultati.

async function* fetchData(url, pageSize, pageNumber) {
  const offset = (pageNumber - 1) * pageSize;
  // Simulacija pridobivanja podatkov z odmikom
  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);  // preskoči elemente s prejšnjih strani

  const results = page.take(pageSize);


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

// Primer uporabe
displayPage(2);

5. `flatMap()`

Pomočnik flatMap() preoblikuje vsako vrednost v asinhronem zaporedju z uporabo funkcije, ki vrne Asinhroni Iterable. Nato splošči nastali Asinhroni Iterable v en sam Asinhroni Generator. To je uporabno za preoblikovanje vsake vrednosti v tok vrednosti in nato združevanje teh tokov.

Sintaksa:

asyncGenerator.flatMap(callback)

Primer: Preoblikovanje toka stavkov v tok besed.

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();

Primer uporabe v praksi: Pridobivanje komentarjev za več blog objav in njihovo združevanje v en sam tok za obdelavo.

async function* fetchBlogPostIds() {
  const blogPostIds = [1, 2, 3]; // Simulacija pridobivanja ID-jev blog objav iz API-ja
  for (const id of blogPostIds) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield id;
  }
}

async function* fetchCommentsForPost(postId) {
  // Simulacija pridobivanja komentarjev za blog objavo iz API-ja
  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()`

Pomočnik reduce() uporabi funkcijo na akumulatorju in vsaki vrednosti Asinhronega Generatorja (od leve proti desni), da ga zmanjša na eno samo vrednost. To je uporabno za agregacijo podatkov iz asinhronega toka.

Sintaksa:

asyncGenerator.reduce(callback, initialValue)

Primer: Izračun vsote števil v toku.

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('Vsota:', sum);
}

processNumbers();

Primer uporabe v praksi: Izračun povprečnega odzivnega časa serije klicev API-ja.

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(`Napaka pri pridobivanju ${endpoint}: ${error}`);
      yield 0; // Ali pa ustrezno obravnavajte napako
    }
  }
}

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(`Povprečni odzivni čas: ${average} ms`);
}

7. `toArray()`

Pomočnik toArray() porabi Asinhroni Generator in vrne obljubo, ki se razreši v polje (array), ki vsebuje vse vrednosti, ki jih je vrnil generator. To je uporabno, ko morate zbrati vse vrednosti iz toka v eno samo polje za nadaljnjo obdelavo.

Sintaksa:

asyncGenerator.toArray()

Primer: Zbiranje števil iz toka v polje.

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('Polje števil:', numberArray);
}

processNumbers();

Primer uporabe v praksi: Zbiranje vseh elementov iz paginiranega API-ja v eno samo polje za filtriranje ali razvrščanje na strani odjemalca.

async function* fetchAllItems(apiEndpoint) {
    let pageNumber = 1;
    const pageSize = 100;  // Prilagodite glede na omejitve paginacije API-ja

    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; // Ni več podatkov
        }

        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(`Pridobljenih ${itemsArray.length} elementov.`);
    // Nadaljnjo obdelavo lahko izvedemo na `itemsArray`
}

8. `forEach()`

Pomočnik forEach() izvede podano funkcijo enkrat za vsako vrednost v Asinhronem Generatorju. Za razliko od drugih pomočnikov, forEach() ne vrne novega Asinhronega Generatorja; uporablja se za izvajanje stranskih učinkov na vsaki vrednosti.

Sintaksa:

asyncGenerator.forEach(callback)

Primer: Izpis vsakega števila v toku v konzolo.

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('Število:', num);
  });
}

processNumbers();

Primer uporabe v praksi: Pošiljanje posodobitev v realnem času v uporabniški vmesnik, ko se podatki obdelujejo iz toka.

async function* fetchRealTimeData(dataSource) {
    //Simulacija pridobivanja podatkov v realnem času (npr. cene delnic).
    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) => {
    //Simulacija posodabljanja UI
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log(`Posodabljanje UI s podatki: ${JSON.stringify(data)}`);
    // Koda za dejansko posodobitev UI bi bila tukaj.
  });
}

Združevanje Pomočnikov za Asinhrone Generatorje za Kompleksne Podatkovne Cevovode

Prava moč Pomočnikov za Asinhrone Generatorje se pokaže v njihovi zmožnosti veriženja za ustvarjanje kompleksnih podatkovnih cevovodov. To vam omogoča izvajanje večkratnih transformacij in operacij na asinhronem toku na jedrnat in berljiv način.

Primer: Filtriranje toka števil, da se vključijo samo soda števila, nato njihovo kvadriranje in na koncu jemanje prvih 3 rezultatov.

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();

Primer uporabe v praksi: Pridobivanje uporabniških podatkov, filtriranje uporabnikov glede na njihovo lokacijo, preoblikovanje njihovih podatkov, da vključujejo samo relevantna polja, in nato prikaz prvih 10 uporabnikov na zemljevidu.

async function* fetchUsers() {
  // Simulacija pridobivanja uporabnikov iz baze podatkov ali API-ja
  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(`Prikazujem do ${maxUsers} uporabnikov iz lokacije ${location} na zemljevidu:`);
  for await (const user of usersForMap) {
    console.log(user);
  }
}

// Primeri uporabe:
displayUsersOnMap('New York', 2);
displayUsersOnMap('London', 5);

Polifili in Podpora Brskalnikov

Podpora za Pomočnike za Asinhrone Generatorje se lahko razlikuje glede na JavaScript okolje. Če morate podpirati starejše brskalnike ali okolja, boste morda morali uporabiti polifile (polyfills). Polifil zagotavlja manjkajočo funkcionalnost z njeno implementacijo v JavaScriptu. Na voljo je več knjižnic polifilov za Pomočnike za Asinhrone Generatorje, kot je core-js.

Primer uporabe core-js:

// Uvoz potrebnih polifilov
require('core-js/features/async-iterator/map');
require('core-js/features/async-iterator/filter');
// ... uvozite druge potrebne pomočnike

Obravnavanje Napak

Pri delu z asinhronimi operacijami je ključnega pomena pravilno obravnavanje napak. Z Pomočniki za Asinhrone Generatorje je obravnavanje napak mogoče izvesti z bloki try...catch znotraj asinhronih funkcij, uporabljenih v pomočnikih.

Primer: Obravnavanje napak pri pridobivanju podatkov znotraj operacije map().

async function* fetchData(urls) {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP napaka! status: ${response.status}`);
      }
      const data = await response.json();
      yield data;
    } catch (error) {
      console.error(`Napaka pri pridobivanju podatkov iz ${url}: ${error}`);
      yield null; // Ali pa ustrezno obravnavajte napako, npr. z vračanjem objekta napake
    }
  }
}

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; // Prenesi napako naprej
    }
    // Obdelaj podatke
    return data;
  });

  for await (const item of processedData) {
    if (item === null) {
      console.log('Preskakujem element zaradi napake');
      continue;
    }
    console.log('Obdelan element:', item);
  }
}

processData();

Najboljše Prakse in Premisleki

• Leno Vrednotenje (Lazy Evaluation): Pomočniki za Asinhrone Generatorje se vrednotijo leno, kar pomeni, da obdelujejo podatke le, ko so zahtevani. To lahko izboljša zmogljivost, zlasti pri delu z velikimi nabori podatkov.
• Obravnavanje Napak: Vedno pravilno obravnavajte napake znotraj asinhronih funkcij, uporabljenih v pomočnikih.
• Polifili: Po potrebi uporabite polifile za podporo starejšim brskalnikom ali okoljem.
• Berljivost: Uporabljajte opisna imena spremenljivk in komentarje, da bo vaša koda bolj berljiva in vzdrževana.
• Zmogljivost: Bodite pozorni na posledice veriženja več pomočnikov na zmogljivost. Čeprav lenost pomaga, lahko pretirano veriženje še vedno povzroči dodatno obremenitev.

Zaključek

JavaScript Pomočniki za Asinhrone Generatorje ponujajo močan in eleganten način za ustvarjanje, preoblikovanje in upravljanje asinhronih podatkovnih tokov. Z uporabo teh pomočnikov lahko razvijalci pišejo bolj jedrnato, berljivo in vzdrževano kodo za obravnavo kompleksnih asinhronih operacij. Razumevanje osnov Asinhronih Generatorjev in Iteratorjev, skupaj s funkcionalnostmi vsakega pomočnika, je bistvenega pomena za učinkovito uporabo teh orodij v aplikacijah v resničnem svetu. Ne glede na to, ali gradite podatkovne cevovode, obdelujete podatke v realnem času ali upravljate z asinhronimi odgovori API-jev, lahko Pomočniki za Asinhrone Generatorje bistveno poenostavijo vašo kodo in izboljšajo njeno splošno učinkovitost.