ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜರ್: ಸ್ಟ್ರೀಮ್ ರಿಸೋರ್ಸ್ ಸಿಸ್ಟಮ್

ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ಗಳು ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಪ್ರಬಲ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳು, ಅಸಿಂಕ್ ಇಟರೇಟರ್ಗಳು ಮತ್ತು ಜನರೇಟರ್ ಫಂಕ್ಷನ್ಗಳಂತಹ ವೈಶಿಷ್ಟ್ಯಗಳೊಂದಿಗೆ, ಡೆವಲಪರ್ಗಳು ದೃಢವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಸ್ಟ್ರೀಮ್ ಸಂಪನ್ಮೂಲ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಲೇಖನವು ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವ, ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸುವ ಮತ್ತು ಕೋಡ್ ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸುವ ವ್ಯವಸ್ಥೆಯನ್ನು ರಚಿಸಲು ಈ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೇಗೆ ಬಳಸಿಕೊಳ್ಳುವುದು ಎಂಬುದನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ನ ಅಗತ್ಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್ಗಳು ಅಥವಾ ಬಾಹ್ಯ API ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವ ಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ, ಪರಿಣಾಮಕಾರಿ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ ಬಹಳ ಮುಖ್ಯ. ನಿರ್ವಹಿಸದ ಸಂಪನ್ಮೂಲಗಳು ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳು, ಮೆಮೊರಿ ಲೀಕ್ಗಳು ಮತ್ತು ಕಳಪೆ ಬಳಕೆದಾರ ಅನುಭವಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು. ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ ನಿರ್ಣಾಯಕವಾಗಿರುವ ಸಾಮಾನ್ಯ ಸನ್ನಿವೇಶಗಳು ಇಲ್ಲಿವೆ:

• ದೊಡ್ಡ ಫೈಲ್ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು: ದೊಡ್ಡ ಫೈಲ್ಗಳನ್ನು ಓದುವುದು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು, ವಿಶೇಷವಾಗಿ ಬ್ರೌಸರ್ ಪರಿಸರದಲ್ಲಿ, ಮುಖ್ಯ ಥ್ರೆಡ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ವಹಣೆ ಅಗತ್ಯವಿದೆ.
• API ಗಳಿಂದ ಡೇಟಾವನ್ನು ಸ್ಟ್ರೀಮಿಂಗ್ ಮಾಡುವುದು: ದೊಡ್ಡ ಡೇಟಾಸೆಟ್ಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ API ಗಳಿಂದ ಡೇಟಾವನ್ನು ಪಡೆದುಕೊಳ್ಳುವುದನ್ನು ಕ್ಲೈಂಟ್ ಅನ್ನು ಮುಳುಗಿಸುವುದನ್ನು ತಡೆಯಲು ಸ್ಟ್ರೀಮಿಂಗ್ ರೀತಿಯಲ್ಲಿ ನಿರ್ವಹಿಸಬೇಕು.
• ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು: ಅಪ್ಲಿಕೇಶನ್ ಪ್ರತಿಕ್ರಿಯೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಅತ್ಯಗತ್ಯ.
• ಈವೆಂಟ್-ಚಾಲಿತ ಸಿಸ್ಟಮ್ಗಳು: ಈವೆಂಟ್ ಸ್ಟ್ರೀಮ್ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ಈವೆಂಟ್ ಕೇಳುಗರು ಸರಿಯಾಗಿ ಸ್ವಚ್ಛಗೊಳಿಸಲ್ಪಟ್ಟಿದ್ದಾರೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಮೆಮೊರಿ ಲೀಕ್ಗಳನ್ನು ತಡೆಗಟ್ಟಲು ಬಹಳ ಮುಖ್ಯ.

