જાવાસ્ક્રિપ્ટ અસિંક જનરેટર હેલ્પર્સ: સ્ટ્રીમ નિર્માણ અને સંચાલનમાં નિપુણતા

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

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

અસિંક જનરેટર હેલ્પર્સમાં ડૂબકી મારતા પહેલાં, અસિંક જનરેટર્સ અને અસિંક ઇટરેટર્સની અંતર્ગત વિભાવનાઓને સમજવું મહત્વપૂર્ણ છે.

અસિંક જનરેટર્સ

અસિંક જનરેટર એક એવું ફંક્શન છે જેને થોભાવી શકાય છે અને ફરી શરૂ કરી શકાય છે, જે અસિંક્રોનસ રીતે વેલ્યુઝ (values) આપે છે. તે તમને મુખ્ય થ્રેડને બ્લોક કર્યા વિના સમય જતાં વેલ્યુઝનો ક્રમ જનરેટ કરવાની મંજૂરી આપે છે. અસિંક જનરેટર્સ async function* સિન્ટેક્સનો ઉપયોગ કરીને વ્યાખ્યાયિત કરવામાં આવે છે.

ઉદાહરણ:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // અસિંક્રોનસ ઓપરેશનનું અનુકરણ
    yield i;
  }
}

// ઉપયોગ
const sequence = generateSequence(1, 5);

અસિંક ઇટરેટર્સ

અસિંક ઇટરેટર એક ઓબ્જેક્ટ છે જે next() મેથડ પૂરી પાડે છે, જે એક પ્રોમિસ (promise) પરત કરે છે જે ક્રમમાં આગલી વેલ્યુ ધરાવતા ઓબ્જેક્ટમાં રિઝોલ્વ થાય છે અને done પ્રોપર્ટી જે દર્શાવે છે કે ક્રમ સમાપ્ત થયો છે કે નહીં. અસિંક ઇટરેટર્સ for await...of લૂપ્સનો ઉપયોગ કરીને ઉપયોગમાં લેવાય છે.

ઉદાહરણ:

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

async function consumeSequence() {
  const sequence = generateSequence(1, 5);
  for await (const value of sequence) {
    console.log(value);
  }
}

consumeSequence();

અસિંક જનરેટર હેલ્પર્સનો પરિચય

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

નીચેના અસિંક જનરેટર હેલ્પર્સ સામાન્ય રીતે ઉપલબ્ધ હોય છે (જાવાસ્ક્રિપ્ટ પર્યાવરણ અને પોલીફિલ્સના આધારે):

• map
• filter
• take
• drop
• flatMap
• reduce
• toArray
• forEach

અસિંક જનરેટર હેલ્પર્સનું વિગતવાર અન્વેષણ

૧. `map()`

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

સિન્ટેક્સ:

asyncGenerator.map(callback)

ઉદાહરણ: સંખ્યાઓના સ્ટ્રીમને તેમના વર્ગોમાં રૂપાંતરિત કરવું.

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

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const squares = numbers.map(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100)); // અસિંક ઓપરેશનનું અનુકરણ
    return num * num;
  });

  for await (const square of squares) {
    console.log(square);
  }
}

processNumbers();

વાસ્તવિક-દુનિયાનો ઉપયોગનો કેસ: કલ્પના કરો કે તમે બહુવિધ APIs માંથી વપરાશકર્તા ડેટા મેળવી રહ્યા છો અને ડેટાને સુસંગત ફોર્મેટમાં રૂપાંતરિત કરવાની જરૂર છે. map() નો ઉપયોગ દરેક વપરાશકર્તા ઓબ્જેક્ટ પર અસિંક્રોનસ રીતે રૂપાંતરણ ફંક્શન લાગુ કરવા માટે થઈ શકે છે.

async function* fetchUsersFromMultipleAPIs(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const response = await fetch(endpoint);
    const data = await response.json();
    for (const user of data) {
      yield user;
    }
  }
}

