ஜாவாஸ்கிரிப்ட் Async Iterator Helper: Zip உடன் Async Stream இணைப்பில் தேர்ச்சி பெறுதல்

ஒத்திசைவற்ற நிரலாக்கம் நவீன ஜாவாஸ்கிரிப்ட் மேம்பாட்டின் ஒரு மூலக்கல்லாகும், இது பிரதான த்ரெட்டைத் தடுக்காத செயல்பாடுகளைக் கையாள நமக்கு உதவுகிறது. Async இட்டரேட்டர்கள் மற்றும் ஜெனரேட்டர்களின் அறிமுகத்துடன், தரவுகளின் ஒத்திசைவற்ற ஸ்ட்ரீம்களைக் கையாளுவது மிகவும் நிர்வகிக்கக்கூடியதாகவும் நேர்த்தியாகவும் மாறியுள்ளது. இப்போது, Async Iterator Helpers-இன் வருகையுடன், இந்த ஸ்ட்ரீம்களைக் கையாளுவதற்கு இன்னும் சக்திவாய்ந்த கருவிகளைப் பெறுகிறோம். ஒரு குறிப்பாகப் பயனுள்ள ஹெல்பர் zip செயல்பாடு ஆகும், இது பல ஒத்திசைவற்ற ஸ்ட்ரீம்களை ஒற்றை ஸ்ட்ரீம் டூப்பிள்களாக இணைக்க அனுமதிக்கிறது. இந்த வலைப்பதிவு இடுகை zip ஹெல்பரை ஆழமாக ஆராய்கிறது, அதன் செயல்பாடு, பயன்பாட்டு வழக்குகள் மற்றும் நடைமுறை எடுத்துக்காட்டுகளை ஆராய்கிறது.

Async இட்டரேட்டர்கள் மற்றும் ஜெனரேட்டர்களைப் புரிந்துகொள்ளுதல்

zip ஹெல்பருக்குள் செல்வதற்கு முன், Async இட்டரேட்டர்கள் மற்றும் ஜெனரேட்டர்களை சுருக்கமாகப் பார்ப்போம்:

• Async இட்டரேட்டர்கள்: இட்டரேட்டர் நெறிமுறைக்கு இணங்க ஆனால் ஒத்திசைவற்ற முறையில் செயல்படும் ஒரு பொருள். இது ஒரு next() முறையைக் கொண்டுள்ளது, இது ஒரு இட்டரேட்டர் முடிவுப் பொருளுக்கு ({ value: any, done: boolean }) தீர்க்கும் ஒரு ப்ராமிஸைத் தருகிறது.
• Async ஜெனரேட்டர்கள்: Async இட்டரேட்டர் பொருட்களைத் தரும் செயல்பாடுகள். அவை async மற்றும் yield முக்கிய வார்த்தைகளைப் பயன்படுத்தி மதிப்புகளை ஒத்திசைவற்ற முறையில் உருவாக்குகின்றன.

இங்கே ஒரு Async ஜெனரேட்டரின் எளிய உதாரணம்:

async function* generateNumbers(count) {
  for (let i = 0; i < count; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simulate async operation
    yield i;
  }
}

இந்த ஜெனரேட்டர் 0 முதல் count - 1 வரையிலான எண்களை அளிக்கிறது, ஒவ்வொரு மகசூலுக்கும் இடையில் 100ms தாமதத்துடன்.

Async Iterator Helper-ஐ அறிமுகப்படுத்துதல்: Zip

