ஜாவாஸ்கிரிப்ட் 'Using' கூற்று: நவீன தானியங்கி வளங்களை அகற்றும் முறை

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

தானியங்கி வளங்களை அகற்றுவது ஏன் முக்கியம்

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

நீங்கள் ஒரு கோப்புடன் பணிபுரியும் ஒரு சூழ்நிலையைக் கவனியுங்கள். நீங்கள் கோப்பைத் திறந்து, அதன் உள்ளடக்கங்களைப் படித்து, பின்னர் அதை மூடுகிறீர்கள். நீங்கள் கோப்பை மூட மறந்துவிட்டால், இயக்க முறைமை (operating system) கோப்பைத் திறந்து வைத்திருக்கலாம், இது மற்ற பயன்பாடுகள் அதை அணுகுவதைத் தடுக்கலாம் அல்லது தரவு சிதைவுக்கு கூட வழிவகுக்கும். தரவுத்தள இணைப்புகளிலும் இதே போன்ற சிக்கல்கள் ஏற்படலாம், அங்கு செயலற்ற இணைப்புகள் மதிப்புமிக்க சேவையக வளங்களை உட்கொள்ளலாம். 'using' கூற்று, ஒரு செயல்பாடு במהלך பிழை ஏற்பட்டாலும், இந்த வளங்கள் தேவைப்படாதபோது எப்போதும் விடுவிக்கப்படுவதை உறுதிசெய்ய ஒரு கட்டமைக்கப்பட்ட வழியை வழங்குகிறது.

'Using' கூற்றை அறிமுகப்படுத்துதல்

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

இது எப்படி வேலை செய்கிறது

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

'using' கூற்றின் அடிப்படை தொடரியல் பின்வருமாறு:

            using (resource) {
  // Code that uses the resource
}

            

              
                Copy
              
            
          

இங்கே, resource என்பது 'Symbol.dispose' அல்லது 'Symbol.asyncDispose' முறையை செயல்படுத்தும் ஒரு பொருளாகும். சுருள் அடைப்புக்குறிக்குள் உள்ள குறியீடு, வளம் பயன்படுத்தப்படும் வரம்பாகும். குறியீடு செயல்படுத்தல் இந்த வரம்பை விட்டு வெளியேறும்போது (தொகுதியின் முடிவை அடைவதன் மூலம் அல்லது ஒரு விதிவிலக்கை எறிவதன் மூலம்), resource பொருளின் 'Symbol.dispose' அல்லது 'Symbol.asyncDispose' முறை தானாகவே அழைக்கப்படும்.

Symbol.dispose உடன் ஒத்திசைவான அகற்றுதல்

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

            class FileResource {
  constructor(filename) {
    this.filename = filename;
    this.fileHandle = fs.openSync(filename, 'r+');
    console.log(`File ${filename} opened.`);
  }

  [Symbol.dispose]() {
    fs.closeSync(this.fileHandle);
    console.log(`File ${this.filename} closed.`);
  }

  readSync(buffer, offset, length, position) {
    return fs.readSync(this.fileHandle, buffer, offset, length, position);
  }
}

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

try (const file = new FileResource('example.txt')) {
  const buffer = Buffer.alloc(1024);
  const bytesRead = file.readSync(buffer, 0, buffer.length, 0);
  console.log(`Read ${bytesRead} bytes from file.`);
  console.log(buffer.toString('utf8', 0, bytesRead));
} catch (err) {
  console.error('An error occurred:', err);
}

            

              
                Copy
              
            
          

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

விளக்கம்: `FileResource` வகுப்பு ஒரு கோப்பு வளத்தை உருவகப்படுத்துகிறது. `[Symbol.dispose]()` முறையில் `fs.closeSync()` ஐப் பயன்படுத்தி கோப்பை ஒத்திசைவாக மூடுவதற்கான தர்க்கம் உள்ளது. `try...using` தொகுதி, ஒரு விதிவிலக்கு எறியப்பட்டாலும், தொகுதி வெளியேறும்போது `[Symbol.dispose]()` அழைக்கப்படும் என்பதற்கு உத்தரவாதம் அளிக்கிறது. இது கோப்பு எப்போதும் மூடப்படுவதை உறுதி செய்கிறது.

