ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர்கள்: ஸ்ட்ரீம் செயலாக்கத்திற்கான ஒரு விரிவான வழிகாட்டி

நவீன ஜாவாஸ்கிரிப்ட் மேம்பாட்டு உலகில், ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களைக் கையாள்வது ஒரு பொதுவான தேவையாகும். நீங்கள் ஒரு API-யிலிருந்து தரவைப் பெற்றாலும், நிகழ்நேர நிகழ்வுகளைச் செயலாக்கினாலும் அல்லது பெரிய தரவுத்தொகுப்புகளுடன் பணிபுரிந்தாலும், பதிலளிக்கக்கூடிய மற்றும் அளவிடக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கு ஒத்திசைவற்ற தரவை திறமையாக நிர்வகிப்பது மிகவும் முக்கியம். ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர்கள் இந்த சவால்களைச் சமாளிக்க ஒரு சக்திவாய்ந்த மற்றும் நேர்த்தியான தீர்வை வழங்குகின்றன.

அசிங்க் இட்டரேட்டர்கள் என்றால் என்ன?

அசிங்க் இட்டரேட்டர்கள் ஒரு நவீன ஜாவாஸ்கிரிப்ட் அம்சமாகும், இது ஸ்ட்ரீம்கள் அல்லது ஒத்திசைவற்ற API பதில்கள் போன்ற ஒத்திசைவற்ற தரவு மூலங்களை ஒரு கட்டுப்படுத்தப்பட்ட மற்றும் வரிசையான முறையில் மீண்டும் மீண்டும் பயன்படுத்த உங்களை அனுமதிக்கிறது. அவை வழக்கமான இட்டரேட்டர்களைப் போலவே இருக்கின்றன, ஆனால் அவற்றின் next() முறை ஒரு Promise-ஐத் திருப்பித் தருவதே முக்கிய வேறுபாடு. இது முக்கிய த்ரெட்டைத் தடுக்காமல் ஒத்திசைவாக வரும் தரவுகளுடன் பணியாற்ற உங்களை அனுமதிக்கிறது.

ஒரு வழக்கமான இட்டரேட்டரை ஒரு தொகுப்பிலிருந்து பொருட்களை ஒவ்வொன்றாகப் பெறுவதற்கான வழியாக நினைத்துப் பாருங்கள். நீங்கள் அடுத்த பொருளைக் கேட்கிறீர்கள், அதை உடனடியாகப் பெறுகிறீர்கள். மறுபுறம், ஒரு அசிங்க் இட்டரேட்டர், ஆன்லைனில் பொருட்களை ஆர்டர் செய்வது போன்றது. நீங்கள் ஆர்டரை வைக்கிறீர்கள் (next() ஐ அழைக்கிறீர்கள்), சிறிது நேரம் கழித்து, அடுத்த பொருள் வந்து சேர்கிறது (Promise தீர்க்கப்படுகிறது).

முக்கிய கருத்துக்கள்

• அசிங்க் இட்டரேட்டர்: இது ஒரு ஆப்ஜெக்ட் ஆகும், இது ஒரு next() முறையை வழங்குகிறது. இது ஒரு Promise-ஐத் திருப்பித் தருகிறது, அந்த Promise ஒரு வழக்கமான இட்டரேட்டரைப் போலவே value மற்றும் done பண்புகளைக் கொண்ட ஒரு ஆப்ஜெக்டாகத் தீர்க்கப்படுகிறது. value வரிசையில் அடுத்த உருப்படியைக் குறிக்கிறது, மேலும் done என்பது இட்டரேஷன் முடிந்துவிட்டதா என்பதைக் குறிக்கிறது.
• அசிங்க் ஜெனரேட்டர்: இது ஒரு சிறப்பு வகை ஃபங்ஷன் ஆகும், இது ஒரு அசிங்க் இட்டரேட்டரைத் திருப்பித் தருகிறது. இது yield என்ற கீவேர்டைப் பயன்படுத்தி ஒத்திசைவாக மதிப்புகளை உருவாக்குகிறது.
• for await...of லூப்: இது அசிங்க் இட்டரேட்டர்களில் மீண்டும் மீண்டும் செயல்படுவதற்காக பிரத்யேகமாக வடிவமைக்கப்பட்ட ஒரு மொழி கட்டமைப்பாகும். இது ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களைப் பயன்படுத்தும் செயல்முறையை எளிதாக்குகிறது.

