ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಇಟರೇಟರ್ ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್ಮೆಂಟ್: ಸ್ಟ್ರೀಮ್ ಕ್ಲೀನಪ್ ಆಟೊಮೇಷನ್

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

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಜನರೇಟರ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಯ ಬಗ್ಗೆ ತಿಳಿಯುವ ಮೊದಲು, ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಜನರೇಟರ್‌ಗಳ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಪರಿಶೀಲಿಸೋಣ.

ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು

ಅಸಿಂಕ್ ಇಟರೇಟರ್ ಎನ್ನುವುದು next() ಮೆಥಡ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದೆ, ಇದು ಎರಡು ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ರಿಸಾಲ್ವ್ ಆಗುವ ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ:

• value: ಅನುಕ್ರಮದಲ್ಲಿನ ಮುಂದಿನ ಮೌಲ್ಯ.
• done: ಇಟರೇಟರ್ ಪೂರ್ಣಗೊಂಡಿದೆಯೇ ಎಂದು ಸೂಚಿಸುವ ಬೂಲಿಯನ್.

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

ಉದಾಹರಣೆ:

async function* asyncIterable() {
  yield 1;
  yield 2;
  yield 3;
}

async function main() {
  for await (const value of asyncIterable()) {
    console.log(value);
  }
}

main(); // Output: 1, 2, 3

ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು

ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ ಫಂಕ್ಷನ್‌ಗಳಾಗಿವೆ. ಅವು ಮೌಲ್ಯಗಳನ್ನು ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಉತ್ಪಾದಿಸಲು async function* ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು yield ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸುತ್ತವೆ.

ಉದಾಹರಣೆ:

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

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

main(); // Output: 1, 2, 3, 4, 5 (with 500ms delay between each value)

ಸವಾಲು: ಅಸಿಂಕ್ರೊನಸ್ ಸ್ಟ್ರೀಮ್‌ಗಳಲ್ಲಿ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ

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

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

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

ಸ್ಟ್ರೀಮ್ ಕ್ಲೀನಪ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು: ತಂತ್ರಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

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

1. try...finally ಬ್ಲಾಕ್

try...finally ಬ್ಲಾಕ್ ಸಂಪನ್ಮೂಲ ಕ್ಲೀನಪ್ ಅನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಒಂದು ಮೂಲಭೂತ ಯಾಂತ್ರಿಕತೆಯಾಗಿದೆ. try ಬ್ಲಾಕ್‌ನಲ್ಲಿ ದೋಷ ಸಂಭವಿಸಿದೆಯೇ ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸದೆ finally ಬ್ಲಾಕ್ ಯಾವಾಗಲೂ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ.

ಉದಾಹರಣೆ:

async function* readFileLines(filePath) {
  let fileHandle;
  try {
    fileHandle = await fs.open(filePath, 'r');
    const stream = fileHandle.readableWebStream();
    const reader = stream.getReader();
    let decoder = new TextDecoder();

    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        break;
      }
      yield decoder.decode(value);
    }
  } finally {
    if (fileHandle) {
      await fileHandle.close();
      console.log('File handle closed.');
    }
  }
}

async function main() {
  try{
    for await (const line of readFileLines('example.txt')) {
      console.log(line);
    }
  } catch (error) {
    console.error('Error reading file:', error);
  }
}

main();

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

2. Symbol.asyncDispose ಬಳಸುವುದು (ಸ್ಪಷ್ಟ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ ಪ್ರಸ್ತಾವನೆ)

ಸ್ಪಷ್ಟ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ ಪ್ರಸ್ತಾವನೆಯು Symbol.asyncDispose ಸಿಂಬಲ್ ಅನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ, ಇದು ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕರೆಯಲಾಗುವ ಮೆಥಡ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಇದು C# ನಲ್ಲಿನ using ಸ್ಟೇಟ್ಮೆಂಟ್ ಅಥವಾ Java ದಲ್ಲಿನ try-with-resources ಸ್ಟೇಟ್ಮೆಂಟ್‌ಗೆ ಹೋಲುತ್ತದೆ.