zip ஹெல்பர் என்பது AsyncIterator ப்ரோட்டோடைப்பில் சேர்க்கப்பட்ட ஒரு ஸ்டேடிக் மெத்தட் ஆகும் (அல்லது சூழலைப் பொறுத்து ஒரு குளோபல் செயல்பாடாகக் கிடைக்கும்). இது பல Async இட்டரேட்டர்களை (அல்லது Async இட்டரபிள்களை) வாதங்களாக எடுத்து ஒரு புதிய Async இட்டரேட்டரைத் தருகிறது. இந்த புதிய இட்டரேட்டர் வரிசைகளை (டூப்பிள்கள்) அளிக்கிறது, அங்கு வரிசையின் ஒவ்வொரு உறுப்பும் தொடர்புடைய உள்ளீட்டு இட்டரேட்டரிலிருந்து வருகிறது. உள்ளீட்டு இட்டரேட்டர்களில் ஏதேனும் ஒன்று தீர்ந்துவிட்டால் இட்டரேஷன் நின்றுவிடும்.

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

தொடரியல்

AsyncIterator.zip(iterator1, iterator2, ..., iteratorN);

திரும்பப் பெறும் மதிப்பு

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

Async Iterator Helper Zip-இன் பயன்பாட்டு வழக்குகள்

zip ஹெல்பர் பல்வேறு சக்திவாய்ந்த பயன்பாட்டு வழக்குகளைத் திறக்கிறது. இங்கே சில பொதுவான காட்சிகள் உள்ளன:

1. பல API-களிலிருந்து தரவை இணைத்தல்: நீங்கள் இரண்டு வெவ்வேறு API-களிலிருந்து தரவைப் பெற்று, பொதுவான விசை (எ.கா., பயனர் ஐடி) அடிப்படையில் முடிவுகளை இணைக்க வேண்டும் என்று கற்பனை செய்து பாருங்கள். ஒவ்வொரு API-இன் தரவு ஸ்ட்ரீமுக்கும் Async இட்டரேட்டர்களை உருவாக்கி, பின்னர் அவற்றை ஒன்றாகச் செயலாக்க zip-ஐப் பயன்படுத்தலாம்.
2. நிகழ்நேர தரவு ஸ்ட்ரீம்களைச் செயலாக்குதல்: நிகழ்நேரத் தரவைக் கையாளும் பயன்பாடுகளில் (எ.கா., நிதிச் சந்தைகள், சென்சார் தரவு), நீங்கள் பல புதுப்பிப்பு ஸ்ட்ரீம்களைக் கொண்டிருக்கலாம். இந்த புதுப்பிப்புகளை நிகழ்நேரத்தில் தொடர்புபடுத்த zip உங்களுக்கு உதவும். எடுத்துக்காட்டாக, நடுத்தர விலையைக் கணக்கிட வெவ்வேறு பரிமாற்றங்களிலிருந்து ஏலம் மற்றும் கேட்கும் விலைகளை இணைத்தல்.
3. இணை தரவு செயலாக்கம்: தொடர்புடைய தரவுகளில் செய்யப்பட வேண்டிய பல ஒத்திசைவற்ற பணிகள் உங்களிடம் இருந்தால், செயல்பாட்டை ஒருங்கிணைத்து முடிவுகளை இணைக்க zip-ஐப் பயன்படுத்தலாம்.
4. UI புதுப்பிப்புகளை ஒத்திசைத்தல்: முன்பக்க மேம்பாட்டில், UI-ஐப் புதுப்பிப்பதற்கு முன் முடிக்க வேண்டிய பல ஒத்திசைவற்ற செயல்பாடுகள் உங்களிடம் இருக்கலாம். இந்தச் செயல்பாடுகளை ஒத்திசைத்து, அனைத்து செயல்பாடுகளும் முடிந்ததும் UI புதுப்பிப்பைத் தூண்ட zip உங்களுக்கு உதவும்.

நடைமுறை உதாரணங்கள்

சில நடைமுறை உதாரணங்களுடன் zip ஹெல்பரை விளக்குவோம்.

உதாரணம் 1: இரண்டு Async ஜெனரேட்டர்களை Zip செய்தல்

இந்த உதாரணம் எண்கள் மற்றும் எழுத்துக்களின் வரிசைகளை உருவாக்கும் இரண்டு எளிய Async ஜெனரேட்டர்களை எப்படி ஜிப் செய்வது என்பதைக் காட்டுகிறது:

async function* generateNumbers(count) {
  for (let i = 1; i <= count; i++) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield i;
  }
}

async function* generateLetters(count) {
  const letters = 'abcdefghijklmnopqrstuvwxyz';
  for (let i = 0; i < count; i++) {
    await new Promise(resolve => setTimeout(resolve, 75));
    yield letters[i];
  }
}

async function main() {
  const numbers = generateNumbers(5);
  const letters = generateLetters(5);

  const zipped = AsyncIterator.zip(numbers, letters);

  for await (const [number, letter] of zipped) {
    console.log(`Number: ${number}, Letter: ${letter}`);
  }
}

main();
// Expected output (order may vary slightly due to async nature):
// Number: 1, Letter: a
// Number: 2, Letter: b
// Number: 3, Letter: c
// Number: 4, Letter: d
// Number: 5, Letter: e

உதாரணம் 2: இரண்டு போலி API-களிலிருந்து தரவை இணைத்தல்

இந்த உதாரணம் இரண்டு வெவ்வேறு API-களிலிருந்து தரவைப் பெறுவதையும் பயனர் ஐடியை அடிப்படையாகக் கொண்டு முடிவுகளை இணைப்பதையும் உருவகப்படுத்துகிறது:

async function* fetchUserData(userIds) {
  for (const userId of userIds) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield { userId, name: `User ${userId}`, country: (userId % 2 === 0 ? 'USA' : 'Canada') };
  }
}

async function* fetchUserPreferences(userIds) {
  for (const userId of userIds) {
    await new Promise(resolve => setTimeout(resolve, 150));
    yield { userId, theme: (userId % 3 === 0 ? 'dark' : 'light'), notifications: true };
  }
}

async function main() {
  const userIds = [1, 2, 3, 4, 5];
  const userData = fetchUserData(userIds);
  const userPreferences = fetchUserPreferences(userIds);

  const zipped = AsyncIterator.zip(userData, userPreferences);

  for await (const [user, preferences] of zipped) {
    if (user.userId === preferences.userId) {
      console.log(`User ID: ${user.userId}, Name: ${user.name}, Country: ${user.country}, Theme: ${preferences.theme}, Notifications: ${preferences.notifications}`);
    } else {
      console.log(`Mismatched user data for ID: ${user.userId}`);
    }
  }
}

main();
// Expected Output:
// User ID: 1, Name: User 1, Country: Canada, Theme: light, Notifications: true
// User ID: 2, Name: User 2, Country: USA, Theme: light, Notifications: true
// User ID: 3, Name: User 3, Country: Canada, Theme: dark, Notifications: true
// User ID: 4, Name: User 4, Country: USA, Theme: light, Notifications: true
// User ID: 5, Name: User 5, Country: Canada, Theme: light, Notifications: true

உதாரணம் 3: ReadableStreams-ஐக் கையாளுதல்

இந்த உதாரணம் zip ஹெல்பரை ReadableStream நிகழ்வுகளுடன் எவ்வாறு பயன்படுத்துவது என்பதைக் காட்டுகிறது. நெட்வொர்க் அல்லது கோப்புகளிலிருந்து ஸ்ட்ரீமிங் தரவைக் கையாளும்போது இது குறிப்பாக பொருத்தமானது.

async function* readableStreamToAsyncGenerator(stream) {
  const reader = stream.getReader();
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) return;
      yield value;
    }
  } finally {
    reader.releaseLock();
  }
}