ಉತ್ತಮವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣಾ ವ್ಯವಸ್ಥೆಯು ಸಂಪನ್ಮೂಲಗಳು ಅಗತ್ಯವಿರುವಾಗ ಸ್ವಾಧೀನಪಡಿಸಿಕೊಳ್ಳುವುದನ್ನು, ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸುವುದನ್ನು ಮತ್ತು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ತಕ್ಷಣವೇ ಬಿಡುಗಡೆ ಮಾಡುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಅಪ್ಲಿಕೇಶನ್ನ ಹೆಜ್ಜೆಗುರುತನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ ಮತ್ತು ಸ್ಥಿರತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳನ್ನು ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ

ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳು, ಅಂದರೆ Array.prototype.values() ವಿಧಾನಗಳು, ಪುನರಾವರ್ತಿತ ಡೇಟಾ ರಚನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಪ್ರಬಲ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ವಿಧಾನಗಳು ಇಟರೇಟರ್ಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಇದು ಘೋಷಣಾತ್ಮಕ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ರೀತಿಯಲ್ಲಿ ಡೇಟಾವನ್ನು ಪರಿವರ್ತಿಸಲು, ಫಿಲ್ಟರ್ ಮಾಡಲು ಮತ್ತು ಬಳಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಪ್ರಸ್ತುತ ಹಂತ 4 ರ ಪ್ರಸ್ತಾಪವಾಗಿರುವುದರಿಂದ ಮತ್ತು ಎಲ್ಲಾ ಬ್ರೌಸರ್ಗಳಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿ ಬೆಂಬಲಿತವಾಗಿಲ್ಲದಿದ್ದರೂ, ಅವುಗಳನ್ನು ಪಾಲಿಫಿಲ್ ಮಾಡಬಹುದು ಅಥವಾ ಬ್ಯಾಬೆಲ್ನಂತಹ ಟ್ರಾನ್ಸ್ಪೈಲರ್ಗಳೊಂದಿಗೆ ಬಳಸಬಹುದು. ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳು ಇವುಗಳನ್ನು ಒಳಗೊಂಡಿವೆ:

• map(): ಇಟರೇಟರ್ನ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ಪರಿವರ್ತಿಸುತ್ತದೆ.
• filter(): ನಿರ್ದಿಷ್ಟ ಮುನ್ಸೂಚನೆಯ ಆಧಾರದ ಮೇಲೆ ಅಂಶಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುತ್ತದೆ.
• take(): ಮೊದಲ n ಅಂಶಗಳೊಂದಿಗೆ ಹೊಸ ಇಟರೇಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• drop(): ಮೊದಲ n ಅಂಶಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುವ ಹೊಸ ಇಟರೇಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
• reduce(): ಇಟರೇಟರ್ನ ಮೌಲ್ಯಗಳನ್ನು ಒಂದೇ ಫಲಿತಾಂಶವಾಗಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ.
• forEach(): ಪ್ರತಿ ಅಂಶಕ್ಕೂ ಒಮ್ಮೆ ಒದಗಿಸಲಾದ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.

ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳು ಅಸಮಕಾಲಿಕ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿವೆ ಏಕೆಂದರೆ ಅವು ಡೇಟಾವನ್ನು ಸೋಮಾರಿಯಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದರರ್ಥ ಡೇಟಾ ಅಗತ್ಯವಿದ್ದಾಗ ಮಾತ್ರ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ, ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ.

ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳೊಂದಿಗೆ ಸ್ಟ್ರೀಮ್ ರಿಸೋರ್ಸ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು

ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರೀಮ್ ರಿಸೋರ್ಸ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಎಂದು ನೋಡೋಣ. ಫೈಲ್ ಸ್ಟ್ರೀಮ್ನಿಂದ ಡೇಟಾವನ್ನು ಓದುವುದು ಮತ್ತು ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮೂಲ ಉದಾಹರಣೆಯೊಂದಿಗೆ ನಾವು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ.

ಉದಾಹರಣೆ: ಫೈಲ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಓದುವುದು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು

ನೀವು ದೊಡ್ಡ ಫೈಲ್ ಅನ್ನು ಓದಲು, ಪ್ರತಿ ಸಾಲನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಮಾಹಿತಿಯನ್ನು ಹೊರತೆಗೆಯಲು ಅಗತ್ಯವಿರುವ ಸನ್ನಿವೇಶವನ್ನು ಪರಿಗಣಿಸಿ. ಸಾಂಪ್ರದಾಯಿಕ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ಸಂಪೂರ್ಣ ಫೈಲ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡಬಹುದು, ಅದು ಅನಕ್ಷಮಕಾರಿಯಾಗಬಹುದು. ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳು ಮತ್ತು ಅಸಮಕಾಲಿಕ ಇಟರೇಟರ್ಗಳೊಂದಿಗೆ, ನೀವು ಫೈಲ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸಾಲಿನಿಂದ ಸಾಲಿಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು.