ಈ ವೈಶಿಷ್ಟ್ಯವು ಇನ್ನೂ ಪ್ರಸ್ತಾವನೆಯ ಹಂತದಲ್ಲಿದ್ದರೂ, ಇದು ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಗೆ ಒಂದು ಸ್ವಚ್ಛ ಮತ್ತು ಹೆಚ್ಚು ರಚನಾತ್ಮಕ ವಿಧಾನವನ್ನು ನೀಡುತ್ತದೆ.

ಪ್ರಸ್ತುತ ಪರಿಸರದಲ್ಲಿ ಇದನ್ನು ಬಳಸಲು ಪಾಲಿಫಿಲ್‌ಗಳು ಲಭ್ಯವಿವೆ.

ಉದಾಹರಣೆ (ಕಾಲ್ಪನಿಕ ಪಾಲಿಫಿಲ್ ಬಳಸಿ):

import { using } from 'resource-management-polyfill';

class MyResource {
  constructor() {
    console.log('Resource acquired.');
  }

  async [Symbol.asyncDispose]() {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simulate async cleanup
    console.log('Resource released.');
  }
}

async function main() {
  await using(new MyResource(), async (resource) => {
    console.log('Using resource...');
    // ... use the resource
  }); // Resource is automatically disposed here
  console.log('After using block.');
}

main();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ದೋಷ ಸಂಭವಿಸಿದೆಯೇ ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸದೆ, ಬ್ಲಾಕ್‌ನಿಂದ ಹೊರಬಂದಾಗ MyResource ಆಬ್ಜೆಕ್ಟ್‌ನ [Symbol.asyncDispose] ಮೆಥಡ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಎಂದು using ಸ್ಟೇಟ್ಮೆಂಟ್ ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲು ನಿರ್ಣಾಯಕ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

3. ರಿಸೋರ್ಸ್ ವ್ರ್ಯಾಪರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು

ಮತ್ತೊಂದು ವಿಧಾನವೆಂದರೆ ಸಂಪನ್ಮೂಲ ಮತ್ತು ಅದರ ಕ್ಲೀನಪ್ ಲಾಜಿಕ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ರಿಸೋರ್ಸ್ ವ್ರ್ಯಾಪರ್ ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸುವುದು. ಈ ಕ್ಲಾಸ್ ಸಂಪನ್ಮೂಲವನ್ನು ಪಡೆಯಲು ಮತ್ತು ಬಿಡುಗಡೆ ಮಾಡಲು ಮೆಥಡ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು, ಕ್ಲೀನಪ್ ಯಾವಾಗಲೂ ಸರಿಯಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

class FileStreamResource {
  constructor(filePath) {
    this.filePath = filePath;
    this.fileHandle = null;
  }

  async acquire() {
    this.fileHandle = await fs.open(this.filePath, 'r');
    console.log('File handle acquired.');
    return this.fileHandle.readableWebStream();
  }

  async release() {
    if (this.fileHandle) {
      await this.fileHandle.close();
      console.log('File handle released.');
      this.fileHandle = null;
    }
  }
}

async function* readFileLines(resource) {
  try {
    const stream = await resource.acquire();
    const reader = stream.getReader();
    let decoder = new TextDecoder();

    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        break;
      }
      yield decoder.decode(value);
    }
  } finally {
    await resource.release();
  }
}

async function main() {
  const fileResource = new FileStreamResource('example.txt');
  try {
    for await (const line of readFileLines(fileResource)) {
      console.log(line);
    }
  } catch (error) {
    console.error('Error reading file:', error);
  }
}

main();

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

4. ಲೈಬ್ರರಿಗಳು ಮತ್ತು ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವುದು

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

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

ಉದಾಹರಣೆ (ನೋಡ್.ಜೆಎಸ್ ಸ್ಟ್ರೀಮ್ಸ್ API ಬಳಸಿ):

const fs = require('node:fs');
const { pipeline } = require('node:stream/promises');
const { Transform } = require('node:stream');