அசிங்க் ஜெனரேட்டர்களைக் கொண்டு அசிங்க் இட்டரேட்டர்களை உருவாக்குதல்

அசிங்க் இட்டரேட்டர்களை உருவாக்குவதற்கான மிகவும் பொதுவான வழி அசிங்க் ஜெனரேட்டர்கள் மூலமாகும். ஒரு அசிங்க் ஜெனரேட்டர் என்பது async function* தொடரியலுடன் அறிவிக்கப்பட்ட ஒரு ஃபங்ஷன் ஆகும். ஃபங்ஷனுக்குள், நீங்கள் yield என்ற கீவேர்டைப் பயன்படுத்தி ஒத்திசைவாக மதிப்புகளை உருவாக்கலாம்.

உதாரணம்: ஒரு நிகழ்நேர தரவு ஊட்டத்தை உருவகப்படுத்துதல்

பங்கு விலைகள் அல்லது சென்சார் ரீடிங்குகள் போன்ற ஒரு நிகழ்நேர தரவு ஊட்டத்தை உருவகப்படுத்தும் ஒரு அசிங்க் ஜெனரேட்டரை உருவாக்குவோம். செயற்கையான தாமதங்களை அறிமுகப்படுத்தவும், ஒத்திசைவற்ற தரவு வருகையை உருவகப்படுத்தவும் setTimeout-ஐப் பயன்படுத்துவோம்.

            async function* generateDataFeed(count) {
  for (let i = 0; i < count; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate delay
    yield { timestamp: Date.now(), value: Math.random() * 100 };
  }
}

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில்:

• async function* generateDataFeed(count) என்பது ஒரு அசிங்க் ஜெனரேட்டரை அறிவிக்கிறது, இது உருவாக்கப்பட வேண்டிய தரவுப் புள்ளிகளின் எண்ணிக்கையைக் குறிக்கும் count என்ற ஆர்குமென்ட்டை எடுக்கிறது.
• for லூப் count முறை இயங்குகிறது.
• await new Promise(resolve => setTimeout(resolve, 500)) என்பது setTimeout-ஐப் பயன்படுத்தி 500ms தாமதத்தை அறிமுகப்படுத்துகிறது. இது நிகழ்நேர தரவு வருகையின் ஒத்திசைவற்ற தன்மையை உருவகப்படுத்துகிறது.
• yield { timestamp: Date.now(), value: Math.random() * 100 } என்பது ஒரு நேரமுத்திரை மற்றும் ஒரு ரேண்டம் மதிப்பைக் கொண்ட ஒரு ஆப்ஜெக்டை அளிக்கிறது. yield என்ற கீவேர்ட் ஃபங்ஷனின் செயல்பாட்டை இடைநிறுத்தி, மதிப்பை அழைப்பாளருக்குத் திருப்பித் தருகிறது.

for await...of மூலம் அசிங்க் இட்டரேட்டர்களைப் பயன்படுத்துதல்

ஒரு அசிங்க் இட்டரேட்டரைப் பயன்படுத்த, நீங்கள் for await...of லூப்பைப் பயன்படுத்தலாம். இந்த லூப் இட்டரேட்டரின் ஒத்திசைவற்ற தன்மையை தானாகவே கையாளுகிறது, அடுத்த இட்டரேஷனுக்குச் செல்வதற்கு முன் ஒவ்வொரு Promise-ம் தீர்க்கப்படும் வரை காத்திருக்கிறது.

உதாரணம்: தரவு ஊட்டத்தைச் செயலாக்குதல்

