ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸ்: நவீன பயன்பாடுகளுக்கான சக்திவாய்ந்த ஸ்ட்ரீம் செயலாக்கம்

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

அசிங்க் இட்டரேட்டர்கள் மற்றும் அசிங்க் இட்டரேபிள்கள் என்றால் என்ன?

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

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

ஒரு அசிங்க் இட்டரேட்டர் என்பது next() முறையை வழங்கும் ஒரு பொருளாகும். இந்த முறை இரண்டு பண்புகளுடன் ஒரு பொருளுக்குத் தீர்க்கும் ஒரு ப்ராமிஸை வழங்குகிறது:

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

இங்கே ஒரு எளிய உதாரணம்:

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(): ஸ்ட்ரீமின் ஒவ்வொரு உறுப்பையும் மாற்றுகிறது.
• filter(): ஒரு நிபந்தனையின் அடிப்படையில் ஸ்ட்ரீமிலிருந்து உறுப்புகளைத் தேர்ந்தெடுக்கிறது.
• take(): ஸ்ட்ரீமின் முதல் N உறுப்புகளை வழங்குகிறது.
• drop(): ஸ்ட்ரீமின் முதல் N உறுப்புகளைத் தவிர்க்கிறது.
• toArray(): ஸ்ட்ரீமின் அனைத்து உறுப்புகளையும் ஒரு வரிசையில் சேகரிக்கிறது.
• forEach(): ஒவ்வொரு ஸ்ட்ரீம் உறுப்புக்கும் ஒரு முறை வழங்கப்பட்ட செயல்பாட்டை செயல்படுத்துகிறது.
• some(): குறைந்தபட்சம் ஒரு உறுப்பு வழங்கப்பட்ட நிபந்தனையை பூர்த்தி செய்கிறதா என்று சரிபார்க்கிறது.
• every(): அனைத்து உறுப்புகளும் வழங்கப்பட்ட நிபந்தனையை பூர்த்தி செய்கின்றனவா என்று சரிபார்க்கிறது.
• find(): வழங்கப்பட்ட நிபந்தனையை பூர்த்தி செய்யும் முதல் உறுப்பை வழங்குகிறது.
• reduce(): ஒரு செயல்பாட்டை ஒரு அக்குமுலேட்டர் மற்றும் ஒவ்வொரு உறுப்புக்கு எதிராகப் பிரயோகித்து அதை ஒற்றை மதிப்பாகக் குறைக்கிறது.

ஒவ்வொரு ஹெல்பரையும் எடுத்துக்காட்டுகளுடன் ஆராய்வோம்.

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() ஹெல்பர் வழங்கப்பட்ட நிபந்தனையின் (predicate function) அடிப்படையில் அசிங்க் இட்டரேபிளிலிருந்து உறுப்புகளைத் தேர்ந்தெடுக்கிறது. இது நிபந்தனையை பூர்த்தி செய்யும் உறுப்புகளை மட்டுமே கொண்ட ஒரு புதிய அசிங்க் இட்டரேபிளை வழங்குகிறது.

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() ஹெல்பர் பயனரால் வழங்கப்பட்ட "reducer" கால்பேக் செயல்பாட்டை அசிங்க் இட்டரேபிளின் ஒவ்வொரு உறுப்பிலும், வரிசையாக, முந்தைய உறுப்பின் கணக்கீட்டிலிருந்து திரும்பப் பெறும் மதிப்பை உள்ளே அனுப்பும். அனைத்து உறுப்புகளிலும் ரிட்யூசரை இயக்கியதன் இறுதி முடிவு ஒரு ஒற்றை மதிப்பாகும். இது இறுதி திரட்டப்பட்ட மதிப்புக்குத் தீர்க்கும் ஒரு ப்ராமிஸை வழங்குகிறது.

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. நிகழ்நேர நிகழ்வுகளைக் கையாளுதல்

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

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 ஒரு WebSocket இலிருந்து பெறப்பட்ட நிகழ்வுகளை வெளியிடும் ஒரு அசிங்க் இட்டரேபிளை உருவாக்குகிறது. filter ஹெல்பர் பயனர் உள்நுழைவு நிகழ்வுகளை மட்டுமே தேர்ந்தெடுக்கிறது, மற்றும் map ஹெல்பர் தரவை விரும்பிய வடிவத்திற்கு மாற்றுகிறது.

அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸைப் பயன்படுத்துவதன் நன்மைகள்

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

உலாவி மற்றும் இயக்க நேர ஆதரவு

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

உலாவி ஆதரவு: Chrome, Firefox, Safari மற்றும் Edge போன்ற நவீன உலாவிகள் படிப்படியாக அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸிற்கான ஆதரவைச் சேர்க்கின்றன. 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 இலிருந்து தரவைப் பெறுகிறது, ஒவ்வொரு உருப்படியையும் அது மீட்டெடுக்கப்பட்டவுடன் வழங்குகிறது. அசிங்க் இட்டரேட்டர் பக்கப்படுத்தல் தர்க்கத்தைக் கையாளுகிறது, இது தரவை ஒரு ஸ்ட்ரீமிங் முறையில் நுகர்வதை எளிதாக்குகிறது.

சாத்தியமான சவால்கள் மற்றும் கருத்தாய்வுகள்

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

• பிழை கையாளுதல்: ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களுடன் பணிபுரியும்போது சரியான பிழை கையாளுதல் முக்கியமானது. தரவு பெறுதல், செயலாக்குதல் அல்லது மாற்றுதலின் போது ஏற்படக்கூடிய சாத்தியமான பிழைகளை நீங்கள் கையாள வேண்டும். உங்கள் அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸில் try...catch தொகுதிகள் மற்றும் பிழை கையாளுதல் நுட்பங்களைப் பயன்படுத்துவது அவசியம்.
• ரத்துசெய்தல்: சில சூழ்நிலைகளில், ஒரு அசிங்க் இட்டரேபிள் முழுமையாக நுகரப்படுவதற்கு முன்பு அதன் செயலாக்கத்தை நீங்கள் ரத்து செய்ய வேண்டியிருக்கலாம். நீண்ட காலமாக இயங்கும் செயல்பாடுகள் அல்லது ஒரு குறிப்பிட்ட நிபந்தனை பூர்த்தி செய்யப்பட்ட பிறகு செயலாக்கத்தை நிறுத்த விரும்பும் நிகழ்நேர தரவு ஸ்ட்ரீம்களைக் கையாளும்போது இது பயனுள்ளதாக இருக்கும். AbortController ஐப் பயன்படுத்துவது போன்ற ரத்துசெய்தல் வழிமுறைகளை செயல்படுத்துவது, ஒத்திசைவற்ற செயல்பாடுகளை திறம்பட நிர்வகிக்க உதவும்.
• பின் அழுத்தம் (Backpressure): தரவை நுகரக்கூடியதை விட வேகமாக உற்பத்தி செய்யும் தரவு ஸ்ட்ரீம்களைக் கையாளும்போது, பின் அழுத்தம் ஒரு கவலையாகிறது. பின் அழுத்தம் என்பது நுகர்வோர் தயாரிப்பாளருக்கு தரவு வெளியிடப்படும் விகிதத்தைக் குறைக்க சமிக்ஞை செய்யும் திறனைக் குறிக்கிறது. பின் அழுத்த வழிமுறைகளை செயல்படுத்துவது நினைவக அதிக சுமையைத் தடுக்கலாம் மற்றும் தரவு ஸ்ட்ரீம் திறமையாக செயலாக்கப்படுவதை உறுதிசெய்யலாம்.
• பிழைதிருத்தம் (Debugging): ஒத்திசைவற்ற குறியீட்டை பிழைதிருத்தம் செய்வது ஒத்திசைவான குறியீட்டை பிழைதிருத்தம் செய்வதை விட சவாலானது. அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸுடன் பணிபுரியும்போது, பைப்லைன் வழியாக தரவு ஓட்டத்தைக் கண்டறியவும் சாத்தியமான சிக்கல்களை அடையாளம் காணவும் பிழைதிருத்த கருவிகள் மற்றும் நுட்பங்களைப் பயன்படுத்துவது முக்கியம்.

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

அசிங்க் இட்டரேட்டர் ஹெல்பர்ஸிலிருந்து அதிகபட்சத்தைப் பெற, பின்வரும் சிறந்த நடைமுறைகளைக் கவனியுங்கள்:

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

மேம்பட்ட நுட்பங்கள்

தனிப்பயன் ஹெல்பர்ஸை உருவாக்குதல்

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

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

முடிவுரை

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