JavaScript asynkron iteratorhjälpare: For Each – Iteration för strömbehandling

Asynkron programmering är en hörnsten i modern JavaScript-utveckling, vilket gör det möjligt för applikationer att hantera tidskrävande operationer utan att blockera huvudtråden. Asynkrona iteratorer, som introducerades i ECMAScript 2018, erbjuder en kraftfull mekanism för att bearbeta dataströmmar asynkront. Detta blogginlägg fördjupar sig i konceptet med asynkrona iteratorer och visar hur man implementerar en asynkron 'for each'-hjälpfunktion för att effektivisera strömbehandling.

Förstå asynkrona iteratorer

En asynkron iterator är ett objekt som följer AsyncIterator-gränssnittet. Det definierar en next()-metod som returnerar ett promise, vilket löses till ett objekt med två egenskaper:

• value: Nästa värde i sekvensen.
• done: En boolean som indikerar om iteratorn har slutförts.

Asynkrona iteratorer används vanligtvis för att konsumera data från asynkrona källor som nätverksströmmar, filsystem eller databaser. for await...of-loopen erbjuder en bekväm syntax för att iterera över asynkrona itererbara objekt.

Exempel: Läsa från en fil asynkront

Tänk dig ett scenario där du behöver läsa en stor fil rad för rad utan att blockera huvudtråden. Du kan uppnå detta med hjälp av en asynkron iterator:

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

async function* readFileLines(filePath) {
  const fileStream = fs.createReadStream(filePath);
  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

async function processFile(filePath) {
  for await (const line of readFileLines(filePath)) {
    console.log(`Rad: ${line}`);
  }
}

// Exempelanvändning
processFile('sökväg/till/din/fil.txt');

            

              
                Copy
              
            
          

I detta exempel är readFileLines en asynkron generatorfunktion som yieldar varje rad i filen när den läses. Funktionen processFile itererar sedan över raderna med hjälp av for await...of och bearbetar varje rad asynkront.

Implementera en asynkron 'For Each'-hjälpfunktion

Även om for await...of-loopen är användbar, kan den bli mångordig när du behöver utföra komplexa operationer på varje element i strömmen. En asynkron 'for each'-hjälpfunktion kan förenkla denna process genom att kapsla in iterationslogiken.

Grundläggande implementation

Här är en grundläggande implementation av en asynkron 'for each'-funktion:

            
async function asyncForEach(iterable, callback) {
  for await (const item of iterable) {
    await callback(item);
  }
}

            

              
                Copy
              
            
          

Denna funktion tar ett asynkront itererbart objekt och en callback-funktion som argument. Den itererar över det itererbara objektet med for await...of och anropar callback-funktionen för varje element. Callback-funktionen bör också vara asynkron om du vill invänta dess slutförande innan du går vidare till nästa element.

Exempel: Bearbeta data från ett API

Anta att du hämtar data från ett API som returnerar en ström av objekt. Du kan använda den asynkrona 'for each'-hjälpfunktionen för att bearbeta varje objekt när det anländer:

            
async function* fetchDataStream(url) {
  const response = await fetch(url);
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        return;
      }

      // Förutsatt att API:et returnerar JSON-stycken
      const chunk = decoder.decode(value);
      const items = JSON.parse(`[${chunk.replace(/\}\{/g, '},{')}]`); //Dela upp stycken i en giltig JSON-array

      for(const item of items){
        yield item;
      }
    }
  } finally {
    reader.releaseLock();
  }
}

async function processItem(item) {
  // Simulera en asynkron operation
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log(`Bearbetar objekt: ${JSON.stringify(item)}`);
}

async function main() {
  const apiUrl = 'https://api.example.com/data'; // Ersätt med din API-slutpunkt
  await asyncForEach(fetchDataStream(apiUrl), processItem);
  console.log('Färdig med databearbetning.');
}

// Exempelanvändning
main();

            

              
                Copy
              
            
          

I detta exempel hämtar fetchDataStream data från API:et och yieldar varje objekt när det tas emot. Funktionen processItem simulerar en asynkron operation på varje objekt. Hjälpfunktionen asyncForEach förenklar sedan iterations- och bearbetningslogiken.

Förbättringar och överväganden

Felhantering

Det är avgörande att hantera fel som kan uppstå under asynkron iteration. Du kan omsluta callback-funktionen i ett try...catch-block för att fånga och hantera undantag:

            
async function asyncForEach(iterable, callback) {
  for await (const item of iterable) {
    try {
      await callback(item);
    } catch (error) {
      console.error(`Fel vid bearbetning av objekt: ${item}`, error);
      // Du kan välja att kasta om felet eller fortsätta bearbetningen
    }
  }
}

            

              
                Copy
              
            
          