generateDataFeed அசிங்க் இட்டரேட்டரை ஒரு for await...of லூப்பைப் பயன்படுத்தி, ஒவ்வொரு தரவுப் புள்ளியையும் கன்சோலில் பதிவு செய்வோம்.

            async function processDataFeed() {
  for await (const data of generateDataFeed(5)) {
    console.log(`Received data: ${JSON.stringify(data)}`);
  }
  console.log('Data feed processing complete.');
}

processDataFeed();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில்:

• async function processDataFeed() என்பது தரவு செயலாக்கத்தைக் கையாள ஒரு ஒத்திசைவற்ற ஃபங்ஷனை அறிவிக்கிறது.
• for await (const data of generateDataFeed(5)) என்பது generateDataFeed(5) மூலம் திருப்பியளிக்கப்பட்ட அசிங்க் இட்டரேட்டரில் மீண்டும் மீண்டும் செயல்படுகிறது. await என்ற கீவேர்ட், ஒவ்வொரு தரவுப் புள்ளியும் வந்து சேரும் வரை லூப் காத்திருப்பதை உறுதி செய்கிறது.
• console.log(`Received data: ${JSON.stringify(data)}`) பெறப்பட்ட தரவுப் புள்ளியை கன்சோலில் பதிவு செய்கிறது.
• console.log('Data feed processing complete.') தரவு ஊட்ட செயலாக்கம் முடிந்துவிட்டது என்பதைக் குறிக்கும் ஒரு செய்தியைப் பதிவு செய்கிறது.

அசிங்க் இட்டரேட்டர்களைப் பயன்படுத்துவதன் நன்மைகள்

அசிங்க் இட்டரேட்டர்கள், கால்பேக்குகள் மற்றும் Promise-கள் போன்ற பாரம்பரிய ஒத்திசைவற்ற நிரலாக்க நுட்பங்களைக் காட்டிலும் பல நன்மைகளை வழங்குகின்றன:

• மேம்படுத்தப்பட்ட வாசிப்புத்திறன்: அசிங்க் இட்டரேட்டர்கள் மற்றும் for await...of லூப் ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களுடன் பணிபுரிய ஒரு ஒத்திசைவான மற்றும் எளிதில் புரிந்துகொள்ளக்கூடிய வழியை வழங்குகின்றன.
• எளிமைப்படுத்தப்பட்ட பிழை கையாளுதல்: for await...of லூப்பிற்குள் பிழைகளைக் கையாள நீங்கள் நிலையான try...catch பிளாக்குகளைப் பயன்படுத்தலாம், இது பிழை கையாளுதலை மிகவும் நேரடியானதாக ஆக்குகிறது.
• பேக்பிரஷர் கையாளுதல்: அசிங்க் இட்டரேட்டர்கள் பேக்பிரஷர் வழிமுறைகளை செயல்படுத்தப் பயன்படுத்தப்படலாம், நுகர்வோர் தரவு உற்பத்தி செய்யப்படும் விகிதத்தைக் கட்டுப்படுத்த அனுமதிக்கிறது, இது வளங்கள் தீர்ந்து போவதைத் தடுக்கிறது.
• இணைக்கும் தன்மை: சிக்கலான தரவு பைப்லைன்களை உருவாக்க அசிங்க் இட்டரேட்டர்களை எளிதாக இணைத்து சங்கிலியாக்கலாம்.
• ரத்துசெய்தல்: அசிங்க் இட்டரேட்டர்கள் ரத்துசெய்தலை ஆதரிக்கும் வகையில் வடிவமைக்கப்படலாம், இது தேவைப்பட்டால் நுகர்வோர் இட்டரேஷன் செயல்முறையை நிறுத்த அனுமதிக்கிறது.

நிஜ-உலக பயன்பாட்டு வழக்குகள்

அசிங்க் இட்டரேட்டர்கள் பல்வேறு நிஜ-உலக பயன்பாட்டு நிகழ்வுகளுக்கு மிகவும் பொருத்தமானவை, அவற்றுள்:

• API ஸ்ட்ரீமிங்: ஸ்ட்ரீமிங் பதில்களை ஆதரிக்கும் API-களிலிருந்து (எ.கா., சர்வர்-சென்ட் நிகழ்வுகள், வெப்சாக்கெட்டுகள்) தரவைப் பெறுதல்.
• கோப்பு செயலாக்கம்: பெரிய கோப்புகளை முழு கோப்பையும் நினைவகத்தில் ஏற்றாமல் துண்டுகளாகப் படித்தல். உதாரணமாக, ஒரு பெரிய CSV கோப்பை வரி வரியாக செயலாக்குதல்.
• நிகழ்நேர தரவு ஊட்டங்கள்: பங்குச் சந்தைகள், சமூக ஊடக தளங்கள் அல்லது IoT சாதனங்கள் போன்ற மூலங்களிலிருந்து நிகழ்நேர தரவு ஸ்ட்ரீம்களைச் செயலாக்குதல்.
• தரவுத்தள வினவல்கள்: தரவுத்தள வினவல்களிலிருந்து பெரிய முடிவுத் தொகுப்புகளை திறமையாக மீண்டும் மீண்டும் பெறுதல்.
• பின்னணிப் பணிகள்: துண்டுகளாக செயல்படுத்தப்பட வேண்டிய நீண்டகால பின்னணிப் பணிகளைச் செயல்படுத்துதல்.

உதாரணம்: ஒரு பெரிய கோப்பை துண்டுகளாகப் படித்தல்

ஒரு பெரிய கோப்பை துண்டுகளாகப் படிக்க அசிங்க் இட்டரேட்டர்களைப் பயன்படுத்துவது எப்படி என்பதை நிரூபிப்போம், ஒவ்வொரு துண்டையும் அது கிடைக்கும்போது செயலாக்குவோம். நினைவகத்தில் பொருந்தாத அளவுக்கு பெரிய கோப்புகளைக் கையாளும்போது இது குறிப்பாக பயனுள்ளதாக இருக்கும்.

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

async function* readLines(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 readLines(filePath)) {
    // Process each line here
    console.log(`Line: ${line}`);
  }
}

processFile('large_file.txt');

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில்:

• கோப்பை வரி வரியாகப் படிக்க fs மற்றும் readline மாட்யூல்களைப் பயன்படுத்துகிறோம்.
• readLines அசிங்க் ஜெனரேட்டர் கோப்பு ஸ்ட்ரீமைப் படிக்க ஒரு readline.Interface-ஐ உருவாக்குகிறது.
• for await...of லூப் கோப்பில் உள்ள வரிகளில் மீண்டும் மீண்டும் செயல்படுகிறது, ஒவ்வொரு வரியையும் அழைப்பாளருக்கு அளிக்கிறது.
• processFile ஃபங்ஷன் readLines அசிங்க் இட்டரேட்டரைப் பயன்படுத்தி ஒவ்வொரு வரியையும் செயலாக்குகிறது.

இந்த அணுகுமுறை, முழு கோப்பையும் நினைவகத்தில் ஏற்றாமல் பெரிய கோப்புகளைச் செயலாக்க உங்களை அனுமதிக்கிறது, இது மிகவும் திறமையானதாகவும் அளவிடக்கூடியதாகவும் ஆக்குகிறது.

மேம்பட்ட நுட்பங்கள்

பேக்பிரஷர் கையாளுதல்

பேக்பிரஷர் என்பது ஒரு பொறிமுறையாகும், இது நுகர்வோர் அதிக தரவைப் பெறத் தயாராக இல்லை என்று உற்பத்தியாளர்களுக்கு சமிக்ஞை செய்ய அனுமதிக்கிறது. இது உற்பத்தியாளர்கள் நுகர்வோரை அதிகமாகச் சுமை ஏற்றுவதைத் தடுத்து, வளங்கள் தீர்ந்து போவதைத் தடுக்கிறது.

அசிங்க் இட்டரேட்டர்கள், நுகர்வோர் இட்டரேட்டரிடமிருந்து தரவைக் கோரும் விகிதத்தைக் கட்டுப்படுத்த அனுமதிப்பதன் மூலம் பேக்பிரஷரை செயல்படுத்தப் பயன்படுத்தப்படலாம். உற்பத்தியாளர் பின்னர் நுகர்வோரின் கோரிக்கைகளின் அடிப்படையில் அதன் தரவு உருவாக்கும் விகிதத்தை சரிசெய்ய முடியும்.