async function main() {
  const stream1 = new ReadableStream({
    start(controller) {
      controller.enqueue('Stream 1 - Part 1\n');
      controller.enqueue('Stream 1 - Part 2\n');
      controller.close();
    }
  });

  const stream2 = new ReadableStream({
    start(controller) {
      controller.enqueue('Stream 2 - Line A\n');
      controller.enqueue('Stream 2 - Line B\n');
      controller.enqueue('Stream 2 - Line C\n');
      controller.close();
    }
  });

  const asyncGen1 = readableStreamToAsyncGenerator(stream1);
  const asyncGen2 = readableStreamToAsyncGenerator(stream2);

  const zipped = AsyncIterator.zip(asyncGen1, asyncGen2);

  for await (const [chunk1, chunk2] of zipped) {
    console.log(`Stream 1: ${chunk1}, Stream 2: ${chunk2}`);
  }
}

main();
// Expected output (order may vary):
// Stream 1: Stream 1 - Part 1\n, Stream 2: Stream 2 - Line A\n
// Stream 1: Stream 1 - Part 2\n, Stream 2: Stream 2 - Line B\n
// Stream 1: undefined, Stream 2: Stream 2 - Line C\n

ReadableStreams பற்றிய முக்கிய குறிப்புகள்: ஒரு ஸ்ட்ரீம் மற்றொன்றுக்கு முன் முடிந்தால், zip ஹெல்பர் அனைத்து ஸ்ட்ரீம்களும் தீர்ந்து போகும் வரை தொடர்ந்து செயல்படும். எனவே, ஏற்கனவே முடிந்த ஸ்ட்ரீம்களுக்கு undefined மதிப்புகளை நீங்கள் சந்திக்க நேரிடலாம். கையாளப்படாத நிராகரிப்புகளைத் தடுக்கவும், சரியான ஸ்ட்ரீம் மூடுதலை உறுதிப்படுத்தவும் readableStreamToAsyncGenerator-க்குள் பிழை கையாளுதல் மிகவும் முக்கியமானது.

பிழை கையாளுதல்

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

• Try-Catch Blocks: இட்டரேட்டர்களால் வீசப்படக்கூடிய எந்த விதிவிலக்குகளையும் பிடிக்க for await...of லூப்பை ஒரு try-catch பிளாக்கில் போர்த்தவும்.
• பிழை பரவல்: உள்ளீட்டு இட்டரேட்டர்களில் ஏதேனும் ஒன்று பிழையை வீசினால், zip ஹெல்பர் அந்தப் பிழையை அதன் விளைவாக வரும் இட்டரேட்டருக்குப் பரப்பும். பயன்பாட்டு செயலிழப்புகளைத் தடுக்க இந்த பிழைகளை மென்மையாகக் கையாள்வதை உறுதிசெய்க.
• ரத்துசெய்தல்: உங்கள் Async இட்டரேட்டர்களில் ரத்துசெய்தல் ஆதரவைச் சேர்ப்பதைக் கவனியுங்கள். ஒரு இட்டரேட்டர் தோல்வியுற்றால் அல்லது ரத்துசெய்யப்பட்டால், தேவையற்ற வேலையைத் தவிர்க்க மற்ற இட்டரேட்டர்களையும் ரத்துசெய்ய விரும்பலாம். நீண்டகால செயல்பாடுகளைக் கையாளும்போது இது மிகவும் முக்கியமானது.

async function main() {
  async function* generateWithError(count) {
    for (let i = 0; i < count; i++) {
      await new Promise(resolve => setTimeout(resolve, 100));
      if (i === 2) {
        throw new Error('Simulated error');
      }
      yield i;
    }
  }

  const numbers1 = generateNumbers(5);
  const numbers2 = generateWithError(5);

  try {
    const zipped = AsyncIterator.zip(numbers1, numbers2);

    for await (const [num1, num2] of zipped) {
      console.log(`Number 1: ${num1}, Number 2: ${num2}`);
    }
  } catch (error) {
    console.error(`Error: ${error.message}`);
  }
}

உலாவி மற்றும் Node.js இணக்கத்தன்மை