Samtidighetskontroll

Som standard bearbetar den asynkrona 'for each'-hjälpfunktionen objekt sekventiellt. Om du behöver bearbeta objekt samtidigt kan du använda en Promise-pool för att begränsa antalet samtidiga operationer:

            
async function asyncForEachConcurrent(iterable, callback, concurrency) {
  const executing = [];
  for await (const item of iterable) {
    const p = callback(item).then(() => executing.splice(executing.indexOf(p), 1));
    executing.push(p);
    if (executing.length >= concurrency) {
      await Promise.race(executing);
    }
  }
  await Promise.all(executing);
}

async function processItem(item) {
  // Simulera en asynkron operation
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log(`Bearbetar objekt: ${JSON.stringify(item)}`);
}

async function main() {
  const apiUrl = 'https://api.example.com/data'; // Ersätt med din API-slutpunkt
  await asyncForEachConcurrent(fetchDataStream(apiUrl), processItem, 5); // Samtidighet på 5
  console.log('Färdig med databearbetning.');
}

            

              
                Copy
              
            
          

I detta exempel begränsar asyncForEachConcurrent antalet samtidiga callback-körningar till den angivna samtidighetsnivån. Detta kan förbättra prestandan vid hantering av stora dataströmmar.

Avbrytande

I vissa fall kan du behöva avbryta iterationsprocessen i förtid. Du kan uppnå detta genom att använda en AbortController:

            
async function asyncForEach(iterable, callback, signal) {
  for await (const item of iterable) {
    if (signal && signal.aborted) {
      console.log('Iteration avbruten.');
      return;
    }
    await callback(item);
  }
}

async function main() {
  const controller = new AbortController();
  const signal = controller.signal;

  setTimeout(() => {
    controller.abort(); // Avbryt efter 2 sekunder
  }, 2000);

  const apiUrl = 'https://api.example.com/data'; // Ersätt med din API-slutpunkt
  await asyncForEach(fetchDataStream(apiUrl), processItem, signal);
  console.log('Färdig med databearbetning.');
}

            

              
                Copy
              
            
          

I detta exempel kontrollerar asyncForEach-funktionen egenskapen signal.aborted före varje iteration. Om signalen har avbrutits stoppas iterationen.

Verkliga tillämpningar

Asynkrona iteratorer och den asynkrona 'for each'-hjälpfunktionen kan tillämpas på ett brett spektrum av verkliga scenarier:

• Databehandlingspipelines: Bearbetning av stora datamängder från databaser eller filsystem.
• Realtidsdataströmmar: Hantering av data från web sockets, meddelandeköer eller sensornätverk.
• API-konsumtion: Hämta och bearbeta data från API:er som returnerar strömmar av objekt.
• Bild- och videobearbetning: Bearbeta stora mediefiler i bitar.
• Logganalys: Analysera stora loggfiler rad för rad.

Exempel - Internationell aktiedata: Tänk dig en applikation som hämtar aktiekurser i realtid från olika internationella börser. En asynkron iterator kan användas för att strömma datan, och en asynkron 'for each' kan bearbeta varje kurs och uppdatera användargränssnittet med de senaste priserna. Detta kan användas för att visa aktuella aktiekurser för företag som:

• Tencent (Kina): Hämta aktiedata för ett stort internationellt teknikföretag
• Tata Consultancy Services (Indien): Visa aktieuppdateringar från ett ledande IT-tjänsteföretag
• Samsung Electronics (Sydkorea): Visa aktiekurser från en global elektroniktillverkare
• Toyota Motor Corporation (Japan): Övervaka aktiepriser för en internationell biltillverkare

Sammanfattning

Asynkrona iteratorer och den asynkrona 'for each'-hjälpfunktionen erbjuder ett kraftfullt och elegant sätt att bearbeta dataströmmar asynkront i JavaScript. Genom att kapsla in iterationslogiken kan du förenkla din kod, förbättra läsbarheten och öka prestandan i dina applikationer. Genom att hantera fel, kontrollera samtidighet och möjliggöra avbrytande kan du skapa robusta och skalbara asynkrona databehandlingspipelines.

Vidare läsning

• MDN Web Docs: for await...of
• MDN Web Docs: async function*
• ECMAScript-specifikation: AsyncIterator Interface