ரத்துசெய்தல்

ரத்துசெய்தல் என்பது ஒரு ஒத்திசைவற்ற செயல்பாடு முடிவடைவதற்கு முன்பு அதை நிறுத்தும் திறன் ஆகும். அந்த செயல்பாடு இனி தேவைப்படாத அல்லது முடிக்க அதிக நேரம் எடுக்கும் சூழ்நிலைகளில் இது பயனுள்ளதாக இருக்கும்.

அசிங்க் இட்டரேட்டர்கள், நுகர்வோர் தரவு உற்பத்தியை நிறுத்த வேண்டும் என்று இட்டரேட்டருக்கு சமிக்ஞை செய்ய ஒரு பொறிமுறையை வழங்குவதன் மூலம் ரத்துசெய்தலை ஆதரிக்கும் வகையில் வடிவமைக்கப்படலாம். இட்டரேட்டர் பின்னர் எந்த வளங்களையும் சுத்தம் செய்து அழகாக முடித்துக் கொள்ள முடியும்.

அசிங்க் ஜெனரேட்டர்கள் மற்றும் ரியாக்டிவ் புரோகிராமிங் (RxJS) ஒப்பீடு

அசிங்க் இட்டரேட்டர்கள் ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களைக் கையாள ஒரு சக்திவாய்ந்த வழியை வழங்கினாலும், RxJS போன்ற ரியாக்டிவ் புரோகிராமிங் லைப்ரரிகள் சிக்கலான ரியாக்டிவ் பயன்பாடுகளை உருவாக்குவதற்கு ஒரு விரிவான கருவிகளின் தொகுப்பை வழங்குகின்றன. RxJS தரவு ஸ்ட்ரீம்களை மாற்றுவதற்கும், வடிகட்டுவதற்கும், மற்றும் இணைப்பதற்கும் ஒரு செழுமையான ஆபரேட்டர்களின் தொகுப்பையும், அத்துடன் அதிநவீன பிழை கையாளுதல் மற்றும் ஒத்திசைவு மேலாண்மை திறன்களையும் வழங்குகிறது.

இருப்பினும், உங்களுக்கு RxJS-ன் முழு சக்தி தேவைப்படாத சூழ்நிலைகளுக்கு அசிங்க் இட்டரேட்டர்கள் ஒரு எளிய மற்றும் இலகுவான மாற்றீட்டை வழங்குகின்றன. அவை ஒரு நேட்டிவ் ஜாவாஸ்கிரிப்ட் அம்சமாகும், அதாவது உங்கள் திட்டத்தில் எந்த வெளிப்புற சார்புகளையும் சேர்க்கத் தேவையில்லை.

அசிங்க் இட்டரேட்டர்கள் மற்றும் RxJS எப்போது பயன்படுத்துவது

• அசிங்க் இட்டரேட்டர்களைப் பயன்படுத்தவும்:
  • ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களைக் கையாள உங்களுக்கு ஒரு எளிய மற்றும் இலகுவான வழி தேவைப்படும்போது.
  • உங்களுக்கு ரியாக்டிவ் புரோகிராமிங்கின் முழு சக்தி தேவைப்படாதபோது.
  • உங்கள் திட்டத்தில் வெளிப்புற சார்புகளைச் சேர்ப்பதைத் தவிர்க்க விரும்பும்போது.
  • ஒத்திசைவற்ற தரவை ஒரு வரிசையான மற்றும் கட்டுப்படுத்தப்பட்ட முறையில் கையாள வேண்டியிருக்கும்போது.