Symbol.asyncDispose உடன் ஒத்திசைவற்ற அகற்றுதல்

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

            class DatabaseConnection {
  constructor(connectionString) {
    this.connectionString = connectionString;
    this.connection = null;
  }

  async connect() {
    // Simulate connecting to a database
    return new Promise(resolve => {
      setTimeout(() => {
        this.connection = { id: Math.random() }; // Simulate a connection object
        console.log(`Connected to database: ${this.connectionString}`);
        resolve();
      }, 500);
    });
  }

  async query(sql) {
    // Simulate executing a query
    return new Promise(resolve => {
      setTimeout(() => {
        console.log(`Executing query: ${sql}`);
        resolve([{ result: 'some data' }]); // Simulate query results
      }, 200);
    });
  }

  async [Symbol.asyncDispose]() {
    // Simulate closing the database connection
    return new Promise(resolve => {
      setTimeout(() => {
        console.log(`Closing database connection: ${this.connectionString}`);
        this.connection = null;
        resolve();
      }, 300);
    });
  }
}

async function main() {
  const connectionString = 'mongodb://localhost:27017/mydatabase';
  try {
    await using db = new DatabaseConnection(connectionString);
    await db.connect();
    const results = await db.query('SELECT * FROM users');
    console.log('Query results:', results);
  } catch (err) {
    console.error('An error occurred:', err);
  }
}

main();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், DatabaseConnection வகுப்பு ஒரு தரவுத்தள இணைப்பைக் குறிக்கிறது. கன்ஸ்ட்ரக்டர் இணைப்பு சரத்தை துவக்குகிறது, மற்றும் 'Symbol.asyncDispose' முறை இணைப்பை ஒத்திசைவற்ற முறையில் மூடுகிறது. 'await using' கூற்று தொகுதி வெளியேறும்போது இணைப்பு தானாகவே மூடப்படுவதை உறுதி செய்கிறது. மீண்டும், தரவுத்தள செயல்பாட்டின் போது ஒரு பிழை ஏற்பட்டாலும், இணைப்பு மூடப்படும், இது வளக் கசிவைத் தடுக்கிறது. connect மற்றும் query முறைகள் ஒத்திசைவற்றவை, நிஜ-உலக தரவுத்தள செயல்பாடுகளை உருவகப்படுத்துகின்றன.

விளக்கம்: `DatabaseConnection` வகுப்பு ஒரு ஒத்திசைவற்ற தரவுத்தள இணைப்பை உருவகப்படுத்துகிறது. `[Symbol.asyncDispose]()` முறை ஒரு ஒத்திசைவற்ற செயல்பாடாக வரையறுக்கப்பட்டுள்ளது, இது பொதுவாக ஒத்திசைவற்ற செயல்பாடுகளை உள்ளடக்கிய ஒரு தரவுத்தள இணைப்பை மூடுவதை உருவகப்படுத்துகிறது. `await using` தொகுதி, தொகுதியிலிருந்து வெளியேறும்போது `[Symbol.asyncDispose]()` முறை ஒத்திசைவற்ற முறையில் அழைக்கப்படுவதை உறுதி செய்கிறது, இது தரவுத்தள இணைப்பை சுத்தம் செய்கிறது. உருவகப்படுத்துதல் ஒத்திசைவற்ற வள தூய்மைப்படுத்தல் எவ்வாறு கையாளப்படுகிறது என்பதைக் காட்ட உதவுகிறது.

மறைமுகமான மற்றும் வெளிப்படையான Using அறிவிப்புகள்

'using' கூற்று இரண்டு முதன்மை வடிவங்களைக் கொண்டுள்ளது: மறைமுகமான மற்றும் வெளிப்படையான. மேலே உள்ள எடுத்துக்காட்டுகள் பெரும்பாலும் வெளிப்படையான அறிவிப்புகளைக் காட்டின.

வெளிப்படையான Using

