ஜாவாஸ்கிரிப்டின் புதிய சூப்பர் பவர்: எக்ஸ்பிளிசிட் ரிசோர்ஸ் மேனேஜ்மென்ட் பற்றிய ஒரு ஆழமான பார்வை

மென்பொருள் மேம்பாட்டின் மாறும் உலகில், வலுவான, நம்பகமான மற்றும் செயல்திறன் மிக்க பயன்பாடுகளை உருவாக்குவதில் வளங்களை திறம்பட நிர்வகிப்பது ஒரு மூலக்கல்லாகும். பல தசாப்தங்களாக, ஜாவாஸ்கிரிப்ட் டெவலப்பர்கள் கோப்பு கையாளுதல்கள், நெட்வொர்க் இணைப்புகள் அல்லது தரவுத்தள அமர்வுகள் போன்ற முக்கியமான வளங்கள் சரியாக வெளியிடப்படுவதை உறுதிசெய்ய try...catch...finally போன்ற கைமுறை முறைகளையே நம்பியிருந்தனர். இது செயல்பட்டாலும், இந்த அணுகுமுறை பெரும்பாலும் சொற்பெருக்குடையது, பிழை ஏற்பட வாய்ப்புள்ளது, மற்றும் சிக்கலான சூழ்நிலைகளில் கட்டுப்படுத்த முடியாததாக மாறும், இது சில சமயங்களில் "பேரழிவின் பிரமிடு" (pyramid of doom) என்று குறிப்பிடப்படுகிறது.

இந்த மொழிக்கு ஒரு முன்னுதாரண மாற்றத்தை அறிமுகப்படுத்துகிறது: எக்ஸ்பிளிசிட் ரிசோர்ஸ் மேனேஜ்மென்ட் (ERM). ECMAScript 2024 (ES2024) தரத்தில் இறுதி செய்யப்பட்ட, C#, பைத்தான் மற்றும் ஜாவா போன்ற மொழிகளில் உள்ள ஒத்த கட்டமைப்புகளால் ஈர்க்கப்பட்ட இந்த சக்திவாய்ந்த அம்சம், வளங்களை தூய்மைப்படுத்துவதைக் கையாள ஒரு அறிவிப்பு மற்றும் தானியங்கு வழியை அறிமுகப்படுத்துகிறது. புதிய using மற்றும் await using முக்கிய வார்த்தைகளைப் பயன்படுத்துவதன் மூலம், ஜாவாஸ்கிரிப்ட் இப்போது ஒரு காலமற்ற நிரலாக்க சவாலுக்கு மிகவும் நேர்த்தியான மற்றும் பாதுகாப்பான தீர்வை வழங்குகிறது.

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

பழைய முறை: கைமுறை வள தூய்மைப்படுத்தலின் சவால்கள்

புதிய அமைப்பின் நேர்த்தியைப் பாராட்டுவதற்கு முன்பு, நாம் முதலில் பழைய முறையின் வலிகளைப் புரிந்து கொள்ள வேண்டும். ஜாவாஸ்கிரிப்டில் வள மேலாண்மைக்கான உன்னதமான முறை try...finally பிளாக் ஆகும்.

இதன் தர்க்கம் எளிமையானது: நீங்கள் try பிளாக்கில் ஒரு வளத்தைப் பெறுகிறீர்கள், அதை finally பிளாக்கில் வெளியிடுகிறீர்கள். try பிளாக்கில் உள்ள குறியீடு வெற்றி பெற்றாலும், தோல்வியுற்றாலும் அல்லது முன்கூட்டியே திரும்பினாலும், finally பிளாக் இயங்குவதை உறுதி செய்கிறது.

ஒரு பொதுவான சர்வர்-சைட் சூழ்நிலையை கருத்தில் கொள்வோம்: ஒரு கோப்பைத் திறந்து, அதில் சில தரவுகளை எழுதி, பின்னர் கோப்பு மூடப்படுவதை உறுதி செய்தல்.

எடுத்துக்காட்டு: try...finally உடன் ஒரு எளிய கோப்பு செயல்பாடு

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

async function processFile(filePath, data) {
  let fileHandle;
  try {
    console.log('கோப்பைத் திறக்கிறது...');
    fileHandle = await fs.open(filePath, 'w');
    console.log('கோப்பில் எழுதுகிறது...');
    await fileHandle.write(data);
    console.log('தரவு வெற்றிகரமாக எழுதப்பட்டது.');
  } catch (error) {
    console.error('கோப்பு செயலாக்கத்தின் போது ஒரு பிழை ஏற்பட்டது:', error);
  } finally {
    if (fileHandle) {
      console.log('கோப்பை மூடுகிறது...');
      await fileHandle.close();
    }
  }
}

இந்த குறியீடு வேலை செய்கிறது, ஆனால் இது பல பலவீனங்களை வெளிப்படுத்துகிறது:

• சொற்பெருக்கு: முக்கிய தர்க்கம் (திறப்பது மற்றும் எழுதுவது) தூய்மைப்படுத்தல் மற்றும் பிழை கையாளுதலுக்கான குறிப்பிடத்தக்க அளவு பாய்லர்பிளேட்டால் சூழப்பட்டுள்ளது.
• கவலைகளின் பிரிப்பு: வளத்தைப் பெறுதல் (fs.open) அதன் தொடர்புடைய தூய்மைப்படுத்தலில் (fileHandle.close) இருந்து வெகு தொலைவில் உள்ளது, இது குறியீட்டைப் படிப்பதையும் பகுத்தறிவதையும் கடினமாக்குகிறது.
• பிழை ஏற்பட வாய்ப்புள்ளது: if (fileHandle) சோதனையை மறந்துவிடுவது எளிது, இது ஆரம்ப fs.open அழைப்பு தோல்வியுற்றால் செயலிழப்பை ஏற்படுத்தும். மேலும், fileHandle.close() அழைப்பின் போது ஏற்படும் ஒரு பிழை கையாளப்படாது மற்றும் try பிளாக்கிலிருந்து அசல் பிழையை மறைக்கக்கூடும்.

இப்போது, தரவுத்தள இணைப்பு மற்றும் கோப்பு கையாளுதல் போன்ற பல வளங்களை நிர்வகிப்பதை கற்பனை செய்து பாருங்கள். குறியீடு விரைவாக ஒரு சிக்கலான குழப்பமாகிறது:

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(`தற்காலிக கோப்பு உருவாக்கப்பட்டது: ${this.path}`);
  }

  // இது சின்க்ரோனஸ் டிஸ்போசபிள் முறை
  [Symbol.dispose]() {
    console.log(`தற்காலிக கோப்பை டிஸ்போஸ் செய்கிறது: ${this.path}`);
    try {
      fs.unlinkSync(this.path);
      console.log('கோப்பு வெற்றிகரமாக நீக்கப்பட்டது.');
    } catch (error) {
      console.error(`கோப்பை நீக்குவதில் தோல்வி: ${this.path}`, error);
      // டிஸ்போஸ் உள்ளேயும் பிழைகளைக் கையாள்வது முக்கியம்!
    }
  }
}

`TempFile`-இன் எந்த நிகழ்வும் இப்போது ஒரு டிஸ்போசபிள் வளமாகும். இது `Symbol.dispose` ஆல் திறவுகோலாகக் கொண்ட ஒரு முறையைக் கொண்டுள்ளது, இது வட்டில் இருந்து கோப்பை நீக்குவதற்கான தர்க்கத்தைக் கொண்டுள்ளது.

`Symbol.asyncDispose` உடன் அசின்க்ரோனஸ் டிஸ்போசல்

பல நவீன தூய்மைப்படுத்தல் செயல்பாடுகள் அசின்க்ரோனஸாக உள்ளன. ஒரு தரவுத்தள இணைப்பை மூடுவது நெட்வொர்க் மூலம் ஒரு `QUIT` கட்டளையை அனுப்புவதை உள்ளடக்கலாம், அல்லது ஒரு செய்தி வரிசை கிளையன்ட் அதன் வெளிச்செல்லும் இடையகத்தை வெளியேற்ற வேண்டியிருக்கலாம். இந்த சூழ்நிலைகளுக்கு, நாம் `Symbol.asyncDispose`-ஐப் பயன்படுத்துகிறோம்.

`Symbol.asyncDispose` உடன் தொடர்புடைய முறை ஒரு `Promise`-ஐத் திரும்ப அளிக்க வேண்டும் (அல்லது ஒரு `async` செயல்பாடாக இருக்க வேண்டும்).

ஒரு பூலுக்கு அசின்க்ரோனஸாக திரும்ப விடுவிக்கப்பட வேண்டிய ஒரு போலி தரவுத்தள இணைப்பை மாதிரியாகக் கொள்வோம்.

// ஒரு போலி தரவுத்தள பூல்
const mockDbPool = {
  getConnection: () => {
    console.log('DB இணைப்பு பெறப்பட்டது.');
    return new MockDbConnection();
  }
};

class MockDbConnection {
  query(sql) {
    console.log(`வினவலை இயக்குகிறது: ${sql}`);
    return Promise.resolve({ success: true, rows: [] });
  }

  // இது அசின்க்ரோனஸ் டிஸ்போசபிள் முறை
  async [Symbol.asyncDispose]() {
    console.log('DB இணைப்பை பூலுக்குத் திரும்ப விடுவிக்கிறது...');
    // இணைப்பை விடுவிப்பதற்கான ஒரு நெட்வொர்க் தாமதத்தை உருவகப்படுத்துகிறது
    await new Promise(resolve => setTimeout(resolve, 50));
    console.log('DB இணைப்பு விடுவிக்கப்பட்டது.');
  }
}

இப்போது, எந்த `MockDbConnection` நிகழ்வும் ஒரு அசின்க்ரோனஸ் டிஸ்போசபிள் வளமாகும். அது இனி தேவைப்படாதபோது தன்னை அசின்க்ரோனஸாக எப்படி விடுவிப்பது என்று அதற்குத் தெரியும்.

புதிய தொடரியல்: `using` மற்றும் `await using` செயல்பாட்டில்

நமது டிஸ்போசபிள் வகுப்புகள் வரையறுக்கப்பட்டவுடன், அவற்றை தானாக நிர்வகிக்க புதிய முக்கிய வார்த்தைகளைப் பயன்படுத்தலாம். இந்த முக்கிய வார்த்தைகள் `let` மற்றும் `const` போலவே, பிளாக்-ஸ்கோப் செய்யப்பட்ட அறிவிப்புகளை உருவாக்குகின்றன.

`using` உடன் சின்க்ரோனஸ் தூய்மைப்படுத்தல்

`using` முக்கிய சொல் `Symbol.dispose`-ஐ செயல்படுத்தும் வளங்களுக்குப் பயன்படுத்தப்படுகிறது. குறியீடு செயல்படுத்தல் `using` அறிவிப்பு செய்யப்பட்ட பிளாக்கை விட்டு வெளியேறும்போது, `[Symbol.dispose]()` முறை தானாகவே அழைக்கப்படுகிறது.

நமது `TempFile` வகுப்பைப் பயன்படுத்துவோம்:

function processDataWithTempFile() {
  console.log('பிளாக்கிற்குள் நுழைகிறது...');
  using tempFile = new TempFile('இது சில முக்கியமான தரவு.');

  // நீங்கள் இங்கே tempFile உடன் வேலை செய்யலாம்
  const content = fs.readFileSync(tempFile.path, 'utf8');
  console.log(`தற்காலிக கோப்பிலிருந்து படிக்கப்பட்டது: "${content}"`);

  // இங்கே தூய்மைப்படுத்தல் குறியீடு எதுவும் தேவையில்லை!
  console.log('...மேலும் வேலை செய்கிறது...');
} // <-- tempFile.[Symbol.dispose]() இங்கே தானாகவே அழைக்கப்படுகிறது!

processDataWithTempFile();
console.log('பிளாக்கிலிருந்து வெளியேறிவிட்டது.');

வெளியீடு இதுவாக இருக்கும்:

பிளாக்கிற்குள் நுழைகிறது...
தற்காலிக கோப்பு உருவாக்கப்பட்டது: /path/to/temp_1678886400000.txt
தற்காலிக கோப்பிலிருந்து படிக்கப்பட்டது: "இது சில முக்கியமான தரவு."
...மேலும் வேலை செய்கிறது...
தற்காலிக கோப்பை டிஸ்போஸ் செய்கிறது: /path/to/temp_1678886400000.txt
கோப்பு வெற்றிகரமாக நீக்கப்பட்டது.
பிளாக்கிலிருந்து வெளியேறிவிட்டது.

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

பல வளங்களை நிர்வகித்தல்

ஒரே பிளாக்கில் பல `using` அறிவிப்புகளை நீங்கள் வைத்திருக்கலாம். அவை உருவாக்கப்பட்டதற்கு நேர்மாறான வரிசையில் (LIFO அல்லது "ஸ்டாக்-போன்ற" நடத்தை) டிஸ்போஸ் செய்யப்படும்.

{
  using resourceA = new MyDisposable('A'); // முதலில் உருவாக்கப்பட்டது
  using resourceB = new MyDisposable('B'); // இரண்டாவதாக உருவாக்கப்பட்டது
  console.log('பிளாக்கிற்குள், வளங்களைப் பயன்படுத்துகிறது...');
} // resourceB முதலில் டிஸ்போஸ் செய்யப்படுகிறது, பின்னர் resourceA

`await using` உடன் அசின்க்ரோனஸ் தூய்மைப்படுத்தல்

`await using` முக்கிய சொல் `using`-இன் அசின்க்ரோனஸ் đối tác ஆகும். இது `Symbol.asyncDispose`-ஐ செயல்படுத்தும் வளங்களுக்குப் பயன்படுத்தப்படுகிறது. தூய்மைப்படுத்தல் அசின்க்ரோனஸாக இருப்பதால், இந்த முக்கிய சொல்லை ஒரு `async` செயல்பாட்டிற்குள் அல்லது ஒரு மாட்யூலின் மேல் மட்டத்தில் மட்டுமே பயன்படுத்த முடியும் (டாப்-லெவல் await ஆதரிக்கப்பட்டால்).

நமது `MockDbConnection` வகுப்பைப் பயன்படுத்துவோம்:

async function performDatabaseOperation() {
  console.log('அசின்க்ரோனஸ் செயல்பாட்டிற்குள் நுழைகிறது...');
  await using db = mockDbPool.getConnection();

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

  console.log('தரவுத்தள செயல்பாடு முடிந்தது.');
} // <-- await db.[Symbol.asyncDispose]() இங்கே தானாகவே அழைக்கப்படுகிறது!

(async () => {
  await performDatabaseOperation();
  console.log('அசின்க்ரோனஸ் செயல்பாடு முடிந்துவிட்டது.');
})();

வெளியீடு அசின்க்ரோனஸ் தூய்மைப்படுத்தலைக் காட்டுகிறது:

அசின்க்ரோனஸ் செயல்பாட்டிற்குள் நுழைகிறது...
DB இணைப்பு பெறப்பட்டது.
வினவலை இயக்குகிறது: SELECT * FROM users
தரவுத்தள செயல்பாடு முடிந்தது.
DB இணைப்பை பூலுக்குத் திரும்ப விடுவிக்கிறது...
(50ms காத்திருக்கிறது)
DB இணைப்பு விடுவிக்கப்பட்டது.
அசின்க்ரோனஸ் செயல்பாடு முடிந்துவிட்டது.

`using` போலவே, `await using` தொடரியல் முழு வாழ்க்கைச் சுழற்சியையும் கையாளுகிறது, ஆனால் அது அசின்க்ரோனஸ் தூய்மைப்படுத்தல் செயல்முறைக்கு சரியாக `await` செய்கிறது. இது சின்க்ரோனஸாக மட்டுமே டிஸ்போஸ் செய்யக்கூடிய வளங்களையும் கையாள முடியும்—அது வெறுமனே அவற்றுக்கு `await` செய்யாது.

மேம்பட்ட வடிவங்கள்: `DisposableStack` மற்றும் `AsyncDisposableStack`

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

இந்த சூழ்நிலைகளுக்கு, ஜாவாஸ்கிரிப்ட் இரண்டு உதவி வகுப்புகளை வழங்குகிறது: `DisposableStack` மற்றும் `AsyncDisposableStack`.

`DisposableStack`: நெகிழ்வான தூய்மைப்படுத்தல் மேலாளர்

ஒரு `DisposableStack` என்பது தூய்மைப்படுத்தல் செயல்பாடுகளின் தொகுப்பை நிர்வகிக்கும் ஒரு பொருள். அதுவே ஒரு டிஸ்போசபிள் வளமாகும், எனவே அதன் முழு வாழ்க்கைச் சுழற்சியையும் ஒரு `using` பிளாக் மூலம் நீங்கள் நிர்வகிக்கலாம்.

இது பல பயனுள்ள முறைகளைக் கொண்டுள்ளது:

• .use(resource): ஒரு `[Symbol.dispose]` முறையைக் கொண்ட ஒரு பொருளை ஸ்டாக்கில் சேர்க்கிறது. வளத்தைத் திருப்பித் தருகிறது, எனவே நீங்கள் அதைச் சங்கிலியாக இணைக்கலாம்.
• .defer(callback): ஒரு தன்னிச்சையான தூய்மைப்படுத்தல் செயல்பாட்டை ஸ்டாக்கில் சேர்க்கிறது. இது தற்காலிக தூய்மைப்படுத்தலுக்கு நம்பமுடியாத அளவிற்கு பயனுள்ளதாக இருக்கும்.
• .adopt(value, callback): ஒரு மதிப்பையும் அந்த மதிப்புக்கான ஒரு தூய்மைப்படுத்தல் செயல்பாட்டையும் சேர்க்கிறது. இது டிஸ்போசபிள் நெறிமுறையை ஆதரிக்காத நூலகங்களிலிருந்து வரும் வளங்களை ரேப் செய்வதற்கு ஏற்றது.
• .move(): தற்போதைய ஸ்டாக்கை அழித்து, வளங்களின் உரிமையை ஒரு புதிய ஸ்டாக்கிற்கு மாற்றுகிறது.

எடுத்துக்காட்டு: நிபந்தனைக்குட்பட்ட வள மேலாண்மை

ஒரு குறிப்பிட்ட நிபந்தனை பூர்த்தி செய்யப்பட்டால் மட்டுமே ஒரு பதிவு கோப்பைத் திறக்கும் ஒரு செயல்பாட்டை கற்பனை செய்து பாருங்கள், ஆனால் எல்லா தூய்மைப்படுத்தலும் இறுதியில் ஒரே இடத்தில் நடக்க வேண்டும் என்று நீங்கள் விரும்புகிறீர்கள்.

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

  const db = stack.use(getDbConnection()); // எப்போதும் DB-ஐப் பயன்படுத்தவும்

  if (shouldLog) {
    const logFileStream = fs.createWriteStream('app.log');
    // ஸ்ட்ரீமிற்கான தூய்மைப்படுத்தலை ஒத்திவைக்கவும்
    stack.defer(() => {
      console.log('பதிவு கோப்பு ஸ்ட்ரீமை மூடுகிறது...');
      logFileStream.end();
    });
    db.logTo(logFileStream);
  }

  db.doWork();

} // <-- ஸ்டாக் டிஸ்போஸ் செய்யப்படுகிறது, பதிவுசெய்யப்பட்ட அனைத்து தூய்மைப்படுத்தல் செயல்பாடுகளையும் LIFO வரிசையில் அழைக்கிறது.

`AsyncDisposableStack`: அசின்க்ரோனஸ் உலகிற்கு

நீங்கள் யூகித்தபடி, `AsyncDisposableStack` என்பது அசின்க்ரோனஸ் பதிப்பாகும். இது சின்க்ரோனஸ் மற்றும் அசின்க்ரோனஸ் டிஸ்போசபிள்கள் இரண்டையும் நிர்வகிக்க முடியும். அதன் முதன்மை தூய்மைப்படுத்தல் முறை `.disposeAsync()` ஆகும், இது அனைத்து அசின்க்ரோனஸ் தூய்மைப்படுத்தல் செயல்பாடுகளும் முடிந்ததும் தீர்க்கப்படும் ஒரு `Promise`-ஐத் திருப்பித் தருகிறது.

எடுத்துக்காட்டு: வளங்களின் கலவையை நிர்வகித்தல்

ஒரு தரவுத்தள இணைப்பு (அசின்க்ரோனஸ் தூய்மைப்படுத்தல்) மற்றும் ஒரு தற்காலிக கோப்பு (சின்க்ரோனஸ் தூய்மைப்படுத்தல்) தேவைப்படும் ஒரு வலை சேவையக கோரிக்கை கையாளுபவரை உருவாக்குவோம்.

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

  // ஒரு அசின்க்ரோனஸ் டிஸ்போசபிள் வளத்தை நிர்வகிக்கவும்
  const dbConnection = await stack.use(getAsyncDbConnection());

  // ஒரு சின்க்ரோனஸ் டிஸ்போசபிள் வளத்தை நிர்வகிக்கவும்
  const tempFile = stack.use(new TempFile('request data'));

  // ஒரு பழைய API-இலிருந்து ஒரு வளத்தை ஏற்றுக்கொள்ளவும்
  const legacyResource = getLegacyResource();
  stack.adopt(legacyResource, () => legacyResource.shutdown());

  console.log('கோரிக்கையைச் செயலாக்குகிறது...');
  await doWork(dbConnection, tempFile.path);

} // <-- stack.disposeAsync() அழைக்கப்படுகிறது. இது அசின்க்ரோனஸ் தூய்மைப்படுத்தலுக்குச் சரியாக `await` செய்யும்.

`AsyncDisposableStack` என்பது சிக்கலான அமைவு மற்றும் பிரிப்பு தர்க்கத்தை ஒரு சுத்தமான, கணிக்கக்கூடிய முறையில் ஒருங்கிணைப்பதற்கான ஒரு சக்திவாய்ந்த கருவியாகும்.

`SuppressedError` உடன் வலுவான பிழை கையாளுதல்

ERM-இன் மிக நுட்பமான ஆனால் குறிப்பிடத்தக்க மேம்பாடுகளில் ஒன்று அது பிழைகளைக் கையாளும் விதமாகும். `using` பிளாக்கிற்குள் ஒரு பிழை ஏற்பட்டால், மற்றும் அதைத் தொடர்ந்த தானியங்கி டிஸ்போசலின் போது *மற்றொரு* பிழை ஏற்பட்டால் என்ன நடக்கும்?

பழைய `try...finally` உலகில், `finally` பிளாக்கிலிருந்து வரும் பிழை பொதுவாக `try` பிளாக்கிலிருந்து வரும் அசல், மிக முக்கியமான பிழையை மேலெழுதும் அல்லது "அடக்கும்". இது பெரும்பாலும் பிழைத்திருத்தத்தை நம்பமுடியாத அளவிற்கு கடினமாக்கியது.

ERM இதை ஒரு புதிய உலகளாவிய பிழை வகையுடன் தீர்க்கிறது: `SuppressedError`. மற்றொரு பிழை ஏற்கனவே பரவிக்கொண்டிருக்கும் போது டிஸ்போசலின் போது ஒரு பிழை ஏற்பட்டால், டிஸ்போசல் பிழை "அடக்கப்படுகிறது". அசல் பிழை வீசப்படுகிறது, ஆனால் அது இப்போது டிஸ்போசல் பிழையைக் கொண்ட ஒரு `suppressed` பண்பைக் கொண்டுள்ளது.

class FaultyResource {
  [Symbol.dispose]() {
    throw new Error('டிஸ்போசலின் போது பிழை!');
  }
}

try {
  using resource = new FaultyResource();
  throw new Error('செயல்பாட்டின் போது பிழை!');
} catch (e) {
  console.log(`பிடிபட்ட பிழை: ${e.message}`); // செயல்பாட்டின் போது பிழை!
  if (e.suppressed) {
    console.log(`அடக்கப்பட்ட பிழை: ${e.suppressed.message}`); // டிஸ்போசலின் போது பிழை!
    console.log(e instanceof SuppressedError); // false
    console.log(e.suppressed instanceof Error); // true
  }
}

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

ஜாவாஸ்கிரிப்ட் சூழல் முழுவதும் நடைமுறை பயன்பாட்டு வழக்குகள்

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

• பின்தளம் (Node.js, Deno, Bun): மிகத் தெளிவான பயன்பாட்டு வழக்குகள் இங்கே உள்ளன. தரவுத்தள இணைப்புகள், கோப்பு கையாளுதல்கள், நெட்வொர்க் சாக்கெட்டுகள் மற்றும் செய்தி வரிசை கிளையண்டுகளை நிர்வகிப்பது அற்பமாகவும் பாதுகாப்பாகவும் மாறுகிறது.
• முன்தளம் (வலை உலாவிகள்): ERM உலாவியிலும் மதிப்புமிக்கது. நீங்கள் `WebSocket` இணைப்புகளை நிர்வகிக்கலாம், வலை பூட்டுகள் API-இலிருந்து பூட்டுகளை விடுவிக்கலாம் அல்லது சிக்கலான WebRTC இணைப்புகளை தூய்மைப்படுத்தலாம்.
• சோதனை கட்டமைப்புகள் (Jest, Mocha, முதலியன): `beforeEach`-இல் அல்லது சோதனைகளுக்குள் `DisposableStack`-ஐப் பயன்படுத்தி மாக்குகள், ஸ்பைகள், சோதனை சேவையகங்கள் அல்லது தரவுத்தள நிலைகளை தானாகவே பிரிக்கலாம், இது சுத்தமான சோதனை தனிமைப்படுத்தலை உறுதி செய்கிறது.
• UI கட்டமைப்புகள் (React, Svelte, Vue): இந்த கட்டமைப்புகள் அவற்றின் சொந்த வாழ்க்கைச் சுழற்சி முறைகளைக் கொண்டிருந்தாலும், ஒரு கூறுகளுக்குள் `DisposableStack`-ஐப் பயன்படுத்தி நிகழ்வு கேட்பவர்கள் அல்லது மூன்றாம் தரப்பு நூலக சந்தாக்கள் போன்ற கட்டமைப்பு அல்லாத வளங்களை நிர்வகிக்கலாம், அவை அனைத்தும் நீக்கப்படும்போது தூய்மைப்படுத்தப்படுவதை உறுதி செய்கிறது.

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

ஒரு நவீன அம்சமாக, நீங்கள் எக்ஸ்பிளிசிட் ரிசோர்ஸ் மேனேஜ்மென்ட்டை எங்கே பயன்படுத்தலாம் என்பதை அறிவது முக்கியம். 2023-இன் பிற்பகுதி / 2024-இன் முற்பகுதியில், முக்கிய ஜாவாஸ்கிரிப்ட் சூழல்களின் சமீபத்திய பதிப்புகளில் ஆதரவு பரவலாக உள்ளது:

• Node.js: பதிப்பு 20+ (முந்தைய பதிப்புகளில் ஒரு கொடியின் பின்னால்)
• Deno: பதிப்பு 1.32+
• Bun: பதிப்பு 1.0+
• உலாவிகள்: Chrome 119+, Firefox 121+, Safari 17.2+

பழைய சூழல்களுக்கு, `using` தொடரியலை மாற்றுவதற்கும் தேவையான சின்னங்கள் மற்றும் ஸ்டாக் வகுப்புகளை பாலிஃபில் செய்வதற்கும் பொருத்தமான செருகுநிரல்களுடன் Babel போன்ற டிரான்ஸ்பைலர்களை நீங்கள் நம்பியிருக்க வேண்டும்.

முடிவு: பாதுகாப்பு மற்றும் தெளிவின் ஒரு புதிய சகாப்தம்

ஜாவாஸ்கிரிப்டின் எக்ஸ்பிளிசிட் ரிசோர்ஸ் மேனேஜ்மென்ட் என்பது வெறும் தொடரியல் இனிப்பை விட மேலானது; இது பாதுகாப்பு, தெளிவு மற்றும் பராமரிப்பை ஊக்குவிக்கும் மொழிக்கு ஒரு அடிப்படை மேம்பாடாகும். வள தூய்மைப்படுத்தலின் சோர்வான மற்றும் பிழை ஏற்பட வாய்ப்புள்ள செயல்முறையை தானியக்கமாக்குவதன் மூலம், அது டெவலப்பர்களை அவர்களின் முதன்மை வணிக தர்க்கத்தில் கவனம் செலுத்த விடுவிக்கிறது.

முக்கிய எடுத்துக்கொள்ள வேண்டியவை:

• தூய்மைப்படுத்தலை தானியக்கமாக்குங்கள்: கைமுறை try...finally பாய்லர்பிளேட்டை அகற்ற using மற்றும் await using ஐப் பயன்படுத்தவும்.
• படிக்க எளிதாக்குங்கள்: வளத்தைப் பெறுதலையும் அதன் வாழ்க்கைச் சுழற்சி வரம்பையும் இறுக்கமாக இணைத்து புலப்படும்படி வைத்திருங்கள்.
• கசிவுகளைத் தடுக்கவும்: தூய்மைப்படுத்தல் தர்க்கம் செயல்படுத்தப்படுவதை உத்தரவாதம் செய்யுங்கள், உங்கள் பயன்பாடுகளில் விலையுயர்ந்த வளக் கசிவுகளைத் தடுக்கவும்.
• பிழைகளை வலுவாகக் கையாளவும்: முக்கியமான பிழை சூழலை ஒருபோதும் இழக்காமல் இருக்க புதிய SuppressedError பொறிமுறையிலிருந்து பயனடையுங்கள்.

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