M

MLOG

ಕನ್ನಡ

`using` ಮತ್ತು `await using` ನೊಂದಿಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಹೊಸ ಎಕ್ಸ್‌ಪ್ಲಿಸಿಟ್ ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಅನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ. ಕ್ಲೀನಪ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು, ರಿಸೋರ್ಸ್ ಲೀಕ್‌ಗಳನ್ನು ತಡೆಯಲು ಮತ್ತು ಸ್ವಚ್ಛ, ದೃಢವಾದ ಕೋಡ್ ಬರೆಯಲು ಕಲಿಯಿರಿ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಹೊಸ ಸೂಪರ್‌ಪವರ್: ಎಕ್ಸ್‌ಪ್ಲಿಸಿಟ್ ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್‌ ಕುರಿತು ಆಳವಾದ ನೋಟ

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

ಈ ಭಾಷೆಗೆ ಒಂದು ಹೊಸ ಮಾದರಿಯ ಬದಲಾವಣೆ ಬಂದಿದೆ: ಎಕ್ಸ್‌ಪ್ಲಿಸಿಟ್ ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ (ERM). ECMAScript 2024 (ES2024) ಸ್ಟ್ಯಾಂಡರ್ಡ್‌ನಲ್ಲಿ ಅಂತಿಮಗೊಳಿಸಲಾದ ಈ ಶಕ್ತಿಯುತ ವೈಶಿಷ್ಟ್ಯವು, C#, ಪೈಥಾನ್, ಮತ್ತು ಜಾವಾದಂತಹ ಭಾಷೆಗಳಲ್ಲಿನ ಇದೇ ರೀತಿಯ ರಚನೆಗಳಿಂದ ಪ್ರೇರಿತವಾಗಿದೆ. ಇದು ಸಂಪನ್ಮೂಲಗಳ ಕ್ಲೀನಪ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಘೋಷಣಾತ್ಮಕ ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ಮಾರ್ಗವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಹೊಸ using ಮತ್ತು await using ಕೀವರ್ಡ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಈಗ ಈ ಸಾರ್ವಕಾಲಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸವಾಲಿಗೆ ಹೆಚ್ಚು ಸುಂದರ ಮತ್ತು ಸುರಕ್ಷಿತ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತದೆ.

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

ಹಳೆಯ ಪದ್ಧತಿ: ಮ್ಯಾನುಯಲ್ ರಿಸೋರ್ಸ್ ಕ್ಲೀನಪ್‌ನ ಸವಾಲುಗಳು

ನಾವು ಹೊಸ ವ್ಯವಸ್ಥೆಯ ಸೊಬಗನ್ನು ಶ್ಲಾಘಿಸುವ ಮೊದಲು, ಹಳೆಯದರ ನೋವಿನ ಅಂಶಗಳನ್ನು ನಾವು ಮೊದಲು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಯ ಕ್ಲಾಸಿಕ್ ಮಾದರಿಯು try...finally ಬ್ಲಾಕ್ ಆಗಿದೆ.

ತರ್ಕವು ಸರಳವಾಗಿದೆ: ನೀವು try ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಸಂಪನ್ಮೂಲವನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ, ಮತ್ತು ನೀವು ಅದನ್ನು finally ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಬಿಡುಗಡೆ ಮಾಡುತ್ತೀರಿ. finally ಬ್ಲಾಕ್, try ಬ್ಲಾಕ್‌ನಲ್ಲಿನ ಕೋಡ್ ಯಶಸ್ವಿಯಾಗಲಿ, ವಿಫಲವಾಗಲಿ ಅಥವಾ ಅಕಾಲಿಕವಾಗಿ ಹಿಂತಿರುಗಲಿ, ಅದರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ.

ಒಂದು ಸಾಮಾನ್ಯ ಸರ್ವರ್-ಸೈಡ್ ಸನ್ನಿವೇಶವನ್ನು ಪರಿಗಣಿಸೋಣ: ಫೈಲ್ ತೆರೆಯುವುದು, ಅದಕ್ಕೆ ಕೆಲವು ಡೇಟಾವನ್ನು ಬರೆಯುವುದು, ಮತ್ತು ನಂತರ ಫೈಲ್ ಮುಚ್ಚಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು.

