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

આધુનિક જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટમાં અસિંક્રોનસ પ્રોગ્રામિંગ એક આધારસ્તંભ છે, ખાસ કરીને જ્યારે API માંથી ડેટા મેળવવો, ફાઇલો વાંચવી અથવા ડેટાબેઝ સાથે ક્રિયાપ્રતિક્રિયા કરવી જેવી I/O કામગીરી સાથે કામ કરવું હોય. પરંપરાગત રીતે, અમે આ અસિંક્રોનસ કાર્યોને સંચાલિત કરવા માટે પ્રોમિસિસ અને એસિંક/એવેઇટ પર આધાર રાખ્યો છે. જો કે, અસિંક જનરેટર ફંક્શન્સ અસિંક્રોનસ ઇટરેશનને હેન્ડલ કરવાની એક શક્તિશાળી અને ભવ્ય રીત પ્રદાન કરે છે, જે અમને અસિંક્રોનસ અને કાર્યક્ષમ રીતે ડેટાના સ્ટ્રીમ્સને પ્રોસેસ કરવા સક્ષમ બનાવે છે.

અસિંક્રોનસ ઇટરેશન પ્રોટોકોલ્સને સમજવું

અસિંક જનરેટર ફંક્શન્સમાં ડાઇવ કરતા પહેલા, જે અસિંક્રોનસ ઇટરેશન પ્રોટોકોલ્સ પર તેઓ બનેલ છે તે સમજવું જરૂરી છે. આ પ્રોટોકોલ્સ વ્યાખ્યાયિત કરે છે કે કેવી રીતે અસિંક્રોનસ ડેટા સોર્સને નિયંત્રિત અને અનુમાનિત રીતે ઇટરેટ કરી શકાય છે.

અસિંક્રોનસ ઇટરેબલ પ્રોટોકોલ

અસિંક્રોનસ ઇટરેબલ પ્રોટોકોલ એક ઑબ્જેક્ટ વ્યાખ્યાયિત કરે છે જેને અસિંક્રોનસ રીતે ઇટરેટ કરી શકાય છે. જો કોઈ ઑબ્જેક્ટમાં Symbol.asyncIterator દ્વારા કી કરેલી મેથડ હોય જે અસિંક્રોનસ ઇટરેટર પરત કરે તો તે આ પ્રોટોકોલનું પાલન કરે છે.

ગીતોની પ્લેલિસ્ટની જેમ ઇટરેબલ વિચારો. અસિંક્રોનસ ઇટરેબલ એક પ્લેલિસ્ટ જેવું છે જ્યાં દરેક ગીત વગાડવામાં આવે તે પહેલાં લોડ કરવાની જરૂર છે (અસિંક્રોનસ રીતે).

ઉદાહરણ:

            const asyncIterable = {
  [Symbol.asyncIterator]() {
    return {
      next() {
        // Asynchronously fetch the next value
      }
    };
  }
};

            

              
                Copy
              
            
          

અસિંક્રોનસ ઇટરેટર પ્રોટોકોલ

અસિંક્રોનસ ઇટરેટર પ્રોટોકોલ એ મેથડ્સ વ્યાખ્યાયિત કરે છે જે અસિંક્રોનસ ઇટરેટરે અમલ કરવી આવશ્યક છે. આ પ્રોટોકોલનું પાલન કરતા ઑબ્જેક્ટમાં next() મેથડ હોવી આવશ્યક છે, અને વૈકલ્પિક રીતે return() અને throw() મેથડ હોવી જોઈએ.

• next(): આ મેથડ એક પ્રોમિસ પરત કરે છે જે બે પ્રોપર્ટીઝ સાથેના ઑબ્જેક્ટ પર રીઝોલ્વ થાય છે: value અને done. value માં સિક્વન્સમાં આગલું મૂલ્ય હોય છે, અને done એક બુલિયન છે જે સૂચવે છે કે ઇટરેશન પૂર્ણ થયું છે કે નહીં.
• return(): (વૈકલ્પિક) આ મેથડ એક પ્રોમિસ પરત કરે છે જે value અને done પ્રોપર્ટીઝ સાથેના ઑબ્જેક્ટ પર રીઝોલ્વ થાય છે. તે સંકેત આપે છે કે ઇટરેટર બંધ થઈ રહ્યું છે. આ સંસાધનોને મુક્ત કરવા માટે ઉપયોગી છે.
• throw(): (વૈકલ્પિક) આ મેથડ એક પ્રોમિસ પરત કરે છે જે ભૂલ સાથે રિજેક્ટ થાય છે. ઇટરેશન દરમિયાન ભૂલ આવી છે તે સંકેત આપવા માટે તેનો ઉપયોગ થાય છે.