async function main() {
  try {
    await pipeline(
      fs.createReadStream('example.txt'),
      new Transform({
        transform(chunk, encoding, callback) {
          this.push(chunk.toString().toUpperCase());
          callback();
        }
      }),
      fs.createWriteStream('output.txt')
    );
    console.log('Pipeline succeeded.');
  } catch (err) {
    console.error('Pipeline failed.', err);
  }
}

main();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, pipeline ಫಂಕ್ಷನ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಅವುಗಳು ಸರಿಯಾಗಿ ಮುಚ್ಚಲ್ಪಟ್ಟಿವೆ ಮತ್ತು ಯಾವುದೇ ದೋಷಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

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

ಮೂಲಭೂತ ತಂತ್ರಗಳನ್ನು ಮೀರಿ, ಹಲವಾರು ಸುಧಾರಿತ ತಂತ್ರಗಳು ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳಲ್ಲಿ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಯನ್ನು ಮತ್ತಷ್ಟು ಹೆಚ್ಚಿಸಬಹುದು.

1. ಕ್ಯಾನ್ಸಲೇಶನ್ ಟೋಕನ್‌ಗಳು

ಕ್ಯಾನ್ಸಲೇಶನ್ ಟೋಕನ್‌ಗಳು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ರದ್ದುಗೊಳಿಸಲು ಒಂದು ಯಾಂತ್ರಿಕತೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ. ಬಳಕೆದಾರರು ವಿನಂತಿಯನ್ನು ರದ್ದುಗೊಳಿಸಿದಾಗ ಅಥವಾ ಟೈಮ್‌ಔಟ್ ಸಂಭವಿಸಿದಾಗ, ಕಾರ್ಯಾಚರಣೆಯು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲು ಇದು ಉಪಯುಕ್ತವಾಗಬಹುದು.

ಉದಾಹರಣೆ:

class CancellationToken {
  constructor() {
    this.isCancelled = false;
    this.listeners = [];
  }

  cancel() {
    this.isCancelled = true;
    for (const listener of this.listeners) {
      listener();
    }
  }

  register(listener) {
    this.listeners.push(listener);
    return () => {
      this.listeners = this.listeners.filter(l => l !== listener);
    };
  }
}

async function* fetchData(url, cancellationToken) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }

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

    while (true) {
      if (cancellationToken.isCancelled) {
        console.log('Fetch cancelled.');
        reader.cancel(); // Cancel the stream
        return;
      }

      const { done, value } = await reader.read();
      if (done) {
        break;
      }

      yield decoder.decode(value);
    }
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

async function main() {
  const cancellationToken = new CancellationToken();
  const url = 'https://example.com/data'; // Replace with a valid URL

  setTimeout(() => {
    cancellationToken.cancel(); // Cancel after 3 seconds
  }, 3000);

  try {
    for await (const chunk of fetchData(url, cancellationToken)) {
      console.log(chunk);
    }
  } catch (error) {
    console.error('Error processing data:', error);
  }
}

main();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, fetchData ಜನರೇಟರ್ ಕ್ಯಾನ್ಸಲೇಶನ್ ಟೋಕನ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಟೋಕನ್ ರದ್ದುಗೊಂಡರೆ, ಜನರೇಟರ್ ಫೆಚ್ ವಿನಂತಿಯನ್ನು ರದ್ದುಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಯಾವುದೇ ಸಂಬಂಧಿತ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡುತ್ತದೆ.

2. WeakRefs ಮತ್ತು FinalizationRegistry

WeakRef ಮತ್ತು FinalizationRegistry ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳಾಗಿದ್ದು, ಇವು ಆಬ್ಜೆಕ್ಟ್ ಜೀವನಚಕ್ರವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಮತ್ತು ಆಬ್ಜೆಕ್ಟ್ ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಟ್ ಆದಾಗ ಕ್ಲೀನಪ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ. ಇತರ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಜೀವನಚಕ್ರಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಇವು ಉಪಯುಕ್ತವಾಗಬಹುದು.

