ஜாவாஸ்கிரிப்ட் நினைவக மேலாண்மை: குப்பை சேகரிப்பு மேம்படுத்தல்

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

ஜாவாஸ்கிரிப்டில் நினைவக மேலாண்மையைப் புரிந்துகொள்வது

ஜாவாஸ்கிரிப்டில், நினைவக மேலாண்மை என்பது தரவைச் சேமிப்பதற்கும் குறியீட்டை இயக்குவதற்கும் நினைவகத்தை ஒதுக்குதல் மற்றும் விடுவிக்கும் செயல்முறையாகும். ஜாவாஸ்கிரிப்ட் இயந்திரம் (குரோம் மற்றும் நோட்.js-ல் V8, பயர்பாக்ஸில் ஸ்பைடர்மாங்கி, அல்லது சஃபாரியில் ஜாவாஸ்கிரிப்ட்கோர் போன்றவை) தானாகவே நினைவகத்தை நிர்வகிக்கிறது. இந்த செயல்முறை இரண்டு முக்கிய நிலைகளை உள்ளடக்கியது:

• நினைவக ஒதுக்கீடு: மாறிகள், பொருள்கள், செயல்பாடுகள் மற்றும் பிற தரவு கட்டமைப்புகளுக்கு நினைவக இடத்தை ஒதுக்குதல்.
• நினைவக நீக்கம் (குப்பை சேகரிப்பு): பயன்பாட்டால் இனி பயன்படுத்தப்படாத நினைவகத்தை மீட்டெடுத்தல்.

நினைவக மேலாண்மையின் முதன்மை நோக்கம் நினைவகம் திறமையாகப் பயன்படுத்தப்படுவதை உறுதிசெய்வதும், நினைவகக் கசிவுகளைத் தடுப்பதும் (பயன்படுத்தப்படாத நினைவகம் விடுவிக்கப்படாதபோது) மற்றும் ஒதுக்கீடு மற்றும் நீக்கத்துடன் தொடர்புடைய மேல்நிலையைக் குறைப்பதும் ஆகும்.

ஜாவாஸ்கிரிப்ட் நினைவக வாழ்க்கைச் சுழற்சி

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

1. ஒதுக்கு: நீங்கள் மாறிகள், பொருள்கள் அல்லது செயல்பாடுகளை உருவாக்கும்போது ஜாவாஸ்கிரிப்ட் இயந்திரம் நினைவகத்தை ஒதுக்குகிறது.
2. பயன்படுத்து: உங்கள் பயன்பாடு ஒதுக்கப்பட்ட நினைவகத்தைப் பயன்படுத்தி தரவைப் படிக்கவும் எழுதவும் செய்கிறது.
3. விடுவி: ஜாவாஸ்கிரிப்ட் இயந்திரம் நினைவகம் இனி தேவையில்லை என்று தீர்மானிக்கும்போது தானாகவே அதை விடுவிக்கிறது. இங்குதான் குப்பை சேகரிப்பு devreக்கு வருகிறது.

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

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