ઉદાહરણ:

            const asyncIterator = {
  next() {
    return new Promise((resolve) => {
      // Asynchronously fetch the next value
      setTimeout(() => {
        resolve({ value: /* some value */, done: false });
      }, 100);
    });
  },
  return() {
    return Promise.resolve({ value: undefined, done: true });
  },
  throw(error) {
    return Promise.reject(error);
  }
};

            

              
                Copy
              
            
          

અસિંક જનરેટર ફંક્શન્સનો પરિચય

અસિંક જનરેટર ફંક્શન્સ અસિંક્રોનસ ઇટરેટર્સ અને ઇટરેબલ્સ બનાવવા માટે વધુ અનુકૂળ અને વાંચી શકાય તેવી રીત પ્રદાન કરે છે. તેઓ પ્રોમિસિસની અસિંક્રોનિસિટી સાથે જનરેટરની શક્તિને જોડે છે.

સિંટેક્સ

અસિંક જનરેટર ફંક્શનની ઘોષણા async function* સિંટેક્સનો ઉપયોગ કરીને કરવામાં આવે છે:

            async function* myAsyncGenerator() {
  // Asynchronous operations and yield statements here
}

            

              
                Copy
              
            
          

yield કીવર્ડ

અસિંક જનરેટર ફંક્શનની અંદર, yield કીવર્ડનો ઉપયોગ અસિંક્રોનસ રીતે મૂલ્યો ઉત્પન્ન કરવા માટે થાય છે. દરેક yield સ્ટેટમેન્ટ અસરકારક રીતે જનરેટર ફંક્શનના એક્ઝિક્યુશનને ત્યાં સુધી થોભાવે છે જ્યાં સુધી યીલ્ડેડ પ્રોમિસ રીઝોલ્વ ન થાય.

ઉદાહરણ:

            async function* fetchUsers() {
  const user1 = await fetch('https://example.com/api/users/1').then(res => res.json());
  yield user1;

  const user2 = await fetch('https://example.com/api/users/2').then(res => res.json());
  yield user2;

  const user3 = await fetch('https://example.com/api/users/3').then(res => res.json());
  yield user3;
}

            

              
                Copy
              
            
          

for await...of સાથે અસિંક જનરેટર્સનો ઉપયોગ કરવો

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

ઉદાહરણ:

            async function main() {
  for await (const user of fetchUsers()) {
    console.log(user);
  }
}

main();

            

              
                Copy
              
            
          

અસિંક જનરેટર ફંક્શન્સ માટે વ્યવહારુ ઉપયોગના કિસ્સાઓ

અસિંક જનરેટર ફંક્શન્સ અસિંક્રોનસ ડેટા સ્ટ્રીમ્સને લગતા સંજોગોમાં શ્રેષ્ઠ છે, જેમ કે:

1. API માંથી સ્ટ્રીમિંગ ડેટા

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

ઉદાહરણ (પેજિનેટેડ ડેટા મેળવવો):

            async function* fetchPaginatedData(url, pageSize = 10) {
  let page = 1;

  while (true) {
    const response = await fetch(`${url}?page=${page}&pageSize=${pageSize}`);
    const data = await response.json();

    if (data.length === 0) {
      return; // No more data
    }

    for (const item of data) {
      yield item;
    }

    page++;
  }
}

async function main() {
  for await (const item of fetchPaginatedData('https://api.example.com/data')) {
    console.log(item);
  }
}

main();

            

              
                Copy
              
            
          

આંતરરાષ્ટ્રીય ઉદાહરણ (ચલણ વિનિમય દર API):

            async function* fetchExchangeRates(currencyPair, startDate, endDate) {
  let currentDate = new Date(startDate);

  while (currentDate <= new Date(endDate)) {
    const dateString = currentDate.toISOString().split('T')[0]; // YYYY-MM-DD
    const url = `https://api.exchangerate.host/${dateString}?base=${currencyPair.substring(0,3)}&symbols=${currencyPair.substring(3,6)}`;
    try {
      const response = await fetch(url);
      const data = await response.json();

      if (data.success) {
        yield {
          date: dateString,
          rate: data.rates[currencyPair.substring(3,6)],
        };
      }

    } catch (error) {
      console.error(`Error fetching data for ${dateString}:`, error);
      // You might want to handle errors differently, e.g., retry or skip the date.
    }

    currentDate.setDate(currentDate.getDate() + 1);
  }
}

async function main() {
  const currencyPair = 'EURUSD';
  const startDate = '2023-01-01';
  const endDate = '2023-01-10';

  for await (const rate of fetchExchangeRates(currencyPair, startDate, endDate)) {
    console.log(rate);
  }
}

main();

            

              
                Copy
              
            
          

આ ઉદાહરણ આપેલ તારીખ શ્રેણી માટે દૈનિક EUR થી USD વિનિમય દરો મેળવે છે. તે API કોલ્સ દરમિયાન સંભવિત ભૂલોને હેન્ડલ કરે છે. `https://api.exchangerate.host` ને વિશ્વસનીય અને યોગ્ય API એન્ડપોઇન્ટ સાથે બદલવાનું યાદ રાખો.

2. મોટી ફાઇલો પ્રોસેસ કરવી

મોટી ફાઇલો સાથે કામ કરતી વખતે, સમગ્ર ફાઇલને મેમરીમાં વાંચવી બિનકાર્યક્ષમ હોઈ શકે છે. અસિંક જનરેટર ફંક્શન્સ તમને ફાઇલને લાઇન દ્વારા લાઇન અથવા ચંકમાં વાંચવાની મંજૂરી આપે છે, દરેક ચંકને અસિંક્રોનસ રીતે પ્રોસેસ કરે છે.

ઉદાહરણ (એક મોટી ફાઇલને લાઇન દ્વારા લાઇન વાંચવી - Node.js):

            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 main() {
  for await (const line of readLines('large_file.txt')) {
    // Process each line asynchronously
    console.log(line);
  }
}

main();

            

              
                Copy
              
            
          

આ Node.js ઉદાહરણ fs.createReadStream અને readline.createInterface નો ઉપયોગ કરીને ફાઇલને લાઇન દ્વારા લાઇન વાંચવાનું દર્શાવે છે. readLines અસિંક જનરેટર ફંક્શન દરેક લાઇનને અસિંક્રોનસ રીતે યીલ્ડ કરે છે.

3. રીઅલ-ટાઇમ ડેટા સ્ટ્રીમ્સને હેન્ડલ કરવું (વેબસૉકેટ્સ, સર્વર-સેન્ટ ઇવેન્ટ્સ)

અસિંક જનરેટર ફંક્શન્સ વેબસોકેટ્સ અથવા સર્વર-સેન્ટ ઇવેન્ટ્સ (SSE) જેવા સોર્સમાંથી રીઅલ-ટાઇમ ડેટા સ્ટ્રીમ્સને પ્રોસેસ કરવા માટે યોગ્ય છે. સ્ટ્રીમમાંથી ડેટા આવે તેમ તમે સતત ડેટા યીલ્ડ કરી શકો છો.

ઉદાહરણ (વેબસૉકેટમાંથી ડેટા પ્રોસેસ કરવો - સંકલ્પનાત્મક):

            // This is a conceptual example and requires a WebSocket library like 'ws' (Node.js) or the browser's built-in WebSocket API.

async function* processWebSocketStream(url) {
  const websocket = new WebSocket(url);

  websocket.onmessage = (event) => {
    //This needs to be handled outside the generator.
    //Typically, you'd push the event.data into a queue
    //and the generator would asynchronously pull from the queue
    //via a Promise that resolves when data is available.
  };
  websocket.onerror = (error) => {
     //Handle errors.
  };
  websocket.onclose = () => {
    //Handle close.
  }

  //The actual yielding and queue management would happen here,
  //making use of Promises to synchronize between the websocket.onmessage
  //event and the async generator function.
  //This is a simplified illustration.

  //while(true){ //Use this if properly queuing events.
  //  const data = await new Promise((resolve) => {
  //   // Resolve the promise when data is available in the queue.
  //  })
  //  yield data
  //}

}

async function main() {
  // for await (const message of processWebSocketStream('wss://example.com/ws')) {
  //   console.log(message);
  // }
  console.log("WebSocket example - conceptual only. See comments in code for details.");
}

main();

            

              
                Copy
              
            
          

વેબસૉકેટ ઉદાહરણ વિશે મહત્વપૂર્ણ નોંધો:

• પૂરા પાડવામાં આવેલ વેબસૉકેટ ઉદાહરણ મુખ્યત્વે સંકલ્પનાત્મક છે કારણ કે વેબસૉકેટની ઇવેન્ટ-સંચાલિત પ્રકૃતિને સીધા જ અસિંક જનરેટર સાથે સંકલિત કરવા માટે પ્રોમિસિસ અને કતારોનો ઉપયોગ કરીને કાળજીપૂર્વક સિંક્રોનાઇઝેશનની જરૂર છે.
• વાસ્તવિક દુનિયાના અમલીકરણો સામાન્ય રીતે આવનારા વેબસૉકેટ સંદેશાઓને કતારમાં બફર કરે છે અને જ્યારે નવો ડેટા ઉપલબ્ધ હોય ત્યારે અસિંક જનરેટરને સંકેત આપવા માટે પ્રોમિસનો ઉપયોગ કરે છે. આ સુનિશ્ચિત કરે છે કે જનરેટર ડેટાની રાહ જોતી વખતે બ્લોક ન કરે.

4. કસ્ટમ અસિંક્રોનસ ઇટરેટર્સનો અમલ કરવો

અસિંક જનરેટર ફંક્શન્સ કોઈપણ અસિંક્રોનસ ડેટા સોર્સ માટે કસ્ટમ અસિંક્રોનસ ઇટરેટર્સ બનાવવાનું સરળ બનાવે છે. તમે મૂલ્યો મેળવવા, પ્રોસેસ કરવા અને યીલ્ડ કરવા માટે તમારી પોતાની લોજિક વ્યાખ્યાયિત કરી શકો છો.

ઉદાહરણ (અસિંક્રોનસ રીતે સંખ્યાઓની સિક્વન્સ જનરેટ કરવી):

            async function* generateNumbers(start, end, delay) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, delay));
    yield i;
  }
}

async function main() {
  for await (const number of generateNumbers(1, 5, 500)) {
    console.log(number);
  }
}

main();

            

              
                Copy
              
            
          

આ ઉદાહરણ start થી end સુધી સંખ્યાઓની સિક્વન્સ જનરેટ કરે છે, જેમાં દરેક સંખ્યા વચ્ચે નિર્દિષ્ટ delay હોય છે. await new Promise(resolve => setTimeout(resolve, delay)) લાઇન અસિંક્રોનસ વિલંબ રજૂ કરે છે.

ભૂલ હેન્ડલિંગ

જ્યારે અસિંક જનરેટર ફંક્શન્સ સાથે કામ કરો ત્યારે ભૂલ હેન્ડલિંગ નિર્ણાયક છે. અસિંક્રોનસ કામગીરી દરમિયાન થતી ભૂલોને હેન્ડલ કરવા માટે તમે જનરેટર ફંક્શનની અંદર try...catch બ્લોક્સનો ઉપયોગ કરી શકો છો.

ઉદાહરણ (અસિંક જનરેટરમાં ભૂલ હેન્ડલિંગ):

            async function* fetchData(url) {
  try {
    const response = await fetch(url);
    const data = await response.json();
    yield data;
  } catch (error) {
    console.error('Error fetching data:', error);
    // You can choose to re-throw the error, yield a default value, or stop the iteration.
    // For example, yield { error: error.message };
    throw error;
  }
}

async function main() {
  try {
    for await (const data of fetchData('https://example.com/api/invalid')) {
      console.log(data);
    }
  } catch (error) {
    console.error('Error during iteration:', error);
  }
}

main();

            

              
                Copy
              
            
          

આ ઉદાહરણ દર્શાવે છે કે fetch કામગીરી દરમિયાન આવી શકે તેવી ભૂલોને કેવી રીતે હેન્ડલ કરવી. try...catch બ્લોક કોઈપણ ભૂલોને પકડે છે અને તેને કન્સોલમાં લૉગ કરે છે. તમે જનરેટરના ઉપભોક્તા દ્વારા પકડવા માટે ભૂલને ફરીથી ફેંકી પણ શકો છો, અથવા ભૂલ ઑબ્જેક્ટ યીલ્ડ કરી શકો છો.

અસિંક જનરેટર ફંક્શન્સનો ઉપયોગ કરવાના ફાયદા

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

અન્ય અસિંક્રોનસ અભિગમો સાથે સરખામણી

અસિંક જનરેટર્સ વિ. પ્રોમિસિસ

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

અસિંક જનરેટર્સ વિ. RxJS ઓબ્ઝર્વેબલ્સ

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

બ્રાઉઝર અને Node.js સુસંગતતા

અસિંક જનરેટર ફંક્શન્સ આધુનિક બ્રાઉઝર્સ અને Node.js માં વ્યાપકપણે સપોર્ટેડ છે. તેઓ તમામ મુખ્ય બ્રાઉઝર્સમાં ઉપલબ્ધ છે જે ES2018 (ECMAScript 2018) અને Node.js વર્ઝન 10 અને તેથી વધુને સપોર્ટ કરે છે.

જો તમારે જૂના વાતાવરણને સપોર્ટ કરવાની જરૂર હોય તો તમે જાવાસ્ક્રિપ્ટના જૂના વર્ઝનમાં તમારા કોડને ટ્રાન્સપાઈલ કરવા માટે Babel જેવા સાધનોનો ઉપયોગ કરી શકો છો.

નિષ્કર્ષ

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

વધુ શીખવું

• MDN વેબ ડોક્સ: AsyncGeneratorFunction
• ES2018નું અન્વેષણ કરવું: અસિંક્રોનસ ઇટરેશન
• Node.js દસ્તાવેજીકરણ: સ્ટ્રીમ્સ અને ફાઇલ સિસ્ટમ કામગીરી માટે સત્તાવાર Node.js દસ્તાવેજીકરણનો સંપર્ક કરો.