எடுத்துக்காட்டுகளில் காணப்படுவது போல, வெளிப்படையான அறிவிப்புகளுக்கு `using` அடைப்புக்குறிக்குள் அறிவிக்கப்படும் மாறிக்கு முன் ஒரு `const` முக்கியச்சொல் தேவைப்படுகிறது (அல்லது ஒத்திசைவற்ற அகற்றுதலுக்கு `await` ஐத் தொடர்ந்து `const`). இது வளத்தை `using` தொகுதிக்கு மட்டுமே வரம்பிற்குட்படுத்துவதை உறுதி செய்கிறது. அந்தத் தொகுதிக்கு வெளியே வளத்தைப் பயன்படுத்த முயற்சித்தால் பிழை ஏற்படும். இது ஒரு கடுமையான வள ஆயுட்காலத்தை அமல்படுத்துகிறது, இது குறியீடு பாதுகாப்பை மேம்படுத்துகிறது மற்றும் தவறாகப் பயன்படுத்துவதற்கான திறனைக் குறைக்கிறது. வெளிப்படையான 'using' அறிவிப்பு, தொகுதியிலிருந்து வெளியேறும்போது ஒரு வளம் அகற்றப்படும் என்பதை மிகவும் தெளிவாகக் காட்டுகிறது.

            try (const file = new FileResource('example.txt')) {
  // Use file resource here
}
// file is no longer accessible here; attempting to use 'file' would cause an error

            

              
                Copy
              
            
          

மறைமுகமான Using

மறுபுறம், மறைமுகமான 'using' அறிவிப்புகள், வளத்தை *வெளிப்புற வரம்புடன்* பிணைக்கின்றன. இது `const` முக்கியச்சொல்லை *விடுவதன்* மூலம் அடையப்படுகிறது. இது வசதியாகத் தோன்றினாலும், இது பொதுவாக ஊக்குவிக்கப்படுவதில்லை ஏனெனில் இது குழப்பத்திற்கும், வளம் அகற்றப்பட்ட பிறகு தற்செயலாக தவறாகப் பயன்படுத்தப்படுவதற்கும் வழிவகுக்கும். ஒரு மறைமுகமான அறிவிப்புடன், `using` கூற்றில் அறிவிக்கப்பட்ட மாறி `using` தொகுதிக்கு வெளியே அணுகக்கூடியதாக இருக்கும், அது வைத்திருக்கும் வளம் அகற்றப்பட்டிருந்தாலும் கூட. அகற்றப்பட்ட வளத்தை குறியீடு பயன்படுத்த முயற்சித்தால் இது இயக்க நேரப் பிழைகளுக்கு வழிவகுக்கும்.

            let file;
try (file = new FileResource('example.txt')) {
  // Use file resource here
}
// file is still accessible here, but the resource it holds has been disposed!
// Using 'file' here will likely cause an error or unexpected behavior.

            

              
                Copy
              
            
          

குறியீட்டின் தெளிவை மேம்படுத்தவும், அகற்றப்பட்ட வளங்களை தற்செயலாக அணுகுவதைத் தடுக்கவும் வெளிப்படையான `using` அறிவிப்புகளை (`const`) பயன்படுத்த கடுமையாகப் பரிந்துரைக்கப்படுகிறது.

'Using' கூற்றைப் பயன்படுத்துவதன் நன்மைகள்

• தானியங்கி வள அகற்றுதல்: வளங்கள் தேவைப்படாதபோது எப்போதும் விடுவிக்கப்படுவதை உறுதி செய்கிறது, வளக் கசிவுகளைத் தடுத்து பயன்பாட்டின் நம்பகத்தன்மையை மேம்படுத்துகிறது.
• எளிமைப்படுத்தப்பட்ட குறியீடு: வள மேலாண்மைக்குத் தேவைப்படும் பாய்லர்பிளேட் குறியீட்டின் அளவைக் குறைக்கிறது, குறியீட்டைத் தூய்மையாகவும் புரிந்துகொள்ள எளிதாகவும் ஆக்குகிறது. சுத்தம் செய்ய `try...finally` தொகுதிகள் தேவையில்லை.
• மேம்படுத்தப்பட்ட பிழை கையாளுதல்: விதிவிலக்குகள் எறியப்படும்போதும் வள அகற்றுதலைத் தானாகவே கையாளுகிறது, செயல்பாட்டின் விளைவைப் பொருட்படுத்தாமல் வளங்கள் எப்போதும் விடுவிக்கப்படுவதை உறுதி செய்கிறது.
• தீர்மானிக்கப்பட்ட அகற்றுதல்: குப்பை சேகரிப்பை மட்டும் நம்பியிருப்பதை விட வளங்களை நிர்வகிக்க மிகவும் தீர்மானிக்கப்பட்ட வழியை வழங்குகிறது. குப்பை சேகரிப்பு இன்னும் முக்கியமானதாக இருந்தாலும், 'using' கூற்று வளங்கள் எப்போது விடுவிக்கப்பட வேண்டும் என்பதில் உங்களுக்கு அதிக கட்டுப்பாட்டைக் கொடுக்கிறது.
• மேம்படுத்தப்பட்ட குறியீடு பாதுகாப்பு: வளங்கள் சரியாக அகற்றப்படுவதையும், 'using' தொகுதி வெளியேறிய பிறகு (வெளிப்படையான அறிவிப்புகளுடன்) அணுக முடியாததையும் உறுதி செய்வதன் மூலம் வளங்களை தற்செயலாக தவறாகப் பயன்படுத்துவதைத் தடுக்கிறது.

'Using' கூற்றிற்கான பயன்பாட்டு வழக்குகள்

வள மேலாண்மை முக்கியமானதாக இருக்கும் பரந்த அளவிலான சூழ்நிலைகளில் 'using' கூற்று பொருந்தும். இங்கே சில பொதுவான பயன்பாட்டு வழக்குகள்:

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

பல்வேறு தொழில்களில் இருந்து எடுத்துக்காட்டுகள்:

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

'Using' கூற்றைப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

'using' கூற்றிலிருந்து அதிகப் பயனைப் பெற, பின்வரும் சிறந்த நடைமுறைகளைக் கவனியுங்கள்:

• எப்போதும் வெளிப்படையான அறிவிப்புகளைப் பயன்படுத்தவும்: வளங்கள் 'using' தொகுதிக்கு மட்டுமே வரம்பிற்குட்பட்டவை என்பதை உறுதிப்படுத்தவும், தற்செயலான தவறான பயன்பாட்டைத் தடுக்கவும், குறியீட்டின் தெளிவை மேம்படுத்தவும் வெளிப்படையான 'using' அறிவிப்புகளை (`const`) பயன்படுத்தவும்.
• Dispose முறைகளை சரியாக செயல்படுத்தவும்: 'Symbol.dispose' அல்லது 'Symbol.asyncDispose' முறைகள் சரியாக செயல்படுத்தப்படுவதை உறுதிசெய்து, பொருளால் வைத்திருக்கும் அனைத்து வளங்களையும் முறையாக விடுவிக்கவும். விதிவிலக்குகள் பரவுவதைத் தடுக்க இந்த முறைகளுக்குள் சாத்தியமான பிழைகளைக் கையாளவும்.
• நீண்ட காலம் வாழும் வளங்களைத் தவிர்க்கவும்: வளக் கசிவுகளின் திறனைக் குறைக்க வளங்களின் ஆயுட்காலத்தைக் குறைக்கவும். வளங்கள் தேவைப்படாதவுடன் விடுவிக்கப்படுவதை உறுதிசெய்ய 'using' கூற்றைப் பயன்படுத்தவும்.
• உங்கள் குறியீட்டை முழுமையாக சோதிக்கவும்: வளங்கள் முறையாக அகற்றப்படுகின்றனவா என்பதை உறுதிப்படுத்த உங்கள் குறியீட்டை முழுமையாக சோதிக்கவும். ஏதேனும் வளக் கசிவுகளைக் கண்டறிந்து சரிசெய்ய நினைவக சுயவிவரக் கருவிகளைப் பயன்படுத்தவும்.
• கூடு கட்டப்பட்ட 'using' கூற்றுகளைக் கவனியுங்கள்: பல வளங்களுடன் பணிபுரியும்போது, வளங்கள் சரியான வரிசையில் விடுவிக்கப்படுவதை உறுதிசெய்ய கூடு கட்டப்பட்ட 'using' கூற்றுகளைப் பயன்படுத்துவதைக் கவனியுங்கள்.
• விதிவிலக்குகளைக் கையாளவும்: 'using' விதிவிலக்குகளில் அகற்றுதலைக் கையாண்டாலும், உங்கள் வளம்-பயன்படுத்தும் குறியீட்டுத் தொகுதிக்குள் சரியான விதிவிலக்கு கையாளுதலை உறுதிப்படுத்தவும். இது கையாளப்படாத நிராகரிப்புகளைத் தடுக்கிறது.
• உங்கள் வள மேலாண்மையை ஆவணப்படுத்தவும்: எந்த வகுப்புகள் வளங்களை நிர்வகிக்கின்றன மற்றும் 'using' கூற்று எவ்வாறு பயன்படுத்தப்பட வேண்டும் என்பதை தெளிவாக ஆவணப்படுத்தவும்.

