ஜாவாஸ்கிரிப்ட் இட்டரேட்டர் ஹெல்பர் பேட்சிங் உத்தி: திறமையான பேட்ச் செயலாக்கம்

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

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

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

இட்டரேட்டர்கள்

ஒரு இட்டரேட்டர் என்பது ஒரு வரிசையை வரையறுக்கும் ஒரு பொருள் மற்றும் அதன் முடிவில் ஒரு ரிட்டர்ன் மதிப்பைத் தரக்கூடியது. குறிப்பாக, இது `next()` முறையுடன் `Iterator` புரோட்டோகாலை செயல்படுத்தும் ஒரு பொருள். `next()` முறை இரண்டு பண்புகளுடன் ஒரு பொருளைத் தருகிறது:

• value: வரிசையில் அடுத்த மதிப்பு.
• done: இட்டரேட்டர் வரிசையின் முடிவை எட்டியதா என்பதைக் குறிக்கும் ஒரு பூலியன்.

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

உதாரணம் (அரே இட்டரேட்டர்):

            
const myArray = [1, 2, 3, 4, 5];
const iterator = myArray[Symbol.iterator]();

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
// ...
console.log(iterator.next()); // { value: undefined, done: true }

            

              
                Copy
              
            
          

இட்டரேட்டர் ஹெல்பர்கள்

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

பொதுவான இட்டரேட்டர் ஹெல்பர்கள்:

• map(): இட்டரபிலில் உள்ள ஒவ்வொரு உறுப்பையும் மாற்றுகிறது.
• filter(): ஒரு குறிப்பிட்ட நிபந்தனையை பூர்த்தி செய்யும் உறுப்புகளைத் தேர்ந்தெடுக்கிறது.
• reduce(): மதிப்புகளை ஒரே முடிவில் குவிக்கிறது.
• forEach(): ஒவ்வொரு இட்டரபில் உறுப்பிற்கும் ஒரு முறை வழங்கப்பட்ட செயல்பாட்டை செயல்படுத்துகிறது.
• some(): வழங்கப்பட்ட செயல்பாட்டால் செயல்படுத்தப்பட்ட சோதனையில் இட்டரபிலில் உள்ள குறைந்தபட்சம் ஒரு உறுப்பு தேர்ச்சி பெறுகிறதா என்பதை சோதிக்கிறது.
• every(): வழங்கப்பட்ட செயல்பாட்டால் செயல்படுத்தப்பட்ட சோதனையில் இட்டரபிலில் உள்ள அனைத்து உறுப்புகளும் தேர்ச்சி பெறுகின்றனவா என்பதை சோதிக்கிறது.

உதாரணம் (map மற்றும் filter பயன்படுத்துதல்):

            
const numbers = [1, 2, 3, 4, 5, 6];

const evenNumbers = numbers.filter(num => num % 2 === 0);
const squaredEvenNumbers = evenNumbers.map(num => num * num);

console.log(squaredEvenNumbers); // Output: [ 4, 16, 36 ]

            

              
                Copy
              
            
          

பேட்சிங்கின் தேவை

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

பேட்சிங் ஏன் முக்கியமானது என்பது இங்கே:

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

உதாரண சூழ்நிலை:

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

இட்டரேட்டர் ஹெல்பர் பேட்சிங்கை செயல்படுத்துதல்

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

கைமுறை பேட்சிங் செயலாக்கம்

நீங்கள் ஒரு ஜெனரேட்டர் செயல்பாட்டைப் பயன்படுத்தி பேட்சிங்கை கைமுறையாக செயல்படுத்தலாம்.

            
function* batchIterator(iterable, batchSize) {
  let batch = [];
  for (const item of iterable) {
    batch.push(item);
    if (batch.length === batchSize) {
      yield batch;
      batch = [];
    }
  }
  if (batch.length > 0) {
    yield batch;
  }
}

// Example usage:
const data = Array.from({ length: 1000 }, (_, i) => i + 1);
const batchSize = 100;

for (const batch of batchIterator(data, batchSize)) {
  // Process each batch
  const processedBatch = batch.map(item => item * 2);
  console.log(processedBatch);
}

            

              
                Copy
              
            
          

விளக்கம்:

1. batchIterator செயல்பாடு ஒரு இட்டரபில் மற்றும் ஒரு பேட்ச் அளவை உள்ளீடாக எடுத்துக்கொள்கிறது.
2. இது இட்டரபில் வழியாக மீண்டும் மீண்டும் சென்று, உருப்படிகளை ஒரு batch அரேயில் சேர்க்கிறது.
3. batch குறிப்பிட்ட batchSize-ஐ அடையும் போது, அது batch-ஐ yield செய்கிறது.
4. மீதமுள்ள எந்த உருப்படிகளும் இறுதி batch-ல் yield செய்யப்படுகின்றன.

லைப்ரரிகளைப் பயன்படுத்துதல்

பல ஜாவாஸ்கிரிப்ட் லைப்ரரிகள் இட்டரேட்டர்களுடன் பணிபுரிவதற்கும் பேட்சிங்கை செயல்படுத்துவதற்கும் பயன்பாடுகளை வழங்குகின்றன. ஒரு பிரபலமான விருப்பம் லோடாஷ் ஆகும்.

உதாரணம் (லோடாஷின் chunk பயன்படுத்துதல்):

            
const _ = require('lodash'); // or import _ from 'lodash';

const data = Array.from({ length: 1000 }, (_, i) => i + 1);
const batchSize = 100;

