M

MLOG

हिन्दी

स्ट्रीम प्रोसेसिंग में क्रांति लाने के लिए जावास्क्रिप्ट एसिंक इटरेटर हेल्पर्स का अन्वेषण करें। map, filter, take, drop, और अन्य तरीकों से एसिंक्रोनस डेटा स्ट्रीम को कुशलतापूर्वक संभालना सीखें।

जावास्क्रिप्ट एसिंक इटरेटर हेल्पर्स: आधुनिक एप्लिकेशन्स के लिए शक्तिशाली स्ट्रीम प्रोसेसिंग

आधुनिक जावास्क्रिप्ट डेवलपमेंट में, एसिंक्रोनस डेटा स्ट्रीम से निपटना एक आम आवश्यकता है। चाहे आप किसी API से डेटा फ़ेच कर रहे हों, बड़ी फ़ाइलों को प्रोसेस कर रहे हों, या रीयल-टाइम इवेंट्स को हैंडल कर रहे हों, एसिंक्रोनस डेटा का कुशलतापूर्वक प्रबंधन करना महत्वपूर्ण है। जावास्क्रिप्ट के एसिंक इटरेटर हेल्पर्स इन स्ट्रीम्स को प्रोसेस करने का एक शक्तिशाली और सुरुचिपूर्ण तरीका प्रदान करते हैं, जो डेटा मैनिपुलेशन के लिए एक फंक्शनल और कंपोज़ेबल दृष्टिकोण प्रदान करते हैं।

एसिंक इटरेटर्स और एसिंक इटरेबल्स क्या हैं?

एसिंक इटरेटर हेल्पर्स में गोता लगाने से पहले, आइए अंतर्निहित अवधारणाओं को समझें: एसिंक इटरेटर्स और एसिंक इटरेबल्स।

एक एसिंक इटरेबल एक ऑब्जेक्ट है जो अपने मानों पर एसिंक्रोनस रूप से इटरेट करने का एक तरीका परिभाषित करता है। यह @@asyncIterator मेथड को लागू करके ऐसा करता है, जो एक एसिंक इटरेटर लौटाता है।

एक एसिंक इटरेटर एक ऑब्जेक्ट है जो एक next() मेथड प्रदान करता है। यह मेथड एक प्रॉमिस लौटाता है जो दो प्रॉपर्टी वाले ऑब्जेक्ट में रिज़ॉल्व होता है:

यहाँ एक सरल उदाहरण है:


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate an asynchronous operation
    yield i;
  }
}

const asyncIterable = generateSequence(5);

(async () => {
  for await (const value of asyncIterable) {
    console.log(value); // Output: 1, 2, 3, 4, 5 (with 500ms delay between each)
  }
})();

इस उदाहरण में, generateSequence एक एसिंक जनरेटर फ़ंक्शन है जो एसिंक्रोनस रूप से संख्याओं का एक अनुक्रम उत्पन्न करता है। एसिंक इटरेबल से मानों का उपभोग करने के लिए for await...of लूप का उपयोग किया जाता है।

एसिंक इटरेटर हेल्पर्स का परिचय

एसिंक इटरेटर हेल्पर्स एसिंक इटरेटर्स की कार्यक्षमता का विस्तार करते हैं, जो एसिंक्रोनस डेटा स्ट्रीम को बदलने, फ़िल्टर करने और हेरफेर करने के लिए मेथड्स का एक सेट प्रदान करते हैं। वे प्रोग्रामिंग की एक फंक्शनल और कंपोज़ेबल शैली को सक्षम करते हैं, जिससे जटिल डेटा प्रोसेसिंग पाइपलाइन बनाना आसान हो जाता है।

मुख्य एसिंक इटरेटर हेल्पर्स में शामिल हैं:

आइए प्रत्येक हेल्पर को उदाहरणों के साथ देखें।

map()

map() हेल्पर दिए गए फ़ंक्शन का उपयोग करके एसिंक इटरेबल के प्रत्येक एलिमेंट को बदलता है। यह बदले हुए मानों के साथ एक नया एसिंक इटरेबल लौटाता है।


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

const asyncIterable = generateSequence(5);

const doubledIterable = asyncIterable.map(x => x * 2);

(async () => {
  for await (const value of doubledIterable) {
    console.log(value); // Output: 2, 4, 6, 8, 10 (with 100ms delay)
  }
})();

इस उदाहरण में, map(x => x * 2) अनुक्रम में प्रत्येक संख्या को दोगुना कर देता है।

filter()

filter() हेल्पर दिए गए शर्त (प्रेडिकेट फ़ंक्शन) के आधार पर एसिंक इटरेबल से एलिमेंट का चयन करता है। यह एक नया एसिंक इटरेबल लौटाता है जिसमें केवल वे एलिमेंट होते हैं जो शर्त को पूरा करते हैं।


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

const asyncIterable = generateSequence(10);

const evenNumbersIterable = asyncIterable.filter(x => x % 2 === 0);

(async () => {
  for await (const value of evenNumbersIterable) {
    console.log(value); // Output: 2, 4, 6, 8, 10 (with 100ms delay)
  }
})();

इस उदाहरण में, filter(x => x % 2 === 0) अनुक्रम से केवल सम संख्याओं का चयन करता है।

take()

take() हेल्पर एसिंक इटरेबल से पहले N एलिमेंट लौटाता है। यह एक नया एसिंक इटरेबल लौटाता है जिसमें केवल निर्दिष्ट संख्या में एलिमेंट होते हैं।


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

const asyncIterable = generateSequence(5);

const firstThreeIterable = asyncIterable.take(3);

(async () => {
  for await (const value of firstThreeIterable) {
    console.log(value); // Output: 1, 2, 3 (with 100ms delay)
  }
})();

इस उदाहरण में, take(3) अनुक्रम से पहली तीन संख्याओं का चयन करता है।

drop()

drop() हेल्पर एसिंक इटरेबल से पहले N एलिमेंट को छोड़ देता है और बाकी को लौटाता है। यह एक नया एसिंक इटरेबल लौटाता है जिसमें शेष एलिमेंट होते हैं।


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

const asyncIterable = generateSequence(5);

const afterFirstTwoIterable = asyncIterable.drop(2);

(async () => {
  for await (const value of afterFirstTwoIterable) {
    console.log(value); // Output: 3, 4, 5 (with 100ms delay)
  }
})();

इस उदाहरण में, drop(2) अनुक्रम से पहली दो संख्याओं को छोड़ देता है।

toArray()

toArray() हेल्पर पूरे एसिंक इटरेबल का उपभोग करता है और सभी एलिमेंट को एक ऐरे में इकट्ठा करता है। यह एक प्रॉमिस लौटाता है जो सभी एलिमेंट वाले ऐरे में रिज़ॉल्व होता है।


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

const asyncIterable = generateSequence(5);

(async () => {
  const numbersArray = await asyncIterable.toArray();
  console.log(numbersArray); // Output: [1, 2, 3, 4, 5]
})();

इस उदाहरण में, toArray() अनुक्रम से सभी संख्याओं को एक ऐरे में इकट्ठा करता है।

forEach()

forEach() हेल्पर एसिंक इटरेबल में प्रत्येक एलिमेंट के लिए एक बार दिए गए फ़ंक्शन को निष्पादित करता है। यह एक नया एसिंक इटरेबल नहीं लौटाता है, यह साइड-इफेक्ट के रूप में फ़ंक्शन को निष्पादित करता है। यह लॉगिंग या UI अपडेट करने जैसे कार्यों के लिए उपयोगी हो सकता है।


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

const asyncIterable = generateSequence(3);

(async () => {
  await asyncIterable.forEach(value => {
    console.log("Value:", value);
  });
  console.log("forEach completed");
})();
// Output: Value: 1, Value: 2, Value: 3, forEach completed

some()

some() हेल्पर यह जाँचता है कि क्या एसिंक इटरेबल में कम से कम एक एलिमेंट दिए गए फ़ंक्शन द्वारा लागू किए गए परीक्षण को पास करता है। यह एक प्रॉमिस लौटाता है जो एक बूलियन मान में रिज़ॉल्व होता है (true यदि कम से कम एक एलिमेंट शर्त को पूरा करता है, अन्यथा false)।


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