உலாவி மற்றும் Node.js ஆதரவு

'using' கூற்று ஜாவாஸ்கிரிப்டில் ஒப்பீட்டளவில் ஒரு புதிய அம்சமாகும். எழுதும் நேரத்தில் (2024), இது TC39 நிலை 4 முன்மொழிவின் ஒரு பகுதியாகும் மற்றும் நவீன உலாவிகள் மற்றும் Node.js இல் ஆதரிக்கப்படுகிறது. இருப்பினும், பழைய உலாவிகள் அல்லது Node.js பதிப்புகள் அதை ஆதரிக்காமல் இருக்கலாம். பழைய சூழல்களில் உங்கள் குறியீடு சரியாக இயங்குவதை உறுதிசெய்ய நீங்கள் பேபல் போன்ற ஒரு டிரான்ஸ்பைலரைப் பயன்படுத்த வேண்டியிருக்கலாம்.

உலாவி ஆதரவு: Chrome, Firefox, Safari, மற்றும் Edge ஆகியவற்றின் நவீன பதிப்புகள் பொதுவாக 'using' கூற்றை ஆதரிக்கின்றன. மிகவும் புதுப்பித்த தகவலுக்கு MDN வலை ஆவணங்கள் போன்ற பொருந்தக்கூடிய அட்டவணைகளை சரிபார்க்கவும்.

Node.js ஆதரவு: Node.js பதிப்புகள் 16 மற்றும் அதற்குப் பிந்தையவை 'using' கூற்றை ஆதரிக்கின்றன. உங்கள் Node.js பதிப்பு புதுப்பித்த நிலையில் உள்ளதா என்பதை உறுதிப்படுத்தவும்.

'Using' கூற்றிற்கான மாற்று வழிகள்

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

            let file;
try {
  file = new FileResource('example.txt');
  // Use file resource here
} catch (err) {
  console.error('An error occurred:', err);
} finally {
  if (file) {
    file[Symbol.dispose]();
  }
}

            

              
                Copy
              
            
          

'try...finally' தொகுதி, வளம் உள்ளதா என்பதை நீங்கள் கைமுறையாகச் சரிபார்த்து, பின்னர் dispose முறையை அழைக்க வேண்டும். இது சிரமமாக இருக்கலாம், குறிப்பாக பல வளங்களைக் கையாளும்போது. 'using' கூற்று வள அகற்றுதலை தானியக்கமாக்குவதன் மூலம் இந்த செயல்முறையை எளிதாக்குகிறது, குறியீட்டைத் தூய்மையாகவும் பராமரிக்க எளிதாகவும் ஆக்குகிறது.

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

முடிவுரை

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

மேலும் கற்றுக்கொள்ள

• TC39 முன்மொழிவுகள்: சமீபத்திய மேம்பாடுகள் குறித்து புதுப்பித்த நிலையில் இருக்க, 'using' கூற்றிற்கான TC39 முன்மொழிவுகளைப் பின்பற்றவும்.
• MDN வலை ஆவணங்கள்: 'using' கூற்று மற்றும் அதன் பயன்பாடு குறித்த விரிவான ஆவணங்களுக்கு MDN வலை ஆவணங்களைப் பார்க்கவும்.
• ஆன்லைன் பயிற்சிகள் மற்றும் எடுத்துக்காட்டுகள்: 'using' கூற்றுடன் நடைமுறை அனுபவத்தைப் பெற ஆன்லைன் பயிற்சிகள் மற்றும் எடுத்துக்காட்டுகளை ஆராயுங்கள்.