const batches = _.chunk(data, batchSize);

batches.forEach(batch => {
  // Process each batch
  const processedBatch = batch.map(item => item * 2);
  console.log(processedBatch);
});

            

              
                Copy
              
            
          

லோடாஷின் _.chunk செயல்பாடு ஒரு அரேயை பேட்ச்களாக பிரிக்கும் செயல்முறையை எளிதாக்குகிறது.

ஒத்திசைவற்ற பேட்ச் செயலாக்கம்

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

உதாரணம் (async/await உடன் ஒத்திசைவற்ற பேட்ச் செயலாக்கம்):

            
async function processBatch(batch) {
  // Simulate an asynchronous operation (e.g., fetching data from an API)
  await new Promise(resolve => setTimeout(resolve, 500)); // Simulate network latency
  return batch.map(item => item * 3); // Example processing
}

async function processDataInBatches(data, batchSize) {
  for (const batch of batchIterator(data, batchSize)) {
    const processedBatch = await processBatch(batch);
    console.log("Processed batch:", processedBatch);
  }
}

const data = Array.from({ length: 500 }, (_, i) => i + 1);
const batchSize = 50;

processDataInBatches(data, batchSize);

            

              
                Copy
              
            
          

விளக்கம்:

1. processBatch செயல்பாடு setTimeout ஐப் பயன்படுத்தி ஒரு ஒத்திசைவற்ற செயல்பாட்டை உருவகப்படுத்துகிறது மற்றும் ஒரு Promise-ஐத் தருகிறது.
2. processDataInBatches செயல்பாடு பேட்ச்கள் வழியாகச் சென்று, ஒவ்வொரு processBatch-ம் முடிவடையும் வரை காத்திருக்க await ஐப் பயன்படுத்துகிறது, பின்னர் அடுத்ததற்குச் செல்கிறது.

இணையான ஒத்திசைவற்ற பேட்ச் செயலாக்கம்

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

            
async function processDataInBatchesConcurrently(data, batchSize) {
  const batches = [...batchIterator(data, batchSize)]; // Convert iterator to array
  
  // Process batches concurrently using Promise.all
  const processedResults = await Promise.all(
    batches.map(async batch => {
      return await processBatch(batch);
    })
  );

  console.log("All batches processed:", processedResults);
}

const data = Array.from({ length: 500 }, (_, i) => i + 1);
const batchSize = 50;

processDataInBatchesConcurrently(data, batchSize);

            

              
                Copy
              
            
          

இணையான செயலாக்கத்திற்கான முக்கிய கருத்தாய்வுகள்:

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

சரியான பேட்ச் அளவைத் தேர்ந்தெடுத்தல்

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

• தரவு அளவு: ஒவ்வொரு தனிப்பட்ட தரவு உருப்படியின் அளவு.
• செயலாக்க சிக்கல்: ஒவ்வொரு உருப்படியிலும் செய்யப்படும் செயல்பாடுகளின் சிக்கலான தன்மை.
• கணினி வளங்கள்: கிடைக்கும் நினைவகம், CPU மற்றும் நெட்வொர்க் அலைவரிசை.
• ஒத்திசைவற்ற செயல்பாட்டு தாமதம்: ஒவ்வொரு பேட்சையும் செயலாக்குவதில் ஈடுபட்டுள்ள எந்தவொரு ஒத்திசைவற்ற செயல்பாடுகளின் தாமதம்.

பொது வழிகாட்டுதல்கள்:

• ஒரு மிதமான பேட்ச் அளவுடன் தொடங்குங்கள்: ஒரு பேட்சிற்கு 100 முதல் 1000 உருப்படிகள் வரை ஒரு நல்ல தொடக்கப் புள்ளியாகும்.
• சோதனை செய்து அளவிடுங்கள்: வெவ்வேறு பேட்ச் அளவுகளைச் சோதித்து, உங்கள் குறிப்பிட்ட சூழ்நிலைக்கான உகந்த மதிப்பைக் கண்டறிய செயல்திறனை அளவிடவும்.
• வளப் பயன்பாட்டைக் கண்காணிக்கவும்: நினைவக நுகர்வு, CPU பயன்பாடு மற்றும் நெட்வொர்க் செயல்பாட்டைக் கண்காணித்து சாத்தியமான தடைகளைக் கண்டறியவும்.
• தகவமைப்பு பேட்சிங்கைக் கவனியுங்கள்: கணினி சுமை மற்றும் செயல்திறன் அளவீடுகளின் அடிப்படையில் பேட்ச் அளவை மாறும் வகையில் சரிசெய்யவும்.

நிஜ உலக உதாரணங்கள்

தரவு இடமாற்றம்

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

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

லாக் செயலாக்கம்

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

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

பட செயலாக்கம்

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

உதாரணம்: ஒரு இ-காமர்ஸ் தளம் அனைத்து தயாரிப்பு படங்களுக்கும் சிறுபடங்களை உருவாக்க வேண்டும். பேட்சிங், பயனர் அனுபவத்தைப் பாதிக்காமல், பின்னணியில் படங்களைச் செயலாக்க தளத்தை அனுமதிக்கிறது.

இட்டரேட்டர் ஹெல்பர் பேட்சிங்கின் நன்மைகள்

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

முடிவுரை

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

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

மேலும் படிக்க

• இட்டரேட்டர்கள் மற்றும் ஜெனரேட்டர்கள் - MDN வலை ஆவணங்கள்
• லோடாஷ் _.chunk
• Promise.all() - MDN வலை ஆவணங்கள்