• RxJS-ஐப் பயன்படுத்தவும்:
  • நீங்கள் அதிநவீன தரவு மாற்றங்கள் மற்றும் பிழை கையாளுதலுடன் சிக்கலான ரியாக்டிவ் பயன்பாடுகளை உருவாக்க வேண்டியிருக்கும்போது.
  • ஒத்திசைவு மற்றும் ஒத்திசைவற்ற செயல்பாடுகளை ஒரு வலுவான மற்றும் அளவிடக்கூடிய வழியில் நிர்வகிக்க வேண்டியிருக்கும்போது.
  • தரவு ஸ்ட்ரீம்களைக் கையாள உங்களுக்கு ஒரு செழுமையான ஆபரேட்டர்களின் தொகுப்பு தேவைப்படும்போது.
  • நீங்கள் ஏற்கனவே ரியாக்டிவ் புரோகிராமிங் கருத்துக்களுடன் பரிச்சயமானவராக இருக்கும்போது.

உலாவி இணக்கத்தன்மை மற்றும் பாலிஃபில்கள்

அசிங்க் இட்டரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்கள் அனைத்து நவீன உலாவிகள் மற்றும் நோட்.js பதிப்புகளில் ஆதரிக்கப்படுகின்றன. இருப்பினும், நீங்கள் பழைய உலாவிகள் அல்லது சூழல்களை ஆதரிக்க வேண்டியிருந்தால், நீங்கள் ஒரு பாலிஃபில்லைப் பயன்படுத்த வேண்டியிருக்கலாம்.

அசிங்க் இட்டரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்களுக்கு பல பாலிஃபில்கள் கிடைக்கின்றன, அவற்றுள்:

• core-js: அசிங்க் இட்டரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்களுக்கான ஆதரவை உள்ளடக்கிய ஒரு விரிவான பாலிஃபில் லைப்ரரி.
• regenerator-runtime: ரீஜெனரேட்டர் டிரான்ஸ்ஃபார்மைச் சார்ந்திருக்கும் அசிங்க் ஜெனரேட்டர்களுக்கான ஒரு பாலிஃபில்.

ஒரு பாலிஃபில்லைப் பயன்படுத்த, நீங்கள் பொதுவாக அதை உங்கள் திட்டத்தில் சேர்த்து, அசிங்க் இட்டரேட்டர்கள் அல்லது அசிங்க் ஜெனரேட்டர்களைப் பயன்படுத்துவதற்கு முன்பு அதை இறக்குமதி செய்ய வேண்டும்.

முடிவுரை

ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர்கள் ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களைக் கையாள ஒரு சக்திவாய்ந்த மற்றும் நேர்த்தியான தீர்வை வழங்குகின்றன. அவை மேம்படுத்தப்பட்ட வாசிப்புத்திறன், எளிமைப்படுத்தப்பட்ட பிழை கையாளுதல், மற்றும் பேக்பிரஷர் மற்றும் ரத்துசெய்தல் வழிமுறைகளைச் செயல்படுத்தும் திறனை வழங்குகின்றன. நீங்கள் API ஸ்ட்ரீமிங், கோப்பு செயலாக்கம், நிகழ்நேர தரவு ஊட்டங்கள் அல்லது தரவுத்தள வினவல்களுடன் பணிபுரிந்தாலும், அசிங்க் இட்டரேட்டர்கள் உங்களுக்கு மிகவும் திறமையான மற்றும் அளவிடக்கூடிய பயன்பாடுகளை உருவாக்க உதவும்.

அசிங்க் இட்டரேட்டர்கள் மற்றும் அசிங்க் ஜெனரேட்டர்களின் முக்கிய கருத்துக்களைப் புரிந்துகொள்வதன் மூலமும், for await...of லூப்பைப் பயன்படுத்துவதன் மூலமும், உங்கள் ஜாவாஸ்கிரிப்ட் திட்டங்களில் ஒத்திசைவற்ற ஸ்ட்ரீம் செயலாக்கத்தின் சக்தியை நீங்கள் திறக்கலாம்.

அசிங்க் இட்டரேட்டர்களுடன் பணிபுரிய உதவும் பயன்பாட்டு ஃபங்ஷன்களின் தொகுப்பிற்கு it-tools (https://www.npmjs.com/package/it-tools) போன்ற லைப்ரரிகளை ஆராய்வதைக் கவனியுங்கள்.

மேலும் ஆராய

• MDN Web Docs: for await...of
• TC39 Proposal: Async Iteration