ಉದಾಹರಣೆ: try...finally ನೊಂದಿಗೆ ಒಂದು ಸರಳ ಫೈಲ್ ಕಾರ್ಯಾಚರಣೆ


const fs = require('fs/promises');

async function processFile(filePath, data) {
  let fileHandle;
  try {
    console.log('Opening file...');
    fileHandle = await fs.open(filePath, 'w');
    console.log('Writing to file...');
    await fileHandle.write(data);
    console.log('Data written successfully.');
  } catch (error) {
    console.error('An error occurred during file processing:', error);
  } finally {
    if (fileHandle) {
      console.log('Closing file...');
      await fileHandle.close();
    }
  }
}

ಈ ಕೋಡ್ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಆದರೆ ಇದು ಹಲವಾರು ದೌರ್ಬಲ್ಯಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸುತ್ತದೆ:

ಈಗ, ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕ ಮತ್ತು ಫೈಲ್ ಹ್ಯಾಂಡಲ್‌ನಂತಹ ಬಹು ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಕೋಡ್ ಶೀಘ್ರವಾಗಿ ಗೂಡುಕಟ್ಟಿದ ಗೊಂದಲವಾಗುತ್ತದೆ:


async function logQueryResultToFile(query, filePath) {
  let dbConnection;
  try {
    dbConnection = await getDbConnection();
    const result = await dbConnection.query(query);

    let fileHandle;
    try {
      fileHandle = await fs.open(filePath, 'w');
      await fileHandle.write(JSON.stringify(result));
    } finally {
      if (fileHandle) {
        await fileHandle.close();
      }
    }
  } finally {
    if (dbConnection) {
      await dbConnection.release();
    }
  }
}

ಈ ಗೂಡುಕಟ್ಟುವಿಕೆ ನಿರ್ವಹಿಸಲು ಮತ್ತು ವಿಸ್ತರಿಸಲು ಕಷ್ಟಕರವಾಗಿದೆ. ಇದು ಉತ್ತಮವಾದ ಅಮೂರ್ತತೆಯ ಅಗತ್ಯವಿದೆ ಎಂಬುದರ ಸ್ಪಷ್ಟ ಸಂಕೇತವಾಗಿದೆ. ಎಕ್ಸ್‌ಪ್ಲಿಸಿಟ್ ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಿದ್ದು ನಿಖರವಾಗಿ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು.

ಒಂದು ಮಾದರಿ ಬದಲಾವಣೆ: ಎಕ್ಸ್‌ಪ್ಲಿಸಿಟ್ ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್‌ನ ತತ್ವಗಳು

ಎಕ್ಸ್‌ಪ್ಲಿಸಿಟ್ ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ (ERM) ಒಂದು ಸಂಪನ್ಮೂಲ ಆಬ್ಜೆಕ್ಟ್ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರನ್‌ಟೈಮ್ ನಡುವೆ ಒಪ್ಪಂದವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಮೂಲ ಕಲ್ಪನೆ ಸರಳವಾಗಿದೆ: ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಅದನ್ನು ಹೇಗೆ ಸ್ವಚ್ಛಗೊಳಿಸಬೇಕು ಎಂದು ಘೋಷಿಸಬಹುದು, ಮತ್ತು ಆ ಆಬ್ಜೆಕ್ಟ್ ಸ್ಕೋಪ್‌ನಿಂದ ಹೊರಗೆ ಹೋದಾಗ ಭಾಷೆಯು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಆ ಕ್ಲೀನಪ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಇದನ್ನು ಎರಡು ಮುಖ್ಯ ಘಟಕಗಳ ಮೂಲಕ ಸಾಧಿಸಲಾಗುತ್ತದೆ:

  1. ಡಿಸ್ಪೋಸಬಲ್ ಪ್ರೋಟೋಕಾಲ್: ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ತಮ್ಮದೇ ಆದ ಕ್ಲೀನಪ್ ತರ್ಕವನ್ನು ವಿಶೇಷ ಚಿಹ್ನೆಗಳನ್ನು ಬಳಸಿ ವ್ಯಾಖ್ಯಾನಿಸಲು ಒಂದು ಪ್ರಮಾಣಿತ ಮಾರ್ಗ: ಸಿಂಕ್ರೊನಸ್ ಕ್ಲೀನಪ್‌ಗಾಗಿ Symbol.dispose ಮತ್ತು ಅಸಿಂಕ್ರೊನಸ್ ಕ್ಲೀನಪ್‌ಗಾಗಿ Symbol.asyncDispose.
  2. using ಮತ್ತು await using ಘೋಷಣೆಗಳು: ಹೊಸ ಕೀವರ್ಡ್‌ಗಳು ಒಂದು ಸಂಪನ್ಮೂಲವನ್ನು ಬ್ಲಾಕ್ ಸ್ಕೋಪ್‌ಗೆ ಬಂಧಿಸುತ್ತವೆ. ಬ್ಲಾಕ್‌ನಿಂದ ಹೊರಬಂದಾಗ, ಸಂಪನ್ಮೂಲದ ಕ್ಲೀನಪ್ ವಿಧಾನವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ.

ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು: `Symbol.dispose` ಮತ್ತು `Symbol.asyncDispose`

ERM ನ ಹೃದಯಭಾಗದಲ್ಲಿ ಎರಡು ಹೊಸ ಸುಪರಿಚಿತ ಚಿಹ್ನೆಗಳಿವೆ. ಈ ಚಿಹ್ನೆಗಳಲ್ಲಿ ಒಂದನ್ನು ತನ್ನ ಕೀಲಿಯಾಗಿ ಹೊಂದಿರುವ ವಿಧಾನವನ್ನು ಹೊಂದಿರುವ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು "ಡಿಸ್ಪೋಸಬಲ್ ರಿಸೋರ್ಸ್" ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.

`Symbol.dispose` ನೊಂದಿಗೆ ಸಿಂಕ್ರೊನಸ್ ಡಿಸ್ಪೋಸಲ್

Symbol.dispose ಚಿಹ್ನೆಯು ಸಿಂಕ್ರೊನಸ್ ಕ್ಲೀನಪ್ ವಿಧಾನವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಇದು ಕ್ಲೀನಪ್‌ಗೆ ಯಾವುದೇ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಅಗತ್ಯವಿಲ್ಲದ ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ ಫೈಲ್ ಹ್ಯಾಂಡಲ್ ಅನ್ನು ಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಮುಚ್ಚುವುದು ಅಥವಾ ಇನ್-ಮೆಮೊರಿ ಲಾಕ್ ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವುದು.

ತನ್ನನ್ನು ತಾನೇ ಸ್ವಚ್ಛಗೊಳಿಸುವ ತಾತ್ಕಾಲಿಕ ಫೈಲ್‌ಗಾಗಿ ಒಂದು ವ್ರ್ಯಾಪರ್ ಅನ್ನು ರಚಿಸೋಣ.


const fs = require('fs');
const path = require('path');

class TempFile {
  constructor(content) {
    this.path = path.join(__dirname, `temp_${Date.now()}.txt`);
    fs.writeFileSync(this.path, content);
    console.log(`Created temp file: ${this.path}`);
  }

  // This is the synchronous disposable method
  [Symbol.dispose]() {
    console.log(`Disposing temp file: ${this.path}`);
    try {
      fs.unlinkSync(this.path);
      console.log('File deleted successfully.');
    } catch (error) {
      console.error(`Failed to delete file: ${this.path}`, error);
      // It's important to handle errors within dispose, too!
    }
  }
}

`TempFile` ನ ಯಾವುದೇ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಈಗ ಡಿಸ್ಪೋಸಬಲ್ ಸಂಪನ್ಮೂಲವಾಗಿದೆ. ಇದು ಡಿಸ್ಕ್‌ನಿಂದ ಫೈಲ್ ಅನ್ನು ಅಳಿಸುವ ತರ್ಕವನ್ನು ಹೊಂದಿರುವ `Symbol.dispose` ಕೀಲಿ ಹೊಂದಿದ ವಿಧಾನವನ್ನು ಹೊಂದಿದೆ.