async function processUsers() {
  const apiEndpoints = [
    'https://api.example.com/users1',
    'https://api.example.com/users2'
  ];

  const users = fetchUsersFromMultipleAPIs(apiEndpoints);

  const normalizedUsers = users.map(async (user) => {
    // વપરાશકર્તા ડેટા ફોર્મેટને નોર્મલાઇઝ કરો
    return {
      id: user.userId || user.id,
      name: user.fullName || user.name,
      email: user.emailAddress || user.email
    };
  });

  for await (const normalizedUser of normalizedUsers) {
    console.log(normalizedUser);
  }
}

૨. `filter()`

filter() હેલ્પર એક નવું અસિંક જનરેટર બનાવે છે જે મૂળ સિક્વન્સમાંથી ફક્ત તે જ વેલ્યુઝ આપે છે જે પૂરી પાડવામાં આવેલ શરતને સંતોષે છે. તે તમને પરિણામી સ્ટ્રીમમાં પસંદગીપૂર્વક વેલ્યુઝ શામેલ કરવાની મંજૂરી આપે છે.

સિન્ટેક્સ:

asyncGenerator.filter(callback)

ઉદાહરણ: સંખ્યાઓના સ્ટ્રીમને ફિલ્ટર કરીને ફક્ત બેકી સંખ્યાઓનો સમાવેશ કરવો.

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

async function processNumbers() {
  const numbers = generateNumbers(1, 10);
  const evenNumbers = numbers.filter(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return num % 2 === 0;
  });

  for await (const evenNumber of evenNumbers) {
    console.log(evenNumber);
  }
}

processNumbers();

વાસ્તવિક-દુનિયાનો ઉપયોગનો કેસ: લોગ એન્ટ્રીઝના સ્ટ્રીમ પર પ્રક્રિયા કરવી અને તેમની ગંભીરતાના સ્તરના આધારે એન્ટ્રીઝને ફિલ્ટર કરવી. ઉદાહરણ તરીકે, ફક્ત ભૂલો અને ચેતવણીઓ પર પ્રક્રિયા કરવી.

async function* readLogFile(filePath) {
  // લોગ ફાઇલને લાઇન બાય લાઇન અસિંક્રોનસ રીતે વાંચવાનું અનુકરણ
  const logEntries = [
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' },
    { timestamp: '...', level: 'WARNING', message: '...' },
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' }
  ];

  for (const entry of logEntries) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield entry;
  }
}

async function processLogs() {
  const logEntries = readLogFile('path/to/log/file.log');
  const errorAndWarningLogs = logEntries.filter(async (entry) => {
    return entry.level === 'ERROR' || entry.level === 'WARNING';
  });

  for await (const log of errorAndWarningLogs) {
    console.log(log);
  }
}

૩. `take()`

take() હેલ્પર એક નવું અસિંક જનરેટર બનાવે છે જે મૂળ સિક્વન્સમાંથી ફક્ત પ્રથમ n વેલ્યુઝ આપે છે. તે સંભવિત અનંત અથવા ખૂબ મોટા સ્ટ્રીમમાંથી પ્રક્રિયા કરવામાં આવતી આઇટમ્સની સંખ્યાને મર્યાદિત કરવા માટે ઉપયોગી છે.

સિન્ટેક્સ:

asyncGenerator.take(n)

ઉદાહરણ: સંખ્યાઓના સ્ટ્રીમમાંથી પ્રથમ ૩ સંખ્યાઓ લેવી.

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);
  const firstThree = numbers.take(3);

  for await (const num of firstThree) {
    console.log(num);
  }
}

processNumbers();

વાસ્તવિક-દુનિયાનો ઉપયોગનો કેસ: અસિંક્રોનસ સર્ચ API માંથી ટોચના ૫ શોધ પરિણામો પ્રદર્શિત કરવા.

async function* search(query) {
  // API માંથી શોધ પરિણામો મેળવવાનું અનુકરણ
  const results = [
    { title: 'Result 1', url: '...' },
    { title: 'Result 2', url: '...' },
    { title: 'Result 3', url: '...' },
    { title: 'Result 4', url: '...' },
    { title: 'Result 5', url: '...' },
    { title: 'Result 6', url: '...' }
  ];

  for (const result of results) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield result;
  }
}

async function displayTopSearchResults(query) {
  const searchResults = search(query);
  const top5Results = searchResults.take(5);

  for await (const result of top5Results) {
    console.log(result);
  }
}

૪. `drop()`

drop() હેલ્પર એક નવું અસિંક જનરેટર બનાવે છે જે મૂળ સિક્વન્સમાંથી પ્રથમ n વેલ્યુઝને છોડી દે છે અને બાકીની વેલ્યુઝ આપે છે. તે take() ની વિરુદ્ધ છે અને સ્ટ્રીમના પ્રારંભિક ભાગોને અવગણવા માટે ઉપયોગી છે.

સિન્ટેક્સ:

asyncGenerator.drop(n)

ઉદાહરણ: સંખ્યાઓના સ્ટ્રીમમાંથી પ્રથમ ૨ સંખ્યાઓ છોડી દેવી.

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

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const remainingNumbers = numbers.drop(2);

  for await (const num of remainingNumbers) {
    console.log(num);
  }
}

processNumbers();

વાસ્તવિક-દુનિયાનો ઉપયોગનો કેસ: API માંથી મેળવેલા મોટા ડેટાસેટમાં પેજિનેટિંગ કરવું, જે પહેલેથી પ્રદર્શિત પરિણામોને છોડી દે છે.

async function* fetchData(url, pageSize, pageNumber) {
  const offset = (pageNumber - 1) * pageSize;
  // ઓફસેટ સાથે ડેટા મેળવવાનું અનુકરણ
  const data = [
    { id: 1, name: 'Item 1' },
    { id: 2, name: 'Item 2' },
    { id: 3, name: 'Item 3' },
    { id: 4, name: 'Item 4' },
    { id: 5, name: 'Item 5' },
    { id: 6, name: 'Item 6' },
    { id: 7, name: 'Item 7' },
    { id: 8, name: 'Item 8' }
  ];

  const pageData = data.slice(offset, offset + pageSize);

  for (const item of pageData) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield item;
  }
}

async function displayPage(pageNumber) {
  const pageSize = 3;
  const allData = fetchData('api/data', pageSize, pageNumber);
  const page = allData.drop((pageNumber - 1) * pageSize);  // પાછલા પેજના આઇટમ્સને છોડી દો

  const results = page.take(pageSize);


  for await (const item of results) {
    console.log(item);
  }
}

// ઉદાહરણ ઉપયોગ
displayPage(2);

૫. `flatMap()`

flatMap() હેલ્પર અસિંક્રોનસ સિક્વન્સમાં દરેક વેલ્યુને એક ફંક્શન લાગુ કરીને રૂપાંતરિત કરે છે જે એક અસિંક ઇટરેબલ (Async Iterable) પરત કરે છે. તે પછી પરિણામી અસિંક ઇટરેબલને એક જ અસિંક જનરેટરમાં ફ્લેટ કરે છે. આ દરેક વેલ્યુને વેલ્યુઝના સ્ટ્રીમમાં રૂપાંતરિત કરવા અને પછી તે સ્ટ્રીમ્સને જોડવા માટે ઉપયોગી છે.

સિન્ટેક્સ:

asyncGenerator.flatMap(callback)

ઉદાહરણ: વાક્યોના સ્ટ્રીમને શબ્દોના સ્ટ્રીમમાં રૂપાંતરિત કરવું.

async function* generateSentences() {
  const sentences = [
    'This is the first sentence.',
    'This is the second sentence.',
    'This is the third sentence.'
  ];

  for (const sentence of sentences) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield sentence;
  }
}

async function* stringToWords(sentence) {
    const words = sentence.split(' ');
    for (const word of words) {
        await new Promise(resolve => setTimeout(resolve, 50));
        yield word;
    }
}

async function processSentences() {
  const sentences = generateSentences();
  const words = sentences.flatMap(async (sentence) => {
      return stringToWords(sentence);
  });

  for await (const word of words) {
    console.log(word);
  }
}

processSentences();

વાસ્તવિક-દુનિયાનો ઉપયોગનો કેસ: બહુવિધ બ્લોગ પોસ્ટ્સ માટે ટિપ્પણીઓ મેળવવી અને તેમને પ્રક્રિયા માટે એક જ સ્ટ્રીમમાં જોડવી.

async function* fetchBlogPostIds() {
  const blogPostIds = [1, 2, 3]; // API માંથી બ્લોગ પોસ્ટ IDs મેળવવાનું અનુકરણ
  for (const id of blogPostIds) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield id;
  }
}

async function* fetchCommentsForPost(postId) {
  // API માંથી બ્લોગ પોસ્ટ માટે ટિપ્પણીઓ મેળવવાનું અનુકરણ
  const comments = [
    { postId: postId, text: `Comment 1 for post ${postId}` },
    { postId: postId, text: `Comment 2 for post ${postId}` }
  ];
  for (const comment of comments) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield comment;
  }
}

async function processComments() {
  const postIds = fetchBlogPostIds();
  const allComments = postIds.flatMap(async (postId) => {
    return fetchCommentsForPost(postId);
  });

  for await (const comment of allComments) {
    console.log(comment);
  }
}

૬. `reduce()`

reduce() હેલ્પર અસિંક જનરેટરના એક્યુમ્યુલેટર અને દરેક વેલ્યુ (ડાબેથી-જમણે) સામે એક ફંક્શન લાગુ કરે છે જેથી તેને એક જ વેલ્યુમાં ઘટાડી શકાય. આ અસિંક્રોનસ સ્ટ્રીમમાંથી ડેટાને એકત્રિત કરવા માટે ઉપયોગી છે.

સિન્ટેક્સ:

asyncGenerator.reduce(callback, initialValue)

ઉદાહરણ: સ્ટ્રીમમાં સંખ્યાઓનો સરવાળો ગણવો.

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

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const sum = await numbers.reduce(async (accumulator, num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return accumulator + num;
  }, 0);

  console.log('Sum:', sum);
}

processNumbers();

વાસ્તવિક-દુનિયાનો ઉપયોગનો કેસ: API કોલ્સની શ્રેણીના સરેરાશ પ્રતિભાવ સમયની ગણતરી કરવી.

async function* fetchResponseTimes(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const startTime = Date.now();
    try {
      await fetch(endpoint);
      const endTime = Date.now();
      const responseTime = endTime - startTime;
      await new Promise(resolve => setTimeout(resolve, 50));
      yield responseTime;
    } catch (error) {
      console.error(`Error fetching ${endpoint}: ${error}`);
      yield 0; // અથવા ભૂલને યોગ્ય રીતે હેન્ડલ કરો
    }
  }
}

async function calculateAverageResponseTime() {
  const apiEndpoints = [
    'https://api.example.com/endpoint1',
    'https://api.example.com/endpoint2',
    'https://api.example.com/endpoint3'
  ];
  const responseTimes = fetchResponseTimes(apiEndpoints);

  let count = 0;
  const sum = await responseTimes.reduce(async (accumulator, time) => {
    count++;
    return accumulator + time;
  }, 0);

  const average = count > 0 ? sum / count : 0;
  console.log(`Average response time: ${average} ms`);
}

૭. `toArray()`

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

સિન્ટેક્સ:

asyncGenerator.toArray()

ઉદાહરણ: સ્ટ્રીમમાંથી સંખ્યાઓને એરેમાં એકત્રિત કરવી.

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

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const numberArray = await numbers.toArray();

  console.log('Number Array:', numberArray);
}

processNumbers();

વાસ્તવિક-દુનિયાનો ઉપયોગનો કેસ: પેજિનેટેડ API માંથી બધી આઇટમ્સને ક્લાયન્ટ-સાઇડ ફિલ્ટરિંગ અથવા સોર્ટિંગ માટે એક જ એરેમાં એકત્રિત કરવી.

async function* fetchAllItems(apiEndpoint) {
    let pageNumber = 1;
    const pageSize = 100;  // API ની પેજિનેશન મર્યાદાઓના આધારે ગોઠવો

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

        if (!data || data.length === 0) {
            break; // વધુ ડેટા નથી
        }

        for (const item of data) {
            await new Promise(resolve => setTimeout(resolve, 50));
            yield item;
        }

        pageNumber++;
    }
}

async function processAllItems() {
    const apiEndpoint = 'https://api.example.com/items';
    const allItems = fetchAllItems(apiEndpoint);
    const itemsArray = await allItems.toArray();

    console.log(`Fetched ${itemsArray.length} items.`);
    // `itemsArray` પર વધુ પ્રક્રિયા કરી શકાય છે
}

૮. `forEach()`

forEach() હેલ્પર અસિંક જનરેટરમાં દરેક વેલ્યુ માટે એકવાર પૂરા પાડવામાં આવેલ ફંક્શનને એક્ઝિક્યુટ કરે છે. અન્ય હેલ્પર્સથી વિપરીત, forEach() નવું અસિંક જનરેટર પરત કરતું નથી; તેનો ઉપયોગ દરેક વેલ્યુ પર સાઇડ ઇફેક્ટ્સ કરવા માટે થાય છે.

સિન્ટેક્સ:

asyncGenerator.forEach(callback)

ઉદાહરણ: સ્ટ્રીમમાં દરેક સંખ્યાને કન્સોલમાં લોગ કરવી.

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

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  await numbers.forEach(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log('Number:', num);
  });
}

processNumbers();

વાસ્તવિક-દુનિયાનો ઉપયોગનો કેસ: સ્ટ્રીમમાંથી ડેટા પ્રોસેસ થતાંની સાથે જ યુઝર ઇન્ટરફેસ પર રિયલ-ટાઇમ અપડેટ્સ મોકલવા.

async function* fetchRealTimeData(dataSource) {
    //રિયલ-ટાઇમ ડેટા (દા.ત. સ્ટોક પ્રાઇસ) મેળવવાનું અનુકરણ કરો.
    const dataStream = [
      { timestamp: new Date(), price: 100 },
      { timestamp: new Date(), price: 101 },
      { timestamp: new Date(), price: 102 }
    ];
    for (const dataPoint of dataStream) {
      await new Promise(resolve => setTimeout(resolve, 500));
      yield dataPoint;
    }
}

async function updateUI() {
  const realTimeData = fetchRealTimeData('stock-api');
  await realTimeData.forEach(async (data) => {
    //UI અપડેટ કરવાનું અનુકરણ કરો
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log(`Updating UI with data: ${JSON.stringify(data)}`);
    // ખરેખર UI અપડેટ કરવાનો કોડ અહીં આવશે.
  });
}

જટિલ ડેટા પાઇપલાઇન્સ માટે અસિંક જનરેટર હેલ્પર્સનું સંયોજન

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

ઉદાહરણ: સંખ્યાઓના સ્ટ્રીમને ફિલ્ટર કરીને ફક્ત બેકી સંખ્યાઓનો સમાવેશ કરવો, પછી તેમનો વર્ગ કરવો, અને અંતે પ્રથમ ૩ પરિણામો લેવા.

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);

  const processedNumbers = numbers
    .filter(async (num) => num % 2 === 0)
    .map(async (num) => num * num)
    .take(3);

  for await (const num of processedNumbers) {
    console.log(num);
  }
}

processNumbers();

વાસ્તવિક-દુનિયાનો ઉપયોગનો કેસ: વપરાશકર્તા ડેટા મેળવવો, તેમના સ્થાનના આધારે વપરાશકર્તાઓને ફિલ્ટર કરવા, તેમના ડેટાને ફક્ત સંબંધિત ફીલ્ડ્સ શામેલ કરવા માટે રૂપાંતરિત કરવું, અને પછી નકશા પર પ્રથમ ૧૦ વપરાશકર્તાઓને પ્રદર્શિત કરવું.

async function* fetchUsers() {
  // ડેટાબેઝ અથવા API માંથી વપરાશકર્તાઓ મેળવવાનું અનુકરણ
  const users = [
    { id: 1, name: 'John Doe', location: 'New York', email: 'john.doe@example.com' },
    { id: 2, name: 'Jane Smith', location: 'London', email: 'jane.smith@example.com' },
    { id: 3, name: 'Ken Tan', location: 'Singapore', email: 'ken.tan@example.com' },
    { id: 4, name: 'Alice Jones', location: 'New York', email: 'alice.jones@example.com' },
    { id: 5, name: 'Bob Williams', location: 'London', email: 'bob.williams@example.com' },
    { id: 6, name: 'Siti Rahman', location: 'Singapore', email: 'siti.rahman@example.com' },
    { id: 7, name: 'Ahmed Khan', location: 'Dubai', email: 'ahmed.khan@example.com' },
    { id: 8, name: 'Maria Garcia', location: 'Madrid', email: 'maria.garcia@example.com' },
    { id: 9, name: 'Li Wei', location: 'Shanghai', email: 'li.wei@example.com' },
    { id: 10, name: 'Hans Müller', location: 'Berlin', email: 'hans.muller@example.com' },
    { id: 11, name: 'Emily Chen', location: 'Sydney', email: 'emily.chen@example.com' }
  ];

  for (const user of users) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield user;
  }
}

async function displayUsersOnMap(location, maxUsers) {
  const users = fetchUsers();

  const usersForMap = users
    .filter(async (user) => user.location === location)
    .map(async (user) => ({
      id: user.id,
      name: user.name,
      location: user.location
    }))
    .take(maxUsers);

  console.log(`Displaying up to ${maxUsers} users from ${location} on the map:`);
  for await (const user of usersForMap) {
    console.log(user);
  }
}

// ઉપયોગના ઉદાહરણો:
displayUsersOnMap('New York', 2);
displayUsersOnMap('London', 5);

પોલીફિલ્સ અને બ્રાઉઝર સપોર્ટ

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

core-js નો ઉપયોગ કરીને ઉદાહરણ:

// જરૂરી પોલીફિલ્સ ઇમ્પોર્ટ કરો
require('core-js/features/async-iterator/map');
require('core-js/features/async-iterator/filter');
// ... અન્ય જરૂરી હેલ્પર્સ ઇમ્પોર્ટ કરો

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

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

ઉદાહરણ: map() ઓપરેશનની અંદર ડેટા મેળવતી વખતે ભૂલોને હેન્ડલ કરવી.

async function* fetchData(urls) {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      const data = await response.json();
      yield data;
    } catch (error) {
      console.error(`Error fetching data from ${url}: ${error}`);
      yield null; // અથવા ભૂલને યોગ્ય રીતે હેન્ડલ કરો, દા.ત., એરર ઓબ્જેક્ટ આપીને
    }
  }
}

async function processData() {
  const urls = [
    'https://api.example.com/data1',
    'https://api.example.com/data2',
    'https://api.example.com/data3'
  ];

  const dataStream = fetchData(urls);

  const processedData = dataStream.map(async (data) => {
    if (data === null) {
      return null; // ભૂલને આગળ વધારો
    }
    // ડેટા પર પ્રક્રિયા કરો
    return data;
  });

  for await (const item of processedData) {
    if (item === null) {
      console.log('Skipping item due to error');
      continue;
    }
    console.log('Processed Item:', item);
  }
}

processData();

શ્રેષ્ઠ પદ્ધતિઓ અને વિચારણાઓ

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

નિષ્કર્ષ

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