ಗಮನಿಸಿ: ಈ ತಂತ್ರಗಳನ್ನು ವಿವೇಚನೆಯಿಂದ ಬಳಸಿ ಏಕೆಂದರೆ ಅವು ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಷನ್ ನಡವಳಿಕೆಯನ್ನು ಅವಲಂಬಿಸಿವೆ, ಇದು ಯಾವಾಗಲೂ ಊಹಿಸಬಹುದಾದಂತಹುದಲ್ಲ.

ಉದಾಹರಣೆ:

const registry = new FinalizationRegistry(heldValue => {
  console.log(`Cleanup: ${heldValue}`);
  // Perform cleanup here (e.g., close connections)
});

class MyObject {
  constructor(id) {
    this.id = id;
    registry.register(this, `Object ${id}`, this);
  }
}

let obj1 = new MyObject(1);
let obj2 = new MyObject(2);

// ... later, if obj1 and obj2 are no longer referenced:
// obj1 = null;
// obj2 = null;
// Garbage collection will eventually trigger the FinalizationRegistry
// and the cleanup message will be logged.

3. ಎರರ್ ಬೌಂಡರಿಗಳು ಮತ್ತು ರಿಕವರಿ

ಎರರ್ ಬೌಂಡರಿಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದರಿಂದ ದೋಷಗಳು ಹರಡುವುದನ್ನು ಮತ್ತು ಇಡೀ ಸ್ಟ್ರೀಮ್‌ಗೆ ಅಡ್ಡಿಯಾಗುವುದನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಎರರ್ ಬೌಂಡರಿಗಳು ದೋಷಗಳನ್ನು ಹಿಡಿಯಬಹುದು ಮತ್ತು ಸ್ಟ್ರೀಮ್ ಅನ್ನು ರಿಕವರ್ ಮಾಡಲು ಅಥವಾ ಸೌಮ್ಯವಾಗಿ ಕೊನೆಗೊಳಿಸಲು ಒಂದು ಯಾಂತ್ರಿಕತೆಯನ್ನು ಒದಗಿಸಬಹುದು.

ಉದಾಹರಣೆ:

async function* processData(dataStream) {
  try {
    for await (const data of dataStream) {
      try {
        // Simulate potential error during processing
        if (Math.random() < 0.1) {
          throw new Error('Processing error!');
        }
        yield `Processed: ${data}`;
      } catch (error) {
        console.error('Error processing data:', error);
        // Recover or skip the problematic data
        yield `Error: ${error.message}`;
      }
    }
  } catch (error) {
    console.error('Stream error:', error);
    // Handle the stream error (e.g., log, terminate)
  }
}

async function* generateData() {
  for (let i = 0; i < 10; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield `Data ${i}`;
  }
}

async function main() {
  for await (const result of processData(generateData())) {
    console.log(result);
  }
}

main();

ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

ಸ್ವಯಂಚಾಲಿತ ಸ್ಟ್ರೀಮ್ ಕ್ಲೀನಪ್ ನಿರ್ಣಾಯಕವಾಗಿರುವ ಕೆಲವು ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.

1. ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ಸ್ಟ್ರೀಮಿಂಗ್ ಮಾಡುವುದು

ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ಸ್ಟ್ರೀಮಿಂಗ್ ಮಾಡುವಾಗ, ಪ್ರಕ್ರಿಯೆಯ ನಂತರ ಫೈಲ್ ಹ್ಯಾಂಡಲ್ ಸರಿಯಾಗಿ ಮುಚ್ಚಲ್ಪಟ್ಟಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ. ಇದು ಫೈಲ್ ಹ್ಯಾಂಡಲ್ ಖಾಲಿಯಾಗುವುದನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ಫೈಲ್ ಅನಿರ್ದಿಷ್ಟವಾಗಿ ತೆರೆದಿರುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

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

const fs = require('node:fs');
const readline = require('node:readline');

