જાવાસ્ક્રિપ્ટ અસિંક ઇટરેટર હેલ્પર: ફોર ઇચ - સ્ટ્રીમ પ્રોસેસિંગ ઇટરેશન

અસિંક્રોનસ પ્રોગ્રામિંગ આધુનિક જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટનો મુખ્ય આધાર છે, જે એપ્લિકેશન્સને મુખ્ય થ્રેડને બ્લોક કર્યા વિના સમય માંગી લેતી કામગીરીઓને હેન્ડલ કરવા સક્ષમ બનાવે છે. ECMAScript 2018 માં રજૂ કરાયેલા અસિંક ઇટરેટર્સ, ડેટા સ્ટ્રીમ્સને અસિંક્રોનસ રીતે પ્રોસેસ કરવા માટે એક શક્તિશાળી મિકેનિઝમ પ્રદાન કરે છે. આ બ્લોગ પોસ્ટ અસિંક ઇટરેટર્સની વિભાવનામાં ઊંડાણપૂર્વક ઉતરે છે અને સ્ટ્રીમ પ્રોસેસિંગને સુવ્યવસ્થિત કરવા માટે અસિંક્રોનસ 'ફોર ઇચ' હેલ્પર ફંક્શન કેવી રીતે અમલમાં મૂકવું તે દર્શાવે છે.

અસિંક ઇટરેટર્સને સમજવું

એક અસિંક ઇટરેટર એ એક ઑબ્જેક્ટ છે જે AsyncIterator ઇન્ટરફેસનું પાલન કરે છે. તે એક next() મેથડ વ્યાખ્યાયિત કરે છે જે એક પ્રોમિસ પરત કરે છે, જે બે પ્રોપર્ટીઝવાળા ઑબ્જેક્ટમાં રિઝોલ્વ થાય છે:

• value: ક્રમમાં આગલી કિંમત.
• done: એક બુલિયન જે સૂચવે છે કે ઇટરેટર પૂર્ણ થયું છે કે નહીં.

અસિંક ઇટરેટર્સનો ઉપયોગ સામાન્ય રીતે નેટવર્ક સ્ટ્રીમ્સ, ફાઇલ સિસ્ટમ્સ અથવા ડેટાબેસેસ જેવા અસિંક્રોનસ સ્રોતોમાંથી ડેટા મેળવવા માટે થાય છે. for await...of લૂપ અસિંક ઇટરેબલ્સ પર ઇટરેટ કરવા માટે એક અનુકૂળ સિન્ટેક્સ પ્રદાન કરે છે.

ઉદાહરણ: ફાઇલમાંથી અસિંક્રોનસ રીતે વાંચન

એક એવા દૃશ્યનો વિચાર કરો જ્યાં તમારે મુખ્ય થ્રેડને બ્લોક કર્યા વિના લાઇન બાય લાઇન મોટી ફાઇલ વાંચવાની જરૂર છે. તમે અસિંક ઇટરેટરનો ઉપયોગ કરીને આ પ્રાપ્ત કરી શકો છો:

            
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(`Line: ${line}`);
  }
}

// Example usage
processFile('path/to/your/file.txt');

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, readFileLines એ એક અસિંક જનરેટર ફંક્શન છે જે ફાઇલની દરેક લાઇનને તે વાંચતાની સાથે જ યીલ્ડ કરે છે. processFile ફંક્શન પછી for await...of નો ઉપયોગ કરીને લાઇન્સ પર ઇટરેટ કરે છે, દરેક લાઇનને અસિંક્રોનસ રીતે પ્રોસેસ કરે છે.

અસિંક 'ફોર ઇચ' હેલ્પરનો અમલ કરવો

જ્યારે for await...of લૂપ ઉપયોગી છે, ત્યારે તે વર્બોઝ બની શકે છે જ્યારે તમારે સ્ટ્રીમમાં દરેક એલિમેન્ટ પર જટિલ કામગીરી કરવાની જરૂર હોય. એક અસિંક 'ફોર ઇચ' હેલ્પર ફંક્શન ઇટરેશન લોજિકને એન્કેપ્સ્યુલેટ કરીને આ પ્રક્રિયાને સરળ બનાવી શકે છે.

મૂળભૂત અમલીકરણ

અહીં અસિંક 'ફોર ઇચ' ફંક્શનનું મૂળભૂત અમલીકરણ છે:

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

            

              
                Copy
              
            
          

આ ફંક્શન એક અસિંક ઇટરેબલ અને એક કોલબેક ફંક્શનને આર્ગ્યુમેન્ટ્સ તરીકે લે છે. તે for await...of નો ઉપયોગ કરીને ઇટરેબલ પર ઇટરેટ કરે છે અને દરેક આઇટમ માટે કોલબેક ફંક્શનને કોલ કરે છે. જો તમે આગલી આઇટમ પર જતા પહેલા તેની પૂર્ણતાની રાહ જોવા માંગતા હોવ તો કોલબેક ફંક્શન પણ અસિંક્રોનસ હોવું જોઈએ.

ઉદાહરણ: API માંથી ડેટા પ્રોસેસિંગ

ધારો કે તમે એક API માંથી ડેટા મેળવી રહ્યા છો જે આઇટમ્સની સ્ટ્રીમ પરત કરે છે. તમે દરેક આઇટમ આવતાની સાથે જ તેને પ્રોસેસ કરવા માટે અસિંક 'ફોર ઇચ' હેલ્પરનો ઉપયોગ કરી શકો છો:

            
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;
      }

      // Assuming the API returns JSON chunks
      const chunk = decoder.decode(value);
      const items = JSON.parse(`[${chunk.replace(/\}\{/g, '},{')}]`); //Split chunks into valid json array

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

async function processItem(item) {
  // Simulate an asynchronous operation
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log(`Processing item: ${JSON.stringify(item)}`);
}

async function main() {
  const apiUrl = 'https://api.example.com/data'; // Replace with your API endpoint
  await asyncForEach(fetchDataStream(apiUrl), processItem);
  console.log('Finished processing data.');
}

// Example usage
main();

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, fetchDataStream API માંથી ડેટા મેળવે છે અને દરેક આઇટમ પ્રાપ્ત થતાં જ તેને યીલ્ડ કરે છે. processItem ફંક્શન દરેક આઇટમ પર એક અસિંક્રોનસ ઓપરેશનનું અનુકરણ કરે છે. asyncForEach હેલ્પર પછી ઇટરેશન અને પ્રોસેસિંગ લોજિકને સરળ બનાવે છે.

સુધારાઓ અને વિચારણાઓ

એરર હેન્ડલિંગ

અસિંક્રોનસ ઇટરેશન દરમિયાન થઈ શકે તેવી એરર્સને હેન્ડલ કરવી મહત્વપૂર્ણ છે. તમે એક્સેપ્શન્સને કેચ કરવા અને હેન્ડલ કરવા માટે કોલબેક ફંક્શનને try...catch બ્લોકમાં રેપ કરી શકો છો:

            
async function asyncForEach(iterable, callback) {
  for await (const item of iterable) {
    try {
      await callback(item);
    } catch (error) {
      console.error(`Error processing item: ${item}`, error);
      // You can choose to re-throw the error or continue processing
    }
  }
}

            

              
                Copy
              
            
          

કોન્કરન્સી કંટ્રોલ

ડિફૉલ્ટ રૂપે, અસિંક 'ફોર ઇચ' હેલ્પર આઇટમ્સને ક્રમિક રીતે પ્રોસેસ કરે છે. જો તમારે આઇટમ્સને કોન્કરન્ટલી પ્રોસેસ કરવાની જરૂર હોય, તો તમે કોન્કરન્ટ ઓપરેશન્સની સંખ્યાને મર્યાદિત કરવા માટે પ્રોમિસ પૂલનો ઉપયોગ કરી શકો છો:

            
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) {
  // Simulate an asynchronous operation
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log(`Processing item: ${JSON.stringify(item)}`);
}

async function main() {
  const apiUrl = 'https://api.example.com/data'; // Replace with your API endpoint
  await asyncForEachConcurrent(fetchDataStream(apiUrl), processItem, 5); // Concurrency of 5
  console.log('Finished processing data.');
}

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, asyncForEachConcurrent કોન્કરન્ટ કોલબેક એક્ઝિક્યુશન્સની સંખ્યાને સ્પષ્ટ કરેલ કોન્કરન્સી લેવલ સુધી મર્યાદિત કરે છે. આ મોટા ડેટા સ્ટ્રીમ્સ સાથે કામ કરતી વખતે પ્રદર્શનને સુધારી શકે છે.

રદ્દીકરણ (કેન્સલેશન)

કેટલાક કિસ્સાઓમાં, તમારે ઇટરેશન પ્રક્રિયાને સમય પહેલાં રદ કરવાની જરૂર પડી શકે છે. તમે AbortController નો ઉપયોગ કરીને આ પ્રાપ્ત કરી શકો છો:

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

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

  setTimeout(() => {
    controller.abort(); // Abort after 2 seconds
  }, 2000);

  const apiUrl = 'https://api.example.com/data'; // Replace with your API endpoint
  await asyncForEach(fetchDataStream(apiUrl), processItem, signal);
  console.log('Finished processing data.');
}

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, asyncForEach ફંક્શન દરેક ઇટરેશન પહેલાં signal.aborted પ્રોપર્ટીને તપાસે છે. જો સિગ્નલ એબોર્ટ કરવામાં આવે, તો ઇટરેશન બંધ થઈ જાય છે.

વાસ્તવિક-દુનિયાની એપ્લિકેશન્સ

અસિંક ઇટરેટર્સ અને અસિંક 'ફોર ઇચ' હેલ્પરને વાસ્તવિક-દુનિયાના દૃશ્યોની વિશાળ શ્રેણીમાં લાગુ કરી શકાય છે:

• ડેટા પ્રોસેસિંગ પાઇપલાઇન્સ: ડેટાબેસેસ અથવા ફાઇલ સિસ્ટમ્સમાંથી મોટા ડેટાસેટ્સ પર પ્રક્રિયા કરવી.
• રિયલ-ટાઇમ ડેટા સ્ટ્રીમ્સ: વેબ સોકેટ્સ, મેસેજ ક્યુઝ, અથવા સેન્સર નેટવર્ક્સમાંથી ડેટાને હેન્ડલ કરવું.
• API કન્ઝમ્પશન: આઇટમ્સની સ્ટ્રીમ્સ પરત કરતી APIs માંથી ડેટા મેળવવો અને પ્રોસેસ કરવો.
• ઇમેજ અને વિડિયો પ્રોસેસિંગ: મોટી મીડિયા ફાઇલોને ચંક્સમાં પ્રોસેસ કરવી.
• લોગ એનાલિસિસ: મોટી લોગ ફાઇલોનું લાઇન બાય લાઇન વિશ્લેષણ કરવું.

ઉદાહરણ - આંતરરાષ્ટ્રીય સ્ટોક ડેટા: એવી એપ્લિકેશનનો વિચાર કરો કે જે વિવિધ આંતરરાષ્ટ્રીય એક્સચેન્જોમાંથી રિયલ-ટાઇમ સ્ટોક ક્વોટ્સ મેળવે છે. ડેટાને સ્ટ્રીમ કરવા માટે એક અસિંક ઇટરેટરનો ઉપયોગ કરી શકાય છે, અને એક અસિંક 'ફોર ઇચ' દરેક ક્વોટને પ્રોસેસ કરી શકે છે, યુઝર ઇન્ટરફેસને નવીનતમ કિંમતો સાથે અપડેટ કરી શકે છે. આનો ઉપયોગ નીચેની જેવી કંપનીઓના વર્તમાન સ્ટોક રેટ્સ પ્રદર્શિત કરવા માટે કરી શકાય છે:

• ટેન્સેન્ટ (ચીન): એક મુખ્ય આંતરરાષ્ટ્રીય ટેકનોલોજી કંપનીના સ્ટોક ડેટા મેળવવા
• ટાટા કન્સલ્ટન્સી સર્વિસિસ (ભારત): એક અગ્રણી IT સેવા કંપનીના સ્ટોક અપડેટ્સ પ્રદર્શિત કરવા
• સેમસંગ ઇલેક્ટ્રોનિક્સ (દક્ષિણ કોરિયા): એક વૈશ્વિક ઇલેક્ટ્રોનિક્સ ઉત્પાદકના સ્ટોક રેટ્સ દર્શાવવા
• ટોયોટા મોટર કોર્પોરેશન (જાપાન): એક આંતરરાષ્ટ્રીય ઓટો ઉત્પાદકના સ્ટોક ભાવોનું નિરીક્ષણ કરવું

નિષ્કર્ષ

અસિંક ઇટરેટર્સ અને અસિંક 'ફોર ઇચ' હેલ્પર જાવાસ્ક્રિપ્ટમાં ડેટા સ્ટ્રીમ્સને અસિંક્રોનસ રીતે પ્રોસેસ કરવાની શક્તિશાળી અને સુઘડ રીત પ્રદાન કરે છે. ઇટરેશન લોજિકને એન્કેપ્સ્યુલેટ કરીને, તમે તમારા કોડને સરળ બનાવી શકો છો, વાંચનક્ષમતા સુધારી શકો છો, અને તમારી એપ્લિકેશન્સના પ્રદર્શનને વધારી શકો છો. એરર્સને હેન્ડલ કરીને, કોન્કરન્સીને નિયંત્રિત કરીને, અને કેન્સલેશનને સક્ષમ કરીને, તમે મજબૂત અને સ્કેલેબલ અસિંક્રોનસ ડેટા પ્રોસેસિંગ પાઇપલાઇન્સ બનાવી શકો છો.

વધુ શીખવા માટે

• MDN વેબ ડૉક્સ: for await...of
• MDN વેબ ડૉક્સ: async function*
• ECMAScript સ્પષ્ટીકરણ: AsyncIterator ઇન્ટરફેસ