• குறி மற்றும் துடைத்தல் (Mark and Sweep): இது மிகவும் பொதுவான குப்பை சேகரிப்பு வழிமுறையாகும். இது இரண்டு கட்டங்களை உள்ளடக்கியது:
• குறி: குப்பை சேகரிப்பான், ரூட் பொருள்களிலிருந்து (எ.கா., குளோபல் மாறிகள்) தொடங்கி, பொருள் வரைபடத்தை கடந்து, அணுகக்கூடிய அனைத்து பொருள்களையும் "உயிருடன்" எனக் குறிக்கிறது.
• துடைத்தல்: குப்பை சேகரிப்பான் குவியலை (டைனமிக் ஒதுக்கீட்டிற்குப் பயன்படுத்தப்படும் நினைவகப் பகுதி) துடைத்து, குறிக்கப்படாத பொருள்களை (அணுக முடியாதவை) அடையாளம் கண்டு, அவை ஆக்கிரமித்த நினைவகத்தை மீட்டெடுக்கிறது.
• குறிப்பு எண்ணுதல் (Reference Counting): இந்த வழிமுறை ஒவ்வொரு பொருளுக்கும் உள்ள குறிப்புகளின் எண்ணிக்கையைக் கண்காணிக்கும். ஒரு பொருளின் குறிப்பு எண்ணிக்கை பூஜ்ஜியத்தை அடையும்போது, அந்த பொருள் இனி பயன்பாட்டின் எந்தப் பகுதியாலும் குறிப்பிடப்படவில்லை என்று அர்த்தம், மற்றும் அதன் நினைவகத்தை மீட்டெடுக்க முடியும். செயல்படுத்த எளிமையானதாக இருந்தாலும், குறிப்பு எண்ணுதல் ஒரு பெரிய வரம்பைக் கொண்டுள்ளது: இது வட்டக் குறிப்புகளை (பொருள்கள் ஒன்றையொன்று குறிப்பிடும்போது, அவற்றின் குறிப்பு எண்ணிக்கைகள் பூஜ்ஜியத்தை அடைவதைத் தடுக்கும் ஒரு சுழற்சியை உருவாக்குகிறது) கண்டறிய முடியாது.
• தலைமுறை குப்பை சேகரிப்பு (Generational Garbage Collection): இந்த அணுகுமுறை குவியலை பொருள்களின் வயதின் அடிப்படையில் "தலைமுறைகளாக" பிரிக்கிறது. இளைய பொருள்கள் பழைய பொருள்களை விட குப்பையாக மாற வாய்ப்புள்ளது என்பதே இதன் யோசனை. குப்பை சேகரிப்பான் "இளம் தலைமுறையை" அடிக்கடி சேகரிப்பதில் கவனம் செலுத்துகிறது, இது பொதுவாக மிகவும் திறமையானது. பழைய தலைமுறைகள் குறைவாக அடிக்கடி சேகரிக்கப்படுகின்றன. இது "தலைமுறை கருதுகோளின்" அடிப்படையில் அமைந்துள்ளது.

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

குப்பை சேகரிப்பு எடுத்துக்காட்டு

பின்வரும் ஜாவாஸ்கிரிப்ட் குறியீட்டைக் கவனியுங்கள்:

function createObject() {
 let obj = { name: "Example", value: 123 };
 return obj;
}

let myObject = createObject();
myObject = null; // பொருளுக்கான குறிப்பை அகற்றவும்

இந்த எடுத்துக்காட்டில், createObject செயல்பாடு ஒரு பொருளை உருவாக்கி அதை myObject மாறிக்கு ஒதுக்குகிறது. myObject ஐ null க்கு அமைக்கும்போது, பொருளுக்கான குறிப்பு அகற்றப்படுகிறது. குப்பை சேகரிப்பான் இறுதியில் அந்தப் பொருள் இனி அணுக முடியாதது என்று கண்டறிந்து அது ஆக்கிரமித்த நினைவகத்தை மீட்டெடுக்கும்.

ஜாவாஸ்கிரிப்டில் நினைவகக் கசிவுகளுக்கான பொதுவான காரணங்கள்

நினைவகக் கசிவுகள் பயன்பாட்டு செயல்திறனை கணிசமாகக் குறைத்து செயலிழப்புகளுக்கு வழிவகுக்கும். அவற்றைத் தடுப்பதற்கு நினைவகக் கசிவுகளின் பொதுவான காரணங்களைப் புரிந்துகொள்வது அவசியம்.

• உலகளாவிய மாறிகள் (Global Variables): தற்செயலாக உலகளாவிய மாறிகளை உருவாக்குவது (var, let, அல்லது const முக்கிய வார்த்தைகளைத் தவிர்ப்பதன் மூலம்) நினைவகக் கசிவுகளுக்கு வழிவகுக்கும். உலகளாவிய மாறிகள் பயன்பாட்டின் வாழ்க்கைச் சுழற்சி முழுவதும் நீடிக்கும், அவற்றின் நினைவகத்தை குப்பை சேகரிப்பான் மீட்டெடுப்பதைத் தடுக்கிறது. எப்போதும் பொருத்தமான வரம்பிற்குள் let அல்லது const (அல்லது உங்களுக்கு செயல்பாடு-சார்ந்த நடத்தை தேவைப்பட்டால் var) பயன்படுத்தி மாறிகளை அறிவிக்கவும்.
• மறக்கப்பட்ட டைமர்கள் மற்றும் கால்பேக்குகள் (Forgotten Timers and Callbacks): setInterval அல்லது setTimeout ஐ சரியாக அழிக்காமல் பயன்படுத்துவது நினைவகக் கசிவுகளை ஏற்படுத்தலாம். இந்த டைமர்களுடன் தொடர்புடைய கால்பேக்குகள் பொருள்கள் இனி தேவைப்படாத பிறகும் அவற்றை உயிர்ப்புடன் வைத்திருக்கலாம். டைமர்கள் இனி தேவைப்படாதபோது அவற்றை அகற்ற clearInterval மற்றும் clearTimeout ஐப் பயன்படுத்தவும்.
• மூடுதல்கள் (Closures): மூடுதல்கள் சில நேரங்களில் பெரிய பொருள்களுக்கான குறிப்புகளை கவனக்குறைவாகப் பிடித்துக்கொண்டால் நினைவகக் கசிவுகளுக்கு வழிவகுக்கும். மூடுதல்களால் பிடிக்கப்பட்ட மாறிகளைக் கவனத்தில் கொண்டு, அவை தேவையற்ற முறையில் நினைவகத்தைப் பிடித்துக் கொண்டிருக்கவில்லை என்பதை உறுதிப்படுத்தவும்.
• DOM கூறுகள் (DOM Elements): ஜாவாஸ்கிரிப்ட் குறியீட்டில் DOM கூறுகளுக்கான குறிப்புகளை வைத்திருப்பது அவை குப்பை சேகரிக்கப்படுவதைத் தடுக்கலாம், குறிப்பாக அந்தக் கூறுகள் DOM-லிருந்து அகற்றப்பட்டால். இது இன்டர்நெட் எக்ஸ்ப்ளோரரின் பழைய பதிப்புகளில் மிகவும் பொதுவானது.
• வட்டக் குறிப்புகள் (Circular References): முன்னர் குறிப்பிட்டபடி, பொருள்களுக்கு இடையிலான வட்டக் குறிப்புகள் குறிப்பு எண்ணும் குப்பை சேகரிப்பாளர்கள் நினைவகத்தை மீட்டெடுப்பதைத் தடுக்கலாம். நவீன குப்பை சேகரிப்பாளர்கள் (குறி மற்றும் துடைத்தல் போன்றவை) பொதுவாக வட்டக் குறிப்புகளைக் கையாள முடியும் என்றாலும், முடிந்தவரை அவற்றைத் தவிர்ப்பது நல்லது.
• நிகழ்வு கேட்பான்கள் (Event Listeners): DOM கூறுகளிலிருந்து நிகழ்வு கேட்பான்களை இனி தேவைப்படாதபோது அகற்ற மறப்பதும் நினைவகக் கசிவுகளை ஏற்படுத்தும். நிகழ்வு கேட்பான்கள் தொடர்புடைய பொருள்களை உயிர்ப்புடன் வைத்திருக்கின்றன. நிகழ்வு கேட்பான்களை பிரிக்க removeEventListener ஐப் பயன்படுத்தவும். டைனமிக்காக உருவாக்கப்பட்ட அல்லது அகற்றப்பட்ட DOM கூறுகளுடன் கையாளும்போது இது மிகவும் முக்கியமானது.

ஜாவாஸ்கிரிப்ட் குப்பை சேகரிப்பு மேம்படுத்தல் நுட்பங்கள்

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

1. தேவையற்ற பொருள்களை உருவாக்குவதைத் தவிர்க்கவும்

அதிக எண்ணிக்கையிலான தற்காலிக பொருள்களை உருவாக்குவது குப்பை சேகரிப்பானுக்கு அழுத்தம் கொடுக்கலாம். ஒதுக்கீடுகள் மற்றும் நீக்கங்களின் எண்ணிக்கையைக் குறைக்க முடிந்தவரை பொருள்களை மீண்டும் பயன்படுத்தவும்.

எடுத்துக்காட்டு: ஒரு லூப்பின் ஒவ்வொரு மறு செய்கையிலும் ஒரு புதிய பொருளை உருவாக்குவதற்குப் பதிலாக, ஏற்கனவே உள்ள ஒரு பொருளை மீண்டும் பயன்படுத்தவும்.

// திறமையற்றது: ஒவ்வொரு மறு செய்கையிலும் ஒரு புதிய பொருளை உருவாக்குகிறது
for (let i = 0; i < 1000; i++) {
 let obj = { index: i };
 // ...
}

// திறமையானது: அதே பொருளை மீண்டும் பயன்படுத்துகிறது
let obj = {};
for (let i = 0; i < 1000; i++) {
 obj.index = i;
 // ...
}

2. உலகளாவிய மாறிகளைக் குறைக்கவும்

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

// தவறு: ஒரு உலகளாவிய மாறியை உருவாக்குகிறது
myGlobalVariable = "Hello";

// சரி: ஒரு செயல்பாட்டிற்குள் ஒரு உள்ளூர் மாறியைப் பயன்படுத்துகிறது
function myFunction() {
 let myLocalVariable = "Hello";
 // ...
}

3. டைமர்கள் மற்றும் கால்பேக்குகளை அழிக்கவும்

நினைவகக் கசிவுகளைத் தடுக்க டைமர்கள் மற்றும் கால்பேக்குகள் இனி தேவைப்படாதபோது அவற்றை எப்போதும் அழிக்கவும்.

let timerId = setInterval(function() {
 // ...
}, 1000);

// டைமர் இனி தேவைப்படாதபோது அதை அழிக்கவும்
clearInterval(timerId);

let timeoutId = setTimeout(function() {
 // ...
}, 5000);

// டைம்அவுட் இனி தேவைப்படாதபோது அதை அழிக்கவும்
clearTimeout(timeoutId);

4. நிகழ்வு கேட்பான்களை அகற்றவும்

DOM கூறுகளிலிருந்து நிகழ்வு கேட்பான்களை இனி தேவைப்படாதபோது பிரிக்கவும். டைனமிக்காக உருவாக்கப்பட்ட அல்லது அகற்றப்பட்ட கூறுகளுடன் கையாளும்போது இது மிகவும் முக்கியமானது.

let element = document.getElementById("myElement");

function handleClick() {
 // ...
}

element.addEventListener("click", handleClick);

// நிகழ்வு கேட்பான் இனி தேவைப்படாதபோது அதை அகற்றவும்
element.removeEventListener("click", handleClick);

5. வட்டக் குறிப்புகளைத் தவிர்க்கவும்

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

let obj1 = {};
let obj2 = {};

obj1.reference = obj2;
obj2.reference = obj1; // வட்டக் குறிப்பு

// வட்டக் குறிப்பை உடைக்கவும்
obj1.reference = null;
obj2.reference = null;

6. WeakMaps மற்றும் WeakSets ஐப் பயன்படுத்தவும்

WeakMap மற்றும் WeakSet என்பவை சிறப்பு வகை சேகரிப்புகளாகும், அவை அவற்றின் விசைகளை (WeakMap இல்) அல்லது மதிப்புகளை (WeakSet இல்) குப்பை சேகரிக்கப்படுவதைத் தடுக்காது. குப்பை சேகரிப்பாளரால் அந்தப் பொருள்கள் மீட்டெடுக்கப்படுவதைத் தடுக்காமல் பொருள்களுடன் தரவை இணைக்க அவை பயனுள்ளதாக இருக்கும்.

WeakMap எடுத்துக்காட்டு:

let element = document.getElementById("myElement");
let data = new WeakMap();

data.set(element, { tooltip: "This is a tooltip" });

// கூறு DOM-லிருந்து அகற்றப்பட்டால், அது குப்பை சேகரிக்கப்படும்,
// மேலும் WeakMap-இல் உள்ள தொடர்புடைய தரவுகளும் அகற்றப்படும்.

WeakSet எடுத்துக்காட்டு:

let element = document.getElementById("myElement");
let trackedElements = new WeakSet();

trackedElements.add(element);

// கூறு DOM-லிருந்து அகற்றப்பட்டால், அது குப்பை சேகரிக்கப்படும்,
// மேலும் அது WeakSet-லிருந்தும் அகற்றப்படும்.

7. தரவு கட்டமைப்புகளை மேம்படுத்தவும்

உங்கள் தேவைகளுக்கு பொருத்தமான தரவு கட்டமைப்புகளைத் தேர்வு செய்யவும். திறமையற்ற தரவு கட்டமைப்புகளைப் பயன்படுத்துவது தேவையற்ற நினைவக நுகர்வு மற்றும் மெதுவான செயல்திறனுக்கு வழிவகுக்கும்.

எடுத்துக்காட்டாக, ஒரு சேகரிப்பில் ஒரு கூறு இருப்பதைக் அடிக்கடி சரிபார்க்க வேண்டுமானால், Array க்குப் பதிலாக Set ஐப் பயன்படுத்தவும். Array (O(n)) ஐ விட Set வேகமான தேடல் நேரங்களை (சராசரியாக O(1)) வழங்குகிறது.

8. டெபௌன்சிங் மற்றும் த்ராட்லிங்

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

function throttle(func, delay) {
 let timeoutId;
 let lastExecTime = 0;

 return function(...args) {
 const currentTime = Date.now();
 const timeSinceLastExec = currentTime - lastExecTime;

 if (!timeoutId) {
 if (timeSinceLastExec >= delay) {
 func.apply(this, args);
 lastExecTime = currentTime;
 } else {
 timeoutId = setTimeout(() => {
 func.apply(this, args);
 lastExecTime = Date.now();
 timeoutId = null;
 }, delay - timeSinceLastExec);
 }
 }
 };
}

function handleScroll() {
 console.log("Scroll event");
}

const throttledHandleScroll = throttle(handleScroll, 250); // அதிகபட்சம் ஒவ்வொரு 250msக்கும் இயக்கவும்

window.addEventListener("scroll", throttledHandleScroll);

9. குறியீடு பிரித்தல்

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

10. கணக்கீட்டு ரீதியாக தீவிரமான பணிகளுக்கு வலைப் பணியாளர்களைப் பயன்படுத்துதல்

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

// main.js
const worker = new Worker('worker.js');

worker.postMessage({ task: 'heavyComputation', data: [1, 2, 3] });

worker.onmessage = function(event) {
 console.log('Result from worker:', event.data);
};

// worker.js
self.onmessage = function(event) {
 const { task, data } = event.data;

 if (task === 'heavyComputation') {
 const result = performHeavyComputation(data);
 self.postMessage(result);
 }
};

function performHeavyComputation(data) {
 // கணக்கீட்டு ரீதியாக தீவிரமான பணியைச் செய்யவும்
 return data.map(x => x * 2);
}

நினைவகப் பயன்பாட்டை சுயவிவரப்படுத்துதல்

நினைவகக் கசிவுகளை அடையாளம் காணவும் நினைவகப் பயன்பாட்டை மேம்படுத்தவும், உலாவி டெவலப்பர் கருவிகளைப் பயன்படுத்தி உங்கள் பயன்பாட்டின் நினைவகப் பயன்பாட்டை சுயவிவரப்படுத்துவது அவசியம்.

குரோம் டெவ்டூல்ஸ்

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

1. குரோம் டெவ்டூல்ஸைத் திறக்கவும் (Ctrl+Shift+I அல்லது Cmd+Option+I).
2. "Memory" பேனலுக்குச் செல்லவும்.
3. "Heap snapshot" அல்லது "Allocation instrumentation on timeline" என்பதைத் தேர்ந்தெடுக்கவும்.
4. உங்கள் பயன்பாட்டின் செயல்பாட்டின் வெவ்வேறு புள்ளிகளில் குவியலின் ஸ்னாப்ஷாட்களை எடுக்கவும்.
5. நினைவகக் கசிவுகள் மற்றும் நினைவகப் பயன்பாடு அதிகமாக உள்ள பகுதிகளை அடையாளம் காண ஸ்னாப்ஷாட்களை ஒப்பிடவும்.

"Allocation instrumentation on timeline" காலப்போக்கில் நினைவக ஒதுக்கீடுகளைப் பதிவு செய்ய உங்களை அனுமதிக்கிறது, இது நினைவகக் கசிவுகள் எப்போது, எங்கே நிகழ்கின்றன என்பதைக் கண்டறிய உதவியாக இருக்கும்.

பயர்பாக்ஸ் டெவலப்பர் கருவிகள்

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

1. பயர்பாக்ஸ் டெவலப்பர் கருவிகளைத் திறக்கவும் (Ctrl+Shift+I அல்லது Cmd+Option+I).
2. "Performance" பேனலுக்குச் செல்லவும்.
3. செயல்திறன் சுயவிவரத்தைப் பதிவுசெய்யத் தொடங்கவும்.
4. நினைவகக் கசிவுகள் மற்றும் நினைவகப் பயன்பாடு அதிகமாக உள்ள பகுதிகளை அடையாளம் காண நினைவகப் பயன்பாட்டு வரைபடத்தை பகுப்பாய்வு செய்யவும்.

உலகளாவிய பரிசீலனைகள்

உலகளாவிய பார்வையாளர்களுக்காக ஜாவாஸ்கிரிப்ட் பயன்பாடுகளை உருவாக்கும்போது, நினைவக மேலாண்மை தொடர்பான பின்வரும் காரணிகளைக் கவனியுங்கள்:

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

முடிவுரை

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