`Symbol.asyncDispose` ನೊಂದಿಗೆ ಅಸಿಂಕ್ರೊನಸ್ ಡಿಸ್ಪೋಸಲ್

ಅನೇಕ ಆಧುನಿಕ ಕ್ಲೀನಪ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿರುತ್ತವೆ. ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚುವುದು ನೆಟ್‌ವರ್ಕ್ ಮೂಲಕ `QUIT` ಆಜ್ಞೆಯನ್ನು ಕಳುಹಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರಬಹುದು, ಅಥವಾ ಸಂದೇಶ ಸರದಿಯ ಕ್ಲೈಂಟ್ ತನ್ನ ಹೊರಹೋಗುವ ಬಫರ್ ಅನ್ನು ಫ್ಲಶ್ ಮಾಡಬೇಕಾಗಬಹುದು. ಈ ಸನ್ನಿವೇಶಗಳಿಗಾಗಿ, ನಾವು `Symbol.asyncDispose` ಅನ್ನು ಬಳಸುತ್ತೇವೆ.

`Symbol.asyncDispose` ಗೆ ಸಂಬಂಧಿಸಿದ ವಿಧಾನವು `Promise` ಅನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು (ಅಥವಾ `async` ಫಂಕ್ಷನ್ ಆಗಿರಬೇಕು).

ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಪೂಲ್‌ಗೆ ಹಿಂತಿರುಗಿಸಬೇಕಾದ ಅಣಕು ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕವನ್ನು ಮಾದರಿ ಮಾಡೋಣ.


// A mock database pool
const mockDbPool = {
  getConnection: () => {
    console.log('DB connection acquired.');
    return new MockDbConnection();
  }
};

class MockDbConnection {
  query(sql) {
    console.log(`Executing query: ${sql}`);
    return Promise.resolve({ success: true, rows: [] });
  }

  // This is the asynchronous disposable method
  async [Symbol.asyncDispose]() {
    console.log('Releasing DB connection back to the pool...');
    // Simulate a network delay for releasing the connection
    await new Promise(resolve => setTimeout(resolve, 50));
    console.log('DB connection released.');
  }
}

ಈಗ, ಯಾವುದೇ `MockDbConnection` ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅಸಿಂಕ್ ಡಿಸ್ಪೋಸಬಲ್ ರಿಸೋರ್ಸ್ ಆಗಿದೆ. ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ತನ್ನನ್ನು ತಾನೇ ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಹೇಗೆ ಬಿಡುಗಡೆ ಮಾಡಬೇಕೆಂದು ಅದಕ್ಕೆ ತಿಳಿದಿದೆ.

ಹೊಸ ಸಿಂಟ್ಯಾಕ್ಸ್: `using` ಮತ್ತು `await using` ಬಳಕೆಯಲ್ಲಿ

ನಮ್ಮ ಡಿಸ್ಪೋಸಬಲ್ ಕ್ಲಾಸ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ ನಂತರ, ನಾವು ಈಗ ಅವುಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸಲು ಹೊಸ ಕೀವರ್ಡ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಈ ಕೀವರ್ಡ್‌ಗಳು `let` ಮತ್ತು `const` ನಂತೆ ಬ್ಲಾಕ್-ಸ್ಕೋಪ್ಡ್ ಘೋಷಣೆಗಳನ್ನು ರಚಿಸುತ್ತವೆ.

`using` ನೊಂದಿಗೆ ಸಿಂಕ್ರೊನಸ್ ಕ್ಲೀನಪ್

`using` ಕೀವರ್ಡ್ ಅನ್ನು `Symbol.dispose` ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಂಪನ್ಮೂಲಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ `using` ಘೋಷಣೆ ಮಾಡಿದ ಬ್ಲಾಕ್ ಅನ್ನು ತೊರೆದಾಗ, `[Symbol.dispose]()` ವಿಧಾನವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ.

ನಮ್ಮ `TempFile` ಕ್ಲಾಸ್ ಅನ್ನು ಬಳಸೋಣ:


function processDataWithTempFile() {
  console.log('Entering block...');
  using tempFile = new TempFile('This is some important data.');

  // You can work with tempFile here
  const content = fs.readFileSync(tempFile.path, 'utf8');
  console.log(`Read from temp file: "${content}"`);

  // No cleanup code needed here!
  console.log('...doing more work...');
} // <-- tempFile.[Symbol.dispose]() is called automatically right here!

processDataWithTempFile();
console.log('Block has been exited.');

ಔಟ್‌ಪುಟ್ ಈ ರೀತಿ ಇರುತ್ತದೆ:

Entering block...
Created temp file: /path/to/temp_1678886400000.txt
Read from temp file: "This is some important data."
...doing more work...
Disposing temp file: /path/to/temp_1678886400000.txt
File deleted successfully.
Block has been exited.

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

ಬಹು ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ನೀವು ಒಂದೇ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಅನೇಕ `using` ಘೋಷಣೆಗಳನ್ನು ಹೊಂದಬಹುದು. ಅವುಗಳನ್ನು ಅವುಗಳ ರಚನೆಯ ಹಿಮ್ಮುಖ ಕ್ರಮದಲ್ಲಿ (LIFO ಅಥವಾ "ಸ್ಟಾಕ್-ಲೈಕ್" ನಡವಳಿಕೆ) ಡಿಸ್ಪೋಸ್ ಮಾಡಲಾಗುತ್ತದೆ.


{
  using resourceA = new MyDisposable('A'); // Created first
  using resourceB = new MyDisposable('B'); // Created second
  console.log('Inside block, using resources...');
} // resourceB is disposed of first, then resourceA

`await using` ನೊಂದಿಗೆ ಅಸಿಂಕ್ರೊನಸ್ ಕ್ಲೀನಪ್

`await using` ಕೀವರ್ಡ್ `using` ಗೆ ಅಸಿಂಕ್ರೊನಸ್ ಸಮಾನವಾಗಿದೆ. ಇದನ್ನು `Symbol.asyncDispose` ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಂಪನ್ಮೂಲಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಕ್ಲೀನಪ್ ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿರುವುದರಿಂದ, ಈ ಕೀವರ್ಡ್ ಅನ್ನು `async` ಫಂಕ್ಷನ್ ಒಳಗೆ ಅಥವಾ ಮಾಡ್ಯೂಲ್‌ನ ಉನ್ನತ ಮಟ್ಟದಲ್ಲಿ (ಟಾಪ್-ಲೆವೆಲ್ ಅವೈಟ್ ಬೆಂಬಲಿತವಾಗಿದ್ದರೆ) ಮಾತ್ರ ಬಳಸಬಹುದು.

ನಮ್ಮ `MockDbConnection` ಕ್ಲಾಸ್ ಅನ್ನು ಬಳಸೋಣ:


async function performDatabaseOperation() {
  console.log('Entering async function...');
  await using db = mockDbPool.getConnection();

  await db.query('SELECT * FROM users');

  console.log('Database operation complete.');
} // <-- await db.[Symbol.asyncDispose]() is called automatically here!

(async () => {
  await performDatabaseOperation();
  console.log('Async function has completed.');
})();

ಔಟ್‌ಪುಟ್ ಅಸಿಂಕ್ರೊನಸ್ ಕ್ಲೀನಪ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ:

Entering async function...
DB connection acquired.
Executing query: SELECT * FROM users
Database operation complete.
Releasing DB connection back to the pool...
(waits 50ms)
DB connection released.
Async function has completed.

`using` ನಂತೆಯೇ, `await using` ಸಿಂಟ್ಯಾಕ್ಸ್ ಸಂಪೂರ್ಣ ಜೀವನಚಕ್ರವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ಇದು ಅಸಿಂಕ್ರೊನಸ್ ಕ್ಲೀನಪ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಿಯಾಗಿ `await` ಮಾಡುತ್ತದೆ. ಇದು ಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಮಾತ್ರ ಡಿಸ್ಪೋಸಬಲ್ ಆಗಿರುವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸಹ ನಿಭಾಯಿಸಬಲ್ಲದು - ಅದು ಅವುಗಳನ್ನು ಕಾಯುವುದಿಲ್ಲ.

ಸುಧಾರಿತ ಮಾದರಿಗಳು: `DisposableStack` ಮತ್ತು `AsyncDisposableStack`

ಕೆಲವೊಮ್ಮೆ, `using` ನ ಸರಳ ಬ್ಲಾಕ್-ಸ್ಕೋಪಿಂಗ್ ಸಾಕಷ್ಟು ಹೊಂದಿಕೊಳ್ಳುವಂತಿಲ್ಲ. ಒಂದು ನಿರ್ದಿಷ್ಟ ಲೆಕ್ಸಿಕಲ್ ಬ್ಲಾಕ್‌ಗೆ ಬದ್ಧವಾಗಿರದ ಜೀವಿತಾವಧಿಯೊಂದಿಗೆ ನೀವು ಸಂಪನ್ಮೂಲಗಳ ಗುಂಪನ್ನು ನಿರ್ವಹಿಸಬೇಕಾದರೆ ಏನು? ಅಥವಾ `Symbol.dispose` ನೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸದ ಹಳೆಯ ಲೈಬ್ರರಿಯೊಂದಿಗೆ ನೀವು ಸಂಯೋಜಿಸುತ್ತಿದ್ದರೆ ಏನು?

ಈ ಸನ್ನಿವೇಶಗಳಿಗಾಗಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎರಡು ಸಹಾಯಕ ಕ್ಲಾಸ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ: `DisposableStack` ಮತ್ತು `AsyncDisposableStack`.

`DisposableStack`: ಹೊಂದಿಕೊಳ್ಳುವ ಕ್ಲೀನಪ್ ಮ್ಯಾನೇಜರ್

ಒಂದು `DisposableStack` ಎಂಬುದು ಕ್ಲೀನಪ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಂಗ್ರಹವನ್ನು ನಿರ್ವಹಿಸುವ ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದೆ. ಇದು ಸ್ವತಃ ಒಂದು ಡಿಸ್ಪೋಸಬಲ್ ಸಂಪನ್ಮೂಲವಾಗಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಅದರ ಸಂಪೂರ್ಣ ಜೀವಿತಾವಧಿಯನ್ನು `using` ಬ್ಲಾಕ್‌ನೊಂದಿಗೆ ನಿರ್ವಹಿಸಬಹುದು.

ಇದು ಹಲವಾರು ಉಪಯುಕ್ತ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದೆ:

ಉದಾಹರಣೆ: ಷರತ್ತುಬದ್ಧ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ

ಒಂದು ನಿರ್ದಿಷ್ಟ ಷರತ್ತು ಪೂರೈಸಿದಾಗ ಮಾತ್ರ ಲಾಗ್ ಫೈಲ್ ತೆರೆಯುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ, ಆದರೆ ನೀವು ಎಲ್ಲಾ ಕ್ಲೀನಪ್ ಅನ್ನು ಕೊನೆಯಲ್ಲಿ ಒಂದೇ ಸ್ಥಳದಲ್ಲಿ ಮಾಡಲು ಬಯಸುತ್ತೀರಿ.


function processWithConditionalLogging(shouldLog) {
  using stack = new DisposableStack();

  const db = stack.use(getDbConnection()); // Always use the DB

  if (shouldLog) {
    const logFileStream = fs.createWriteStream('app.log');
    // Defer the cleanup for the stream
    stack.defer(() => {
      console.log('Closing log file stream...');
      logFileStream.end();
    });
    db.logTo(logFileStream);
  }

  db.doWork();

} // <-- The stack is disposed, calling all registered cleanup functions in LIFO order.

`AsyncDisposableStack`: ಅಸಿಂಕ್ರೊನಸ್ ಪ್ರಪಂಚಕ್ಕಾಗಿ