ಮೊದಲಿಗೆ, ಫೈಲ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸಾಲಿನಿಂದ ಸಾಲಿಗೆ ಓದುವ ಅಸಮಕಾಲಿಕ ಜನರೇಟರ್ ಫಂಕ್ಷನ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ:

async function* readFileLines(filePath) {
 const fileStream = fs.createReadStream(filePath, { encoding: 'utf8' });
 const rl = readline.createInterface({
  input: fileStream,
  crlfDelay: Infinity
 });

 try {
  for await (const line of rl) {
   yield line;
  }
 } finally {
  // Ensure the file stream is closed, even if errors occur
  fileStream.destroy();
 }
}

ಈ ಫಂಕ್ಷನ್ ನೋಡ್.ಜೆಎಸ್ನ fs ಮತ್ತು readline ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಬಳಸಿ ಓದುವ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಫೈಲ್ನ ಪ್ರತಿ ಸಾಲಿನ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ. finally ಬ್ಲಾಕ್ ಓದುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ದೋಷ ಸಂಭವಿಸಿದರೂ ಫೈಲ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸರಿಯಾಗಿ ಮುಚ್ಚಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಯ ನಿರ್ಣಾಯಕ ಭಾಗವಾಗಿದೆ.

ಮುಂದೆ, ಫೈಲ್ ಸ್ಟ್ರೀಮ್ನಿಂದ ಸಾಲುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಾವು ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳನ್ನು ಬಳಸಬಹುದು:

async function processFile(filePath) {
 const lines = readFileLines(filePath);

 // Simulate Iterator Helpers
 async function* map(iterable, transform) {
  for await (const item of iterable) {
   yield transform(item);
  }
 }

 async function* filter(iterable, predicate) {
  for await (const item of iterable) {
   if (predicate(item)) {
    yield item;
   }
 }


 // Using "Iterator Helpers" (simulated here)
 const processedLines = map(filter(lines, line => line.length > 0), line => line.toUpperCase());

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

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಮೊದಲು ಖಾಲಿ ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಉಳಿದ ಸಾಲುಗಳನ್ನು ದೊಡ್ಡಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತೇವೆ. ಈ ಸಿಮ್ಯುಲೇಟೆಡ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ ಫಂಕ್ಷನ್ಗಳು ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸೋಮಾರಿಯಾಗಿ ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತವೆ. for await...of ಲೂಪ್ ಸಂಸ್ಕರಿಸಿದ ಸಾಲುಗಳನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಕನ್ಸೋಲ್ಗೆ ಲಾಗ್ ಮಾಡುತ್ತದೆ.

ಈ ವಿಧಾನದ ಪ್ರಯೋಜನಗಳು

• ಮೆಮೊರಿ ದಕ್ಷತೆ: ಫೈಲ್ ಅನ್ನು ಸಾಲಿನಿಂದ ಸಾಲಿಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ, ಇದು ಅಗತ್ಯವಿರುವ ಮೆಮೊರಿಯ ಪ್ರಮಾಣವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
• ಸುಧಾರಿತ ಕಾರ್ಯಕ್ಷಮತೆ: ಸೋಮಾರಿಯಾದ ಮೌಲ್ಯಮಾಪನವು ಅಗತ್ಯವಿರುವ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ಸಂಪನ್ಮೂಲ ಸುರಕ್ಷತೆ: ದೋಷಗಳು ಸಂಭವಿಸಿದರೂ ಸಹ, finally ಬ್ಲಾಕ್ ಫೈಲ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸರಿಯಾಗಿ ಮುಚ್ಚಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ಓದಲು ಸುಲಭ: ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳು ಸಂಕೀರ್ಣ ಡೇಟಾ ರೂಪಾಂತರಗಳನ್ನು ವ್ಯಕ್ತಪಡಿಸಲು ಘೋಷಣಾತ್ಮಕ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಸುಧಾರಿತ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣಾ ತಂತ್ರಗಳು

ಮೂಲ ಫೈಲ್ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಿಕೆಯ ಹೊರತಾಗಿ, ಹೆಚ್ಚು ಸುಧಾರಿತ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣಾ ತಂತ್ರಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳನ್ನು ಬಳಸಬಹುದು. ಕೆಲವು ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

1. ದರ ಮಿತಿ

ಬಾಹ್ಯ API ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವಾಗ, API ಬಳಕೆಯ ಮಿತಿಗಳನ್ನು ಮೀರದಂತೆ ತಡೆಯಲು ದರ ಮಿತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಅವಶ್ಯಕ. API ಗೆ ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸುವ ದರವನ್ನು ನಿಯಂತ್ರಿಸಲು ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳನ್ನು ಬಳಸಬಹುದು.

async function* rateLimit(iterable, delay) {
 for await (const item of iterable) {
  yield item;
  await new Promise(resolve => setTimeout(resolve, delay));
 }
}

async function* fetchFromAPI(urls) {
 for (const url of urls) {
  const response = await fetch(url);
  if (!response.ok) {
   throw new Error(`HTTP error! status: ${response.status}`);
  }
  yield await response.json();
 }
}

async function processAPIResponses(urls, rateLimitDelay) {
 const apiResponses = fetchFromAPI(urls);
 const rateLimitedResponses = rateLimit(apiResponses, rateLimitDelay);

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

// Example usage:
const apiUrls = [
 'https://api.example.com/data1',
 'https://api.example.com/data2',
 'https://api.example.com/data3'
];

// Set a rate limit of 500ms between requests
await processAPIResponses(apiUrls, 500);

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, rateLimit ಫಂಕ್ಷನ್ ಪುನರಾವರ್ತಿತದಿಂದ ಹೊರಸೂಸಲ್ಪಟ್ಟ ಪ್ರತಿ ಐಟಂ ನಡುವೆ ವಿಳಂಬವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಇದು API ವಿನಂತಿಗಳನ್ನು ನಿಯಂತ್ರಿತ ದರದಲ್ಲಿ ಕಳುಹಿಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. fetchFromAPI ಫಂಕ್ಷನ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ URL ಗಳಿಂದ ಡೇಟಾವನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು JSON ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ನೀಡುತ್ತದೆ. processAPIResponses ಈ ಫಂಕ್ಷನ್ಗಳನ್ನು ಸಂಯೋಜಿಸಿ ದರ ಮಿತಿಯೊಂದಿಗೆ API ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. ಸರಿಯಾದ ದೋಷ ನಿರ್ವಹಣೆಯು (ಉದಾಹರಣೆಗೆ, response.ok ಅನ್ನು ಪರಿಶೀಲಿಸುವುದು) ಸಹ ಒಳಗೊಂಡಿದೆ.

2. ರಿಸೋರ್ಸ್ ಪೂಲಿಂಗ್

ರಿಸೋರ್ಸ್ ಪೂಲಿಂಗ್ ಎಂದರೆ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪದೇ ಪದೇ ರಚಿಸುವ ಮತ್ತು ನಾಶಮಾಡುವ ಓವರ್ಹೆಡ್ ಅನ್ನು ತಪ್ಪಿಸಲು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಸಂಪನ್ಮೂಲಗಳ ಪೂಲ್ ಅನ್ನು ರಚಿಸುವುದು. ಪೂಲ್ನಿಂದ ಸಂಪನ್ಮೂಲಗಳ ಸ್ವಾಧೀನ ಮತ್ತು ಬಿಡುಗಡೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳನ್ನು ಬಳಸಬಹುದು.

ಈ ಉದಾಹರಣೆಯು ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳಿಗಾಗಿ ಸರಳೀಕೃತ ಸಂಪನ್ಮೂಲ ಪೂಲ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ:

class ConnectionPool {
 constructor(size, createConnection) {
  this.size = size;
  this.createConnection = createConnection;
  this.pool = [];
  this.available = [];
  this.initializePool();
 }

 async initializePool() {
  for (let i = 0; i < this.size; i++) {
   const connection = await this.createConnection();
   this.pool.push(connection);
   this.available.push(connection);
  }
 }

 async acquire() {
  if (this.available.length > 0) {
   return this.available.pop();
  }
  // Optionally handle the case where no connections are available, e.g., wait or throw an error.
  throw new Error("No available connections in the pool.");
 }

 release(connection) {
  this.available.push(connection);
 }

 async useConnection(callback) {
  const connection = await this.acquire();
  try {
   return await callback(connection);
  } finally {
   this.release(connection);
  }
 }
}

// Example Usage (assuming you have a function to create a database connection)
async function createDBConnection() {
 // Simulate creating a database connection
 return new Promise(resolve => {
  setTimeout(() => {
   resolve({ id: Math.random(), query: (sql) => Promise.resolve(`Executed: ${sql}`) }); // Simulate a connection object
  }, 100);
 });
}

async function main() {
 const poolSize = 5;
 const pool = new ConnectionPool(poolSize, createDBConnection);

 // Wait for the pool to initialize
 await new Promise(resolve => setTimeout(resolve, 100 * poolSize));

 // Use the connection pool to execute queries
 for (let i = 0; i < 10; i++) {
  try {
   const result = await pool.useConnection(async (connection) => {
    return await connection.query(`SELECT * FROM users WHERE id = ${i}`);
   });
   console.log(`Query ${i} Result: ${result}`);
  } catch (error) {
   console.error(`Error executing query ${i}: ${error.message}`);
  }
 }
}

main();

ಈ ಉದಾಹರಣೆಯು ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳ ಪೂಲ್ ಅನ್ನು ನಿರ್ವಹಿಸುವ ConnectionPool ಕ್ಲಾಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. acquire ವಿಧಾನವು ಪೂಲ್ನಿಂದ ಸಂಪರ್ಕವನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ ಮತ್ತು release ವಿಧಾನವು ಸಂಪರ್ಕವನ್ನು ಪೂಲ್ಗೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. useConnection ವಿಧಾನವು ಸಂಪರ್ಕವನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ, ಸಂಪರ್ಕದೊಂದಿಗೆ ಕಾಲ್ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಸಂಪರ್ಕವನ್ನು ಬಿಡುಗಡೆ ಮಾಡುತ್ತದೆ, ಸಂಪರ್ಕಗಳು ಯಾವಾಗಲೂ ಪೂಲ್ಗೆ ಹಿಂತಿರುಗಿಸಲ್ಪಡುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಡೇಟಾಬೇಸ್ ಸಂಪನ್ಮೂಲಗಳ ದಕ್ಷ ಬಳಕೆಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ ಮತ್ತು ಪದೇ ಪದೇ ಹೊಸ ಸಂಪರ್ಕಗಳನ್ನು ರಚಿಸುವ ಓವರ್ಹೆಡ್ ಅನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

3. ಥ್ರೊಟ್ಲಿಂಗ್

ಥ್ರೊಟ್ಲಿಂಗ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಮುಳುಗಿಸುವುದನ್ನು ತಡೆಯಲು ಸಮಕಾಲೀನ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ. ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಥ್ರೊಟಲ್ ಮಾಡಲು ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳನ್ನು ಬಳಸಬಹುದು.

async function* throttle(iterable, concurrency) {
 const queue = [];
 let running = 0;
 let iterator = iterable[Symbol.asyncIterator]();

 async function execute() {
  if (queue.length === 0 || running >= concurrency) {
   return;
  }

  running++;
  const { value, done } = queue.shift();
  try {
   yield await value;
  } finally {
   running--;
   if (!done) {
    execute(); // Continue processing if not done
   }
  }
  if (queue.length > 0) {
   execute(); // Start another task if available
  }
 }

 async function fillQueue() {
  while (running < concurrency) {
   const { value, done } = await iterator.next();
   if (done) {
    return;
   }
   queue.push({ value, done });
   execute();
  }
 }

 await fillQueue();
}

async function* generateTasks(count) {
 for (let i = 1; i <= count; i++) {
  yield new Promise(resolve => {
   const delay = Math.random() * 1000;
   setTimeout(() => {
    console.log(`Task ${i} completed after ${delay}ms`);
    resolve(`Result from task ${i}`);
   }, delay);
  });
 }
}

async function main() {
 const taskCount = 10;
 const concurrencyLimit = 3;

 const tasks = generateTasks(taskCount);
 const throttledTasks = throttle(tasks, concurrencyLimit);

 for await (const result of throttledTasks) {
  console.log(`Received: ${result}`);
 }
 console.log('All tasks completed');
}

main();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, throttle ಫಂಕ್ಷನ್ ಸಮಕಾಲೀನ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ. ಇದು ಬಾಕಿ ಉಳಿದಿರುವ ಕಾರ್ಯಗಳ ಸರದಿಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸಮಕಾಲೀನ ಮಿತಿಯವರೆಗೆ ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. generateTasks ಫಂಕ್ಷನ್ ಯಾದೃಚ್ಛಿಕ ವಿಳಂಬದ ನಂತರ ಪರಿಹರಿಸುವ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳ ಗುಂಪನ್ನು ರಚಿಸುತ್ತದೆ. main ಫಂಕ್ಷನ್ ಈ ಫಂಕ್ಷನ್ಗಳನ್ನು ಸಂಯೋಜಿಸಿ ಕಾರ್ಯಗಳನ್ನು ಥ್ರೊಟ್ಲಿಂಗ್ನೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಇದು ಸಿಸ್ಟಮ್ ತುಂಬಾ ಸಮಕಾಲೀನ ಕಾರ್ಯಾಚರಣೆಗಳಿಂದ ಮುಳುಗದಂತೆ ತಡೆಯುತ್ತದೆ.

ದೋಷ ನಿರ್ವಹಣೆ

ಯಾವುದೇ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣಾ ವ್ಯವಸ್ಥೆಯ ಅತ್ಯಗತ್ಯ ಭಾಗವೆಂದರೆ ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆ. ಅಸಮಕಾಲಿಕ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಸಂಪನ್ಮೂಲ ಸೋರಿಕೆಗಳನ್ನು ತಡೆಗಟ್ಟಲು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ದೋಷಗಳನ್ನು ಸಭ್ಯವಾಗಿ ನಿರ್ವಹಿಸುವುದು ಮುಖ್ಯ. ದೋಷ ಸಂಭವಿಸಿದರೂ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸರಿಯಾಗಿ ಸ್ವಚ್ಛಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು try-catch-finally ಬ್ಲಾಕ್ಗಳನ್ನು ಬಳಸಿ.

ಉದಾಹರಣೆಗೆ, ಮೇಲಿನ readFileLines ಫಂಕ್ಷನ್ನಲ್ಲಿ, ಓದುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ದೋಷ ಸಂಭವಿಸಿದರೂ ಸಹ, finally ಬ್ಲಾಕ್ ಫೈಲ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಮುಚ್ಚಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ತೀರ್ಮಾನ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳು ಅಸಮಕಾಲಿಕ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ಗಳಲ್ಲಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಪ್ರಬಲ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅಸಿಂಕ್ ಇಟರೇಟರ್ಗಳು ಮತ್ತು ಜನರೇಟರ್ ಫಂಕ್ಷನ್ಗಳಂತಹ ವೈಶಿಷ್ಟ್ಯಗಳೊಂದಿಗೆ ಇಟರೇಟರ್ ಹೆಲ್ಪರ್ಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್ಗಳು ದೃಢವಾದ, ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಸ್ಟ್ರೀಮ್ ಸಂಪನ್ಮೂಲ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ಗಳ ಕಾರ್ಯಕ್ಷಮತೆ, ಸ್ಥಿರತೆ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸರಿಯಾದ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ ಬಹಳ ಮುಖ್ಯ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್ಗಳು ಅಥವಾ ಬಾಹ್ಯ API ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವ ಅಪ್ಲಿಕೇಶನ್ಗಳು. ದರ ಮಿತಿ, ಸಂಪನ್ಮೂಲ ಪೂಲಿಂಗ್ ಮತ್ತು ಥ್ರೊಟ್ಲಿಂಗ್ನಂತಹ ತಂತ್ರಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ, ನೀವು ಸಂಪನ್ಮೂಲ ಬಳಕೆಯನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸಬಹುದು, ಅಡಚಣೆಗಳನ್ನು ತಡೆಯಬಹುದು ಮತ್ತು ಒಟ್ಟಾರೆ ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಸುಧಾರಿಸಬಹುದು.