TypeScript using முக்கியச்சொல் மற்றும் வெளிப்படையான வள மேலாண்மை (Explicit Resource Management)

தயாரிப்புச் சூழலில் (production) ஏற்படும் மெமரி லீக் (memory leaks) பெரும்பாலும் ஒரு பிழையிலிருந்தே உருவாகின்றன: டெவலப்பர்கள் வளங்களைப் (resources) பெறுகிறார்கள், ஆனால் அவற்றை விடுவிக்கத் தவறிவிடுகிறார்கள்.

பிழைகள் ஏற்பட்ட பின்னரும் தரவுத்தள இணைப்புகள் (Database connections) திறந்தே இருக்கும். கோப்பு கையாளிகள் (File handles) கணினி வளங்களைச் செலவழிக்கும். WebSocket கிளையண்டுகள் செயலிழந்த சேவையகங்களுடன் (servers) இணைந்தே இருக்கும். நீங்கள் finally பிளாக்குகளில் கைமுறையாகச் சுத்தம் செய்வதைச் சார்ந்திருக்கும்போது இது நிகழ்கிறது.

TypeScript-இன் using முக்கியச்சொல் இதற்குத் தீர்வாக அமைகிறது. இது ECMAScript Explicit Resource Management முன்மொழிவின் ஒரு பகுதியாகும். இது 'disposable pattern' மூலம் சுத்தம் செய்வதை உறுதி செய்கிறது. ஒரு வளமானது அதன் எல்லைக்குறிப்பிலிருந்து (scope) வெளியேறும்போது, TypeScript அதன் disposal method-ஐத் தானாகவே இயக்கும்.

இனி உங்களுக்கு கைமுறை finally பிளாக்குகள் தேவையில்லை. சுத்தம் செய்வதை நீங்கள் இனி மறக்க மாட்டீர்கள். இணைப்புகள் கசிவதையும் (leak) தடுக்கலாம்.

இது எவ்வாறு செயல்படுகிறது:

• using முக்கியச்சொல், வளங்கள் ஒரு எல்லைக்குறிப்பிலிருந்து (scope) வெளியேறும்போது அவற்றை விடுவிப்பதை உறுதி செய்கிறது.
• Disposable resources என்பது ஒத்திசைவு (sync) பணிகளுக்கு Symbol.dispose அல்லது ஒத்திசைவற்ற (async) பணிகளுக்கு Symbol.asyncDispose-ஐப் பயன்படுத்துகின்றன.
• TypeScript, using அறிவிப்புகளைத் தானியங்கி disposal stack-உடன் கூடிய try-finally பிளாக்குகளாக மாற்றுகிறது.
• இந்த முறை, முன்கூட்டியே திரும்புதல் (early returns),thrown exceptions அல்லது மறக்கப்பட்ட குறியீடுகளால் ஏற்படும் கசிவுகளைத் தடுக்கிறது.

தரவுத்தள இணைப்புகள், கோப்பு கையாளிகள், லாக்ஸ் (locks) அல்லது டைமர்கள் (timers) போன்ற குறிப்பிட்ட கால அளவு கொண்ட எந்தவொரு வளத்திற்கும் using-ஐப் பயன்படுத்தவும்.

இந்த நுட்பம் ஒரு 'disposal protocol'-ஐப் பயன்படுத்துகிறது. பொருள்கள் (Objects) Symbol.dispose மூலம் அடையாளப்படுத்தப்பட்ட ஒரு முறையை (method) செயல்படுத்துகின்றன. ஒரு எல்லைக்குறிப்பு (scope) இயல்பான நிறைவு, ஒரு return அல்லது ஒரு விதிவிலக்கு (exception) மூலம் வெளியேறும்போது, TypeScript அந்த முறையை அழைக்கும்.

கோப்பு கையாளியின் (file handle) உதாரணம்:

class FileHandle {
  private handle: number;

  constructor(path: string) {
    this.handle = openFileSync(path);
  }

  [Symbol.dispose]() {
    if (this.handle !== -1) {
      closeFileSync(this.handle);
      this.handle = -1;
    }
  }

  read(buffer: Buffer): number {
    return readSync(this.handle, buffer);
  }
}

function processFile(path: string) {
  using file = new FileHandle(path);
  const buffer = Buffer.alloc(1024);
  file.read(buffer);
}

இந்த disposal ஒரு உருவாக்கப்பட்ட finally பிளாக்கில் இயங்கும். ஒரு செயல்பாடு (function) பிழையைத் தூண்டினாலும் அல்லது முன்கூட்டியே திரும்பினாலும் இது இயங்கும்.

TypeScript ஒரு disposal stack-ஐப் பராமரிக்கிறது. நீங்கள் வளங்களைப் பெற்ற வரிசையின் தலைகீழ் வரிசையில் அவை விடுவிக்கப்படுகின்றன. இது பெரும்பாலான சுத்தம் செய்யும் தர்க்கங்களின் (cleanup logic) இயல்பான சார்பு வரிசைக்கு (dependency order) பொருந்துகிறது.

ஒத்திசைவற்ற (asynchronous) சுத்தம் செய்வதற்கு, await using-ஐப் பயன்படுத்தவும். இதற்கு அந்த வளமானது Symbol.asyncDispose-ஐச் செயல்படுத்த வேண்டும். TypeScript தொடர்வதற்கு முன் திரும்பப் பெறப்பட்ட Promise-க்காகக் காத்திருக்கும் (await).

வெற்றிக்கான மூன்று விதிகள்:

• உங்கள் disposal methods-க்குள் விதிவிலக்குகளை (exceptions) வீச வேண்டாம். அதற்குப் பதிலாக பிழைகளைப் பிடித்து (catch) உள்நாட்டிலேயே பதிவு (log) செய்யவும்.
• ஒரு ஒத்திசைவு (synchronous) Symbol.dispose முறையினுள் ஒத்திசைவற்ற (async) செயல்பாடுகளைப் பயன்படுத்த வேண்டாம். அதற்குப் பதிலாக Symbol.asyncDispose-ஐப் பயன்படுத்தவும்.
• using அறிவிப்புகள் 'block-scoped' என்பதை நினைவில் கொள்ளுங்கள். ஒரு if பிளாக்கிற்குள் இருக்கும் ஒரு வளமானது, அந்த பிளாக் முடிவடையும் போது விடுவிக்கப்படும், செயல்பாடு (function) முடிவடையும் போது அல்ல.

இந்த முறை மிகக்குறைந்த இயக்கச் செலவில் (runtime cost) பாதுகாப்பை வழங்குகிறது.

Source: https://dev.to/jsmanifest/typescript-using-keyword-and-explicit-resource-management-done-right-22pg