Async இட்டரேட்டர் ஹெல்பர்கள் ஜாவாஸ்கிரிப்ட்டில் ஒப்பீட்டளவில் ஒரு புதிய அம்சமாகும். Async இட்டரேட்டர் ஹெல்பர்களுக்கான உலாவி ஆதரவு வளர்ந்து வருகிறது. சமீபத்திய இணக்கத்தன்மைத் தகவலுக்கு MDN ஆவணத்தைப் பார்க்கவும். பழைய உலாவிகளை ஆதரிக்க பாலிஃபில்கள் அல்லது டிரான்ஸ்பைலர்களை (பேபல் போன்றவை) நீங்கள் பயன்படுத்த வேண்டியிருக்கலாம்.

Node.js-இல், Async இட்டரேட்டர் ஹெல்பர்கள் சமீபத்திய பதிப்புகளில் (பொதுவாக Node.js 18+) கிடைக்கின்றன. இந்த அம்சங்களைப் பயன்படுத்த நீங்கள் இணக்கமான Node.js பதிப்பைப் பயன்படுத்துவதை உறுதிசெய்க. இதைப் பயன்படுத்த, எந்த இறக்குமதியும் தேவையில்லை, இது ஒரு குளோபல் பொருளாகும்.

AsyncIterator.zip-க்கு மாற்றுகள்

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

• தனிப்பயன் செயலாக்கம்: Async ஜெனரேட்டர்கள் மற்றும் ப்ராமிஸ்களைப் பயன்படுத்தி உங்கள் சொந்த zip செயல்பாட்டை எழுதலாம். இது செயலாக்கத்தின் மீது முழுமையான கட்டுப்பாட்டை உங்களுக்கு வழங்குகிறது, ஆனால் அதிக குறியீடு தேவைப்படுகிறது.
• `it-utils` போன்ற லைப்ரரிகள்: `it-utils` (`js-it` சுற்றுச்சூழல் அமைப்பின் ஒரு பகுதி) போன்ற லைப்ரரிகள், ஒத்திசைவற்ற இட்டரேட்டர்கள் உட்பட இட்டரேட்டர்களுடன் பணிபுரிய பயன்பாட்டுச் செயல்பாடுகளை வழங்குகின்றன. இந்த லைப்ரரிகள் பெரும்பாலும் ஜிப்பிங்கிற்கு அப்பாற்பட்ட பரந்த அளவிலான அம்சங்களை வழங்குகின்றன.

Async Iterator Helpers-ஐப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

zip போன்ற Async இட்டரேட்டர் ஹெல்பர்களை திறம்பட பயன்படுத்த, இந்த சிறந்த நடைமுறைகளைக் கவனியுங்கள்:

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

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

Async இட்டரேட்டர் ஹெல்பர்களின் அடிப்படைகளில் நீங்கள் வசதியாகிவிட்டால், நீங்கள் மேலும் மேம்பட்ட நுட்பங்களை ஆராயலாம்:

• ஹெல்பர்களை சங்கிலியாக்குதல்: சிக்கலான தரவு மாற்றங்களைச் செய்ய நீங்கள் பல Async இட்டரேட்டர் ஹெல்பர்களை ஒன்றாகச் சங்கிலியாக்கலாம்.
• தனிப்பயன் ஹெல்பர்கள்: மீண்டும் பயன்படுத்தக்கூடிய தர்க்கத்தை இணைக்க உங்கள் சொந்த தனிப்பயன் Async இட்டரேட்டர் ஹெல்பர்களை உருவாக்கலாம்.
• பேக்பிரஷர் கையாளுதல்: ஸ்ட்ரீமிங் பயன்பாடுகளில், நுகர்வோரை தரவுகளால் மூழ்கடிப்பதைத் தடுக்க பேக்பிரஷர் வழிமுறைகளைச் செயல்படுத்தவும்.

முடிவுரை

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

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

மகிழ்ச்சியான கோடிங், உங்கள் ஒத்திசைவற்ற ஸ்ட்ரீம்கள் எப்போதும் ஒத்திசைவில் இருக்கட்டும்!