ನೀವು ಊಹಿಸುವಂತೆ, `AsyncDisposableStack` ಅಸಿಂಕ್ರೊನಸ್ ಆವೃತ್ತಿಯಾಗಿದೆ. ಇದು ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಿಂಕ್ರೊನಸ್ ಡಿಸ್ಪೋಸಬಲ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಬಲ್ಲದು. ಅದರ ಪ್ರಾಥಮಿಕ ಕ್ಲೀನಪ್ ವಿಧಾನವು `.disposeAsync()` ಆಗಿದೆ, ಇದು ಎಲ್ಲಾ ಅಸಿಂಕ್ರೊನಸ್ ಕ್ಲೀನಪ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಪೂರ್ಣಗೊಂಡಾಗ ಪರಿಹರಿಸುವ `Promise` ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ಸಂಪನ್ಮೂಲಗಳ ಮಿಶ್ರಣವನ್ನು ನಿರ್ವಹಿಸುವುದು

ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕ (ಅಸಿಂಕ್ ಕ್ಲೀನಪ್) ಮತ್ತು ತಾತ್ಕಾಲಿಕ ಫೈಲ್ (ಸಿಂಕ್ ಕ್ಲೀನಪ್) ಅಗತ್ಯವಿರುವ ವೆಬ್ ಸರ್ವರ್ ವಿನಂತಿ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ರಚಿಸೋಣ.


async function handleRequest() {
  await using stack = new AsyncDisposableStack();

  // Manage an async disposable resource
  const dbConnection = await stack.use(getAsyncDbConnection());

  // Manage a sync disposable resource
  const tempFile = stack.use(new TempFile('request data'));

  // Adopt a resource from an old API
  const legacyResource = getLegacyResource();
  stack.adopt(legacyResource, () => legacyResource.shutdown());

  console.log('Processing request...');
  await doWork(dbConnection, tempFile.path);

} // <-- stack.disposeAsync() is called. It will correctly await async cleanup.

`AsyncDisposableStack` ಸಂಕೀರ್ಣ ಸೆಟಪ್ ಮತ್ತು ಟಿಯರ್‌ಡೌನ್ ತರ್ಕವನ್ನು ಸ್ವಚ್ಛ, ಊಹಿಸಬಹುದಾದ ರೀತಿಯಲ್ಲಿ ಸಂಘಟಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದೆ.

`SuppressedError` ನೊಂದಿಗೆ ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆ

ERM ನ ಅತ್ಯಂತ ಸೂಕ್ಷ್ಮ ಆದರೆ ಮಹತ್ವದ ಸುಧಾರಣೆಗಳಲ್ಲಿ ಒಂದು ಅದು ದೋಷಗಳನ್ನು ಹೇಗೆ ನಿಭಾಯಿಸುತ್ತದೆ ಎಂಬುದಾಗಿದೆ. `using` ಬ್ಲಾಕ್ ಒಳಗೆ ಒಂದು ದೋಷವನ್ನು ಎಸೆದರೆ, ಮತ್ತು ನಂತರದ ಸ್ವಯಂಚಾಲಿತ ಡಿಸ್ಪೋಸಲ್ ಸಮಯದಲ್ಲಿ *ಮತ್ತೊಂದು* ದೋಷವನ್ನು ಎಸೆದರೆ ಏನಾಗುತ್ತದೆ?

ಹಳೆಯ `try...finally` ಪ್ರಪಂಚದಲ್ಲಿ, `finally` ಬ್ಲಾಕ್‌ನಿಂದ ಬಂದ ದೋಷವು ಸಾಮಾನ್ಯವಾಗಿ `try` ಬ್ಲಾಕ್‌ನಿಂದ ಬಂದ ಮೂಲ, ಹೆಚ್ಚು ಮುಖ್ಯವಾದ ದೋಷವನ್ನು ತಿದ್ದಿ ಬರೆಯುತ್ತಿತ್ತು ಅಥವಾ "suppress" ಮಾಡುತ್ತಿತ್ತು. ಇದು ಆಗಾಗ್ಗೆ ಡೀಬಗ್ ಮಾಡುವುದನ್ನು ಅತ್ಯಂತ ಕಷ್ಟಕರವಾಗಿಸುತ್ತಿತ್ತು.

ERM ಇದನ್ನು ಹೊಸ ಜಾಗತಿಕ ದೋಷ ಪ್ರಕಾರದೊಂದಿಗೆ ಪರಿಹರಿಸುತ್ತದೆ: `SuppressedError`. ಮತ್ತೊಂದು ದೋಷವು ಈಗಾಗಲೇ ಪ್ರಸಾರವಾಗುತ್ತಿರುವಾಗ ಡಿಸ್ಪೋಸಲ್ ಸಮಯದಲ್ಲಿ ದೋಷ ಸಂಭವಿಸಿದರೆ, ಡಿಸ್ಪೋಸಲ್ ದೋಷವನ್ನು "suppress" ಮಾಡಲಾಗುತ್ತದೆ. ಮೂಲ ದೋಷವನ್ನು ಎಸೆಯಲಾಗುತ್ತದೆ, ಆದರೆ ಈಗ ಅದು ಡಿಸ್ಪೋಸಲ್ ದೋಷವನ್ನು ಒಳಗೊಂಡಿರುವ `suppressed` ಪ್ರಾಪರ್ಟಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.


class FaultyResource {
  [Symbol.dispose]() {
    throw new Error('Error during disposal!');
  }
}

try {
  using resource = new FaultyResource();
  throw new Error('Error during operation!');
} catch (e) {
  console.log(`Caught error: ${e.message}`); // Error during operation!
  if (e.suppressed) {
    console.log(`Suppressed error: ${e.suppressed.message}`); // Error during disposal!
    console.log(e instanceof SuppressedError); // false
    console.log(e.suppressed instanceof Error); // true
  }
}

ಈ ನಡವಳಿಕೆಯು ನೀವು ಮೂಲ ವೈಫಲ್ಯದ ಸಂದರ್ಭವನ್ನು ಎಂದಿಗೂ ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಇದು ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ಡೀಬಗ್ ಮಾಡಬಹುದಾದ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯಾದ್ಯಂತ ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

ಎಕ್ಸ್‌ಪ್ಲಿಸಿಟ್ ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್‌ನ ಅನ್ವಯಗಳು ವಿಶಾಲವಾಗಿವೆ ಮತ್ತು ಜಗತ್ತಿನಾದ್ಯಂತ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಸಂಬಂಧಿಸಿವೆ, ಅವರು ಬ್ಯಾಕ್-ಎಂಡ್, ಫ್ರಂಟ್-ಎಂಡ್, ಅಥವಾ ಟೆಸ್ಟಿಂಗ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿರಲಿ.

ಬ್ರೌಸರ್ ಮತ್ತು ರನ್‌ಟೈಮ್ ಬೆಂಬಲ

ಇದು ಒಂದು ಆಧುನಿಕ ವೈಶಿಷ್ಟ್ಯವಾಗಿರುವುದರಿಂದ, ನೀವು ಎಕ್ಸ್‌ಪ್ಲಿಸಿಟ್ ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಅನ್ನು ಎಲ್ಲಿ ಬಳಸಬಹುದು ಎಂದು ತಿಳಿದಿರುವುದು ಮುಖ್ಯ. 2023ರ ಕೊನೆಯಲ್ಲಿ / 2024ರ ಆರಂಭದಲ್ಲಿ, ಪ್ರಮುಖ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರಗಳ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಬೆಂಬಲವು ವ್ಯಾಪಕವಾಗಿದೆ:

ಹಳೆಯ ಪರಿಸರಗಳಿಗಾಗಿ, `using` ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ರೂಪಾಂತರಿಸಲು ಮತ್ತು ಅಗತ್ಯ ಚಿಹ್ನೆಗಳು ಮತ್ತು ಸ್ಟಾಕ್ ಕ್ಲಾಸ್‌ಗಳನ್ನು ಪಾಲಿಫಿಲ್ ಮಾಡಲು ನೀವು Babel ನಂತಹ ಟ್ರಾನ್ಸ್‌ಪೈಲರ್‌ಗಳನ್ನು ಮತ್ತು ಸೂಕ್ತ ಪ್ಲಗಿನ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಬೇಕಾಗುತ್ತದೆ.

ತೀರ್ಮಾನ: ಸುರಕ್ಷತೆ ಮತ್ತು ಸ್ಪಷ್ಟತೆಯ ಹೊಸ ಯುಗ

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

ಪ್ರಮುಖ ಅಂಶಗಳು:

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