async function processLargeCSV(filePath) {
  const fileStream = fs.createReadStream(filePath);
  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  try {
    for await (const line of rl) {
      // Process each line of the CSV file
      console.log(`Processing: ${line}`);
    }
  } finally {
    fileStream.close(); // Ensure the file stream is closed
    console.log('File stream closed.');
  }
}

async function main() {
  try{
    await processLargeCSV('large_data.csv');
  } catch (error) {
    console.error('Error processing CSV:', error);
  }
}

main();

2. ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

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

ಉದಾಹರಣೆ (ಡೇಟಾಬೇಸ್‌ನಿಂದ ಡೇಟಾವನ್ನು ತರುವುದು ಮತ್ತು ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚುವುದು):

const { Pool } = require('pg');

async function fetchDataFromDatabase(query) {
  const pool = new Pool({
    user: 'dbuser',
    host: 'localhost',
    database: 'mydb',
    password: 'dbpassword',
    port: 5432
  });

  let client;

  try {
    client = await pool.connect();
    const result = await client.query(query);
    return result.rows;
  } finally {
    if (client) {
      client.release(); // Release the connection back to the pool
      console.log('Database connection released.');
    }
  }
}

async function main() {
  try{
    const data = await fetchDataFromDatabase('SELECT * FROM mytable');
    console.log('Data:', data);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

main();

3. ನೆಟ್‌ವರ್ಕ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು

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

ಉದಾಹರಣೆ (ರಿಮೋಟ್ API ನಿಂದ ಡೇಟಾವನ್ನು ತರುವುದು ಮತ್ತು ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚುವುದು):

const https = require('node:https');

async function fetchDataFromAPI(url) {
  return new Promise((resolve, reject) => {
    const req = https.get(url, (res) => {
      let data = '';

      res.on('data', (chunk) => {
        data += chunk;
      });

      res.on('end', () => {
        resolve(JSON.parse(data));
      });
    });

    req.on('error', (error) => {
      reject(error);
    });

    req.on('close', () => {
      console.log('Connection closed.');
    });
  });
}

async function main() {
  try {
    const data = await fetchDataFromAPI('https://jsonplaceholder.typicode.com/todos/1');
    console.log('Data:', data);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

main();

ತೀರ್ಮಾನ

ದೃಢವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸಮರ್ಥ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ಸ್ಟ್ರೀಮ್ ಕ್ಲೀನಪ್ ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಜನರೇಟರ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ಮತ್ತು try...finally ಬ್ಲಾಕ್‌ಗಳು, Symbol.asyncDispose (ಲಭ್ಯವಿದ್ದಾಗ), ರಿಸೋರ್ಸ್ ವ್ರ್ಯಾಪರ್‌ಗಳು, ಕ್ಯಾನ್ಸಲೇಶನ್ ಟೋಕನ್‌ಗಳು ಮತ್ತು ಎರರ್ ಬೌಂಡರಿಗಳಂತಹ ತಂತ್ರಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ದೋಷಗಳು ಅಥವಾ ರದ್ದತಿಗಳ ಸಂದರ್ಭದಲ್ಲಿಯೂ ಸಂಪನ್ಮೂಲಗಳು ಯಾವಾಗಲೂ ಬಿಡುಗಡೆಯಾಗುತ್ತವೆ ಎಂದು ಡೆವಲಪರ್‌ಗಳು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.

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

ಹೆಚ್ಚಿನ ಕಲಿಕೆ

• ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು ಮತ್ತು ಜನರೇಟರ್‌ಗಳ ಕುರಿತು MDN ವೆಬ್ ಡಾಕ್ಸ್: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of
• ನೋಡ್.ಜೆಎಸ್ ಸ್ಟ್ರೀಮ್ಸ್ API ಡಾಕ್ಯುಮೆಂಟೇಶನ್: https://nodejs.org/api/stream.html
• RxJS ಡಾಕ್ಯುಮೆಂಟೇಶನ್: https://rxjs.dev/
• ಸ್ಪಷ್ಟ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ ಪ್ರಸ್ತಾವನೆ: https://github.com/tc39/proposal-explicit-resource-management

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