const asyncIterable = generateSequence(5);

(async () => {
  const hasEvenNumber = await asyncIterable.some(x => x % 2 === 0);
  console.log("Has even number:", hasEvenNumber); // Output: Has even number: true
})();

every()

every() हेल्पर यह जाँचता है कि क्या एसिंक इटरेबल में सभी एलिमेंट दिए गए फ़ंक्शन द्वारा लागू किए गए परीक्षण को पास करते हैं। यह एक प्रॉमिस लौटाता है जो एक बूलियन मान में रिज़ॉल्व होता है (true यदि सभी एलिमेंट शर्त को पूरा करते हैं, अन्यथा false)।


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

const asyncIterable = generateSequence(4);

(async () => {
  const areAllEven = await asyncIterable.every(x => x % 2 === 0);
  console.log("Are all even:", areAllEven); // Output: Are all even: true
})();

find()

find() हेल्पर एसिंक इटरेबल में पहला एलिमेंट लौटाता है जो दिए गए परीक्षण फ़ंक्शन को संतुष्ट करता है। यदि कोई मान परीक्षण फ़ंक्शन को संतुष्ट नहीं करता है, तो undefined लौटाया जाता है। यह एक प्रॉमिस लौटाता है जो पाए गए एलिमेंट या undefined में रिज़ॉल्व होता है।


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

const asyncIterable = generateSequence(5);

(async () => {
  const firstEven = await asyncIterable.find(x => x % 2 === 0);
  console.log("First even number:", firstEven); // Output: First even number: 2
})();

reduce()

reduce() हेल्पर एसिंक इटरेबल के प्रत्येक एलिमेंट पर एक उपयोगकर्ता-प्रदत्त "रिड्यूसर" कॉलबैक फ़ंक्शन को क्रम से निष्पादित करता है, जिसमें पिछले एलिमेंट पर गणना से वापसी मान पास किया जाता है। सभी एलिमेंट में रिड्यूसर चलाने का अंतिम परिणाम एक एकल मान है। यह एक प्रॉमिस लौटाता है जो अंतिम संचित मान में रिज़ॉल्व होता है।


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

const asyncIterable = generateSequence(5);

(async () => {
  const sum = await asyncIterable.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
  console.log("Sum:", sum); // Output: Sum: 15
})();

व्यावहारिक उदाहरण और उपयोग के मामले

एसिंक इटरेटर हेल्पर्स विभिन्न परिदृश्यों में मूल्यवान हैं। आइए कुछ व्यावहारिक उदाहरण देखें:

1. स्ट्रीमिंग API से डेटा प्रोसेस करना

कल्पना कीजिए कि आप एक रीयल-टाइम डेटा विज़ुअलाइज़ेशन डैशबोर्ड बना रहे हैं जो एक स्ट्रीमिंग API से डेटा प्राप्त करता है। API लगातार अपडेट भेजता है, और आपको नवीनतम जानकारी प्रदर्शित करने के लिए इन अपडेट को प्रोसेस करने की आवश्यकता है।


async function* fetchDataFromAPI(url) {
  let response = await fetch(url);

  if (!response.body) {
    throw new Error("ReadableStream not supported in this environment");
  }

  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        break;
      }
      const chunk = decoder.decode(value);
      // Assuming the API sends JSON objects separated by newlines
      const lines = chunk.split('\n');
      for (const line of lines) {
        if (line.trim() !== '') {
          yield JSON.parse(line);
        }
      }
    }
  } finally {
    reader.releaseLock();
  }
}

const apiURL = 'https://example.com/streaming-api'; // Replace with your API URL
const dataStream = fetchDataFromAPI(apiURL);

// Process the data stream
(async () => {
  for await (const data of dataStream.filter(item => item.type === 'metric').map(item => ({ timestamp: item.timestamp, value: item.value }))) {
    console.log('Processed Data:', data);
    // Update the dashboard with the processed data
  }
})();

इस उदाहरण में, fetchDataFromAPI एक स्ट्रीमिंग API से डेटा फ़ेच करता है, JSON ऑब्जेक्ट्स को पार्स करता है, और उन्हें एक एसिंक इटरेबल के रूप में उत्पन्न करता है। filter हेल्पर केवल मीट्रिक्स का चयन करता है, और map हेल्पर डैशबोर्ड को अपडेट करने से पहले डेटा को वांछित प्रारूप में बदल देता है।

2. बड़ी फ़ाइलों को पढ़ना और प्रोसेस करना

मान लीजिए आपको ग्राहक डेटा वाली एक बड़ी CSV फ़ाइल को प्रोसेस करने की आवश्यकता है। पूरी फ़ाइल को मेमोरी में लोड करने के बजाय, आप इसे चंक-बाय-चंक प्रोसेस करने के लिए एसिंक इटरेटर हेल्पर्स का उपयोग कर सकते हैं।


async function* readLinesFromFile(filePath) {
  const file = await fsPromises.open(filePath, 'r');

  try {
    let buffer = Buffer.alloc(1024);
    let fileOffset = 0;
    let remainder = '';

    while (true) {
      const { bytesRead } = await file.read(buffer, 0, buffer.length, fileOffset);
      if (bytesRead === 0) {
        if (remainder) {
          yield remainder;
        }
        break;
      }

      fileOffset += bytesRead;
      const chunk = buffer.toString('utf8', 0, bytesRead);
      const lines = chunk.split('\n');

      lines[0] = remainder + lines[0];
      remainder = lines.pop() || '';

      for (const line of lines) {
        yield line;
      }
    }
  } finally {
    await file.close();
  }
}

const filePath = './customer_data.csv'; // Replace with your file path
const lines = readLinesFromFile(filePath);

// Process the lines
(async () => {
  for await (const customerData of lines.drop(1).map(line => line.split(',')).filter(data => data[2] === 'USA')) {
    console.log('Customer from USA:', customerData);
    // Process customer data from the USA
  }
})();

इस उदाहरण में, readLinesFromFile फ़ाइल को लाइन-बाय-लाइन पढ़ता है और प्रत्येक लाइन को एक एसिंक इटरेबल के रूप में उत्पन्न करता है। drop(1) हेल्पर हेडर पंक्ति को छोड़ देता है, map हेल्पर लाइन को कॉलम में विभाजित करता है, और filter हेल्पर केवल USA के ग्राहकों का चयन करता है।

3. रीयल-टाइम इवेंट्स को हैंडल करना

एसिंक इटरेटर हेल्पर्स का उपयोग वेबसॉकेट्स जैसे स्रोतों से रीयल-टाइम इवेंट्स को हैंडल करने के लिए भी किया जा सकता है। आप एक एसिंक इटरेबल बना सकते हैं जो इवेंट्स के आने पर उन्हें उत्सर्जित करता है और फिर इन इवेंट्स को प्रोसेस करने के लिए हेल्पर्स का उपयोग करता है।


async function* createWebSocketStream(url) {
  const ws = new WebSocket(url);

  yield new Promise((resolve, reject) => {
      ws.onopen = () => {
          resolve();
      };
      ws.onerror = (error) => {
          reject(error);
      };
  });

  try {
    while (ws.readyState === WebSocket.OPEN) {
      yield new Promise((resolve, reject) => {
        ws.onmessage = (event) => {
          resolve(JSON.parse(event.data));
        };
        ws.onerror = (error) => {
          reject(error);
        };
        ws.onclose = () => {
           resolve(null); // Resolve with null when connection closes
        }
      });

    }
  } finally {
    ws.close();
  }
}

const websocketURL = 'wss://example.com/events'; // Replace with your WebSocket URL
const eventStream = createWebSocketStream(websocketURL);

// Process the event stream
(async () => {
  for await (const event of eventStream.filter(event => event.type === 'user_login').map(event => ({ userId: event.userId, timestamp: event.timestamp }))) {
    console.log('User Login Event:', event);
    // Process user login event
  }
})();

इस उदाहरण में, createWebSocketStream एक एसिंक इटरेबल बनाता है जो वेबसॉकेट से प्राप्त इवेंट्स को उत्सर्जित करता है। filter हेल्पर केवल उपयोगकर्ता लॉगिन इवेंट्स का चयन करता है, और map हेल्पर डेटा को वांछित प्रारूप में बदल देता है।

एसिंक इटरेटर हेल्पर्स का उपयोग करने के लाभ

ब्राउज़र और रनटाइम सपोर्ट

एसिंक इटरेटर हेल्पर्स जावास्क्रिप्ट में अभी भी एक अपेक्षाकृत नई सुविधा है। 2024 के अंत तक, वे TC39 मानकीकरण प्रक्रिया के चरण 3 में हैं, जिसका अर्थ है कि निकट भविष्य में उनके मानकीकृत होने की संभावना है। हालाँकि, वे अभी तक सभी ब्राउज़रों और Node.js संस्करणों में मूल रूप से समर्थित नहीं हैं।

ब्राउज़र सपोर्ट: क्रोम, फ़ायरफ़ॉक्स, सफारी और एज जैसे आधुनिक ब्राउज़र धीरे-धीरे एसिंक इटरेटर हेल्पर्स के लिए समर्थन जोड़ रहे हैं। आप Can I use... जैसी वेबसाइटों पर नवीनतम ब्राउज़र संगतता जानकारी देख सकते हैं कि कौन से ब्राउज़र इस सुविधा का समर्थन करते हैं।

Node.js सपोर्ट: Node.js के हाल के संस्करण (v18 और ऊपर) एसिंक इटरेटर हेल्पर्स के लिए प्रायोगिक समर्थन प्रदान करते हैं। उनका उपयोग करने के लिए, आपको --experimental-async-iterator ध्वज के साथ Node.js चलाने की आवश्यकता हो सकती है।

पॉलीफिल्स: यदि आपको उन वातावरणों में एसिंक इटरेटर हेल्पर्स का उपयोग करने की आवश्यकता है जो मूल रूप से उनका समर्थन नहीं करते हैं, तो आप एक पॉलीफ़िल का उपयोग कर सकते हैं। एक पॉलीफ़िल कोड का एक टुकड़ा है जो लापता कार्यक्षमता प्रदान करता है। एसिंक इटरेटर हेल्पर्स के लिए कई पॉलीफ़िल लाइब्रेरी उपलब्ध हैं; एक लोकप्रिय विकल्प core-js लाइब्रेरी है।

कस्टम एसिंक इटरेटर्स लागू करना

जबकि एसिंक इटरेटर हेल्पर्स मौजूदा एसिंक इटरेबल्स को प्रोसेस करने का एक सुविधाजनक तरीका प्रदान करते हैं, आपको कभी-कभी अपने स्वयं के कस्टम एसिंक इटरेटर्स बनाने की आवश्यकता हो सकती है। यह आपको विभिन्न स्रोतों, जैसे डेटाबेस, API, या फ़ाइल सिस्टम से डेटा को स्ट्रीमिंग तरीके से संभालने की अनुमति देता है।

एक कस्टम एसिंक इटरेटर बनाने के लिए, आपको एक ऑब्जेक्ट पर @@asyncIterator मेथड को लागू करने की आवश्यकता है। इस मेथड को एक next() मेथड के साथ एक ऑब्जेक्ट लौटाना चाहिए। next() मेथड को एक प्रॉमिस लौटाना चाहिए जो value और done प्रॉपर्टी वाले ऑब्जेक्ट में रिज़ॉल्व होता है।

यहाँ एक कस्टम एसिंक इटरेटर का एक उदाहरण है जो एक पेजिनेटेड API से डेटा फ़ेच करता है:


async function* fetchPaginatedData(baseURL) {
  let page = 1;
  let hasMore = true;

  while (hasMore) {
    const url = `${baseURL}?page=${page}`;
    const response = await fetch(url);
    const data = await response.json();

    if (data.results.length === 0) {
      hasMore = false;
      break;
    }

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

    page++;
  }
}

const apiBaseURL = 'https://api.example.com/data'; // Replace with your API URL
const paginatedData = fetchPaginatedData(apiBaseURL);

// Process the paginated data
(async () => {
  for await (const item of paginatedData) {
    console.log('Item:', item);
    // Process the item
  }
})();

इस उदाहरण में, fetchPaginatedData एक पेजिनेटेड API से डेटा फ़ेच करता है, प्रत्येक आइटम को प्राप्त होने पर उत्पन्न करता है। एसिंक इटरेटर पेजिनेशन तर्क को संभालता है, जिससे डेटा को स्ट्रीमिंग तरीके से उपभोग करना आसान हो जाता है।

संभावित चुनौतियाँ और विचार

जबकि एसिंक इटरेटर हेल्पर्स कई लाभ प्रदान करते हैं, कुछ संभावित चुनौतियों और विचारों से अवगत होना महत्वपूर्ण है:

एसिंक इटरेटर हेल्पर्स का उपयोग करने के लिए सर्वोत्तम प्रथाएं

एसिंक इटरेटर हेल्पर्स का अधिकतम लाभ उठाने के लिए, निम्नलिखित सर्वोत्तम प्रथाओं पर विचार करें:

उन्नत तकनीकें

कस्टम हेल्पर्स बनाना

आप मौजूदा हेल्पर्स को कंपोज़ करके या स्क्रैच से नए बनाकर अपने स्वयं के कस्टम एसिंक इटरेटर हेल्पर्स बना सकते हैं। यह आपको अपनी विशिष्ट आवश्यकताओं के लिए कार्यक्षमता को अनुकूलित करने और पुन: प्रयोज्य घटक बनाने की अनुमति देता है।


async function* takeWhile(asyncIterable, predicate) {
  for await (const value of asyncIterable) {
    if (!predicate(value)) {
      break;
    }
    yield value;
  }
}

// Example Usage:
async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(10);
const firstFive = takeWhile(asyncIterable, x => x <= 5);

(async () => {
  for await (const value of firstFive) {
    console.log(value);
  }
})();

कई एसिंक इटरेबल्स को मिलाना

आप zip या merge जैसी तकनीकों का उपयोग करके कई एसिंक इटरेबल्स को एक ही एसिंक इटरेबल में मिला सकते हैं। यह आपको एक साथ कई स्रोतों से डेटा प्रोसेस करने की अनुमति देता है।


async function* zip(asyncIterable1, asyncIterable2) {
    const iterator1 = asyncIterable1[Symbol.asyncIterator]();
    const iterator2 = asyncIterable2[Symbol.asyncIterator]();

    while (true) {
        const result1 = await iterator1.next();
        const result2 = await iterator2.next();

        if (result1.done || result2.done) {
            break;
        }

        yield [result1.value, result2.value];
    }
}

// Example Usage:
async function* generateSequence1(end) {
    for (let i = 1; i <= end; i++) {
        yield i;
    }
}

async function* generateSequence2(end) {
    for (let i = 10; i <= end + 9; i++) {
        yield i;
    }
}

const iterable1 = generateSequence1(5);
const iterable2 = generateSequence2(5);

(async () => {
    for await (const [value1, value2] of zip(iterable1, iterable2)) {
        console.log(value1, value2);
    }
})();

निष्कर्ष

जावास्क्रिप्ट एसिंक इटरेटर हेल्पर्स एसिंक्रोनस डेटा स्ट्रीम को प्रोसेस करने का एक शक्तिशाली और सुरुचिपूर्ण तरीका प्रदान करते हैं। वे डेटा मैनिपुलेशन के लिए एक फंक्शनल और कंपोज़ेबल दृष्टिकोण प्रदान करते हैं, जिससे जटिल डेटा प्रोसेसिंग पाइपलाइन बनाना आसान हो जाता है। एसिंक इटरेटर्स और एसिंक इटरेबल्स की मुख्य अवधारणाओं को समझकर और विभिन्न हेल्पर मेथड्स में महारत हासिल करके, आप अपने एसिंक्रोनस जावास्क्रिप्ट कोड की दक्षता और रखरखाव में काफी सुधार कर सकते हैं। जैसे-जैसे ब्राउज़र और रनटाइम सपोर्ट बढ़ता जा रहा है, एसिंक इटरेटर हेल्पर्स आधुनिक जावास्क्रिप्ट डेवलपर्स के लिए एक आवश्यक उपकरण बनने के लिए तैयार हैं।