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

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

அடிப்படைகளைப் புரிந்துகொள்ளுதல்: ஜாவாஸ்கிரிப்டில் பண்பு அணுகல்

ஜாவாஸ்கிரிப்டில், ஒரு ஆப்ஜெக்ட்டின் பண்புகளை அணுகுவது எளிமையானதாகத் தெரிகிறது: நீங்கள் டாட் நோட்டேஷன் (object.property) அல்லது பிராக்கெட் நோட்டேஷன் (object['property']) பயன்படுத்தலாம். இருப்பினும், பின்னணியில், பண்புடன் தொடர்புடைய மதிப்பைக் கண்டறிந்து மீட்டெடுக்க இன்ஜின் பல செயல்பாடுகளைச் செய்ய வேண்டும். இந்த செயல்பாடுகள் எப்போதும் நேரடியானவை அல்ல, குறிப்பாக ஜாவாஸ்கிரிப்டின் ஆற்றல்மிக்க தன்மையைக் கருத்தில் கொள்ளும்போது.

இந்த உதாரணத்தைக் கவனியுங்கள்:

const obj = { x: 10, y: 20 };
console.log(obj.x); // 'x' பண்பை அணுகுதல்

இன்ஜின் முதலில் செய்ய வேண்டியவை:

• obj ஒரு சரியான ஆப்ஜெக்ட் தானா என்று சரிபார்க்கவும்.
• ஆப்ஜெக்ட்டின் கட்டமைப்பிற்குள் x என்ற பண்பைக் கண்டறியவும்.
• x உடன் தொடர்புடைய மதிப்பைப் பெறவும்.

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

இன்லைன் கேச்சிங்: ஒரு செயல்திறன் ஊக்கி

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

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

1. முதல் அணுகல்: ஒரு பண்பு முதல் முறையாக அணுகப்படும்போது, இன்ஜின் முழு தேடல் செயல்முறையையும் செய்கிறது, ஆப்ஜெக்ட்டிற்குள் பண்பின் இருப்பிடத்தை அடையாளம் காண்கிறது.
2. கேச்சிங்: இன்ஜின், பண்பின் இருப்பிடம் (எ.கா., நினைவகத்தில் அதன் ஆஃப்செட்) மற்றும் ஆப்ஜெக்ட்டின் மறைக்கப்பட்ட வகுப்பு (hidden class) (இதைப் பற்றி பின்னர்) பற்றிய தகவல்களை, அணுகலைச் செய்த குறிப்பிட்ட குறியீட்டு வரியுடன் தொடர்புடைய ஒரு சிறிய இன்லைன் கேச்சில் சேமிக்கிறது.
3. அடுத்தடுத்த அணுகல்கள்: அதே குறியீட்டு இடத்திலிருந்து அதே பண்பிற்கு அடுத்தடுத்த அணுகல்களின் போது, இன்ஜின் முதலில் இன்லைன் கேச்சை சரிபார்க்கிறது. கேச்சில் ஆப்ஜெக்ட்டின் தற்போதைய மறைக்கப்பட்ட வகுப்பிற்கான சரியான தகவல் இருந்தால், இன்ஜின் முழு தேடலைச் செய்யாமல் நேரடியாக பண்பு மதிப்பை மீட்டெடுக்க முடியும்.

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

மறைக்கப்பட்ட வகுப்புகள்: திறமையான கேச்சிங்கின் திறவுகோல்

இன்லைன் கேச்சிங்கைப் புரிந்துகொள்வதற்கான ஒரு முக்கிய கருத்து மறைக்கப்பட்ட வகுப்புகள் (hidden classes) (வரைபடங்கள் அல்லது வடிவங்கள் என்றும் அழைக்கப்படுகிறது) ஆகும். மறைக்கப்பட்ட வகுப்புகள் என்பது ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்களின் கட்டமைப்பைக் குறிக்க V8 பயன்படுத்தும் உள் தரவு கட்டமைப்புகளாகும். அவை ஒரு ஆப்ஜெக்ட்டில் உள்ள பண்புகளையும் நினைவகத்தில் அவற்றின் அமைப்பையும் விவரிக்கின்றன.

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

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

இந்த உதாரணத்தைக் கவனியுங்கள்:

const obj1 = { x: 10, y: 20 };
const obj2 = { x: 5, y: 15 };
const obj3 = { y: 30, x: 40 }; // வெவ்வேறு பண்பு வரிசை

// obj1 மற்றும் obj2 பெரும்பாலும் ஒரே மறைக்கப்பட்ட வகுப்பைப் பகிர்ந்து கொள்ளும்
// obj3 ஒரு ভিন্ন மறைக்கப்பட்ட வகுப்பைக் கொண்டிருக்கும்

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

பாலிமார்பிஸம் மற்றும் இன்லைன் கேச் நடத்தை

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

ஒரு குறிப்பிட்ட பண்பு அணுகல் தளத்தில் எதிர்கொள்ளப்படும் வெவ்வேறு மறைக்கப்பட்ட வகுப்புகளின் எண்ணிக்கையின் அடிப்படையில், இன்லைன் கேச்களை இவ்வாறு வகைப்படுத்தலாம்:

• மோனோமார்பிக் (Monomorphic): பண்பு அணுகல் தளம் ஒரே ஒரு மறைக்கப்பட்ட வகுப்பின் ஆப்ஜெக்ட்களை மட்டுமே எதிர்கொண்டுள்ளது. இது இன்லைன் கேச்சிங்கிற்கு சிறந்த சூழ்நிலையாகும், ஏனெனில் இன்ஜின் கேச் செய்யப்பட்ட பண்பு இருப்பிடத்தை நம்பிக்கையுடன் மீண்டும் பயன்படுத்த முடியும்.
• பாலிமார்பிக் (Polymorphic): பண்பு அணுகல் தளம் பல (வழக்கமாக ஒரு சிறிய எண்ணிக்கை) மறைக்கப்பட்ட வகுப்புகளின் ஆப்ஜெக்ட்களை எதிர்கொண்டுள்ளது. இன்ஜின் பல சாத்தியமான பண்பு இருப்பிடங்களைக் கையாள வேண்டும். V8 பாலிமார்பிக் இன்லைன் கேச்களை ஆதரிக்கிறது, இது மறைக்கப்பட்ட வகுப்பு/பண்பு இருப்பிட ஜோடிகளின் ஒரு சிறிய அட்டவணையை சேமிக்கிறது.
• மெகாமார்பிக் (Megamorphic): பண்பு அணுகல் தளம் அதிக எண்ணிக்கையிலான வெவ்வேறு மறைக்கப்பட்ட வகுப்புகளின் ஆப்ஜெக்ட்களை எதிர்கொண்டுள்ளது. இந்த சூழ்நிலையில் இன்லைன் கேச்சிங் பயனற்றதாகிவிடும், ஏனெனில் இன்ஜினால் சாத்தியமான அனைத்து மறைக்கப்பட்ட வகுப்பு/பண்பு இருப்பிட ஜோடிகளையும் திறமையாக சேமிக்க முடியாது. மெகாமார்பிக் சந்தர்ப்பங்களில், V8 பொதுவாக மெதுவான, பொதுவான பண்பு அணுகல் பொறிமுறைக்குத் திரும்புகிறது.

இதை ஒரு உதாரணத்துடன் விளக்குவோம்:

function getX(obj) {
  return obj.x;
}

const obj1 = { x: 10, y: 20 };
const obj2 = { x: 5, z: 15 };
const obj3 = { x: 7, a: 8, b: 9 };

console.log(getX(obj1)); // முதல் அழைப்பு: மோனோமார்பிக்
console.log(getX(obj2)); // இரண்டாவது அழைப்பு: பாலிமார்பிக் (இரண்டு மறைக்கப்பட்ட வகுப்புகள்)
console.log(getX(obj3)); // மூன்றாவது அழைப்பு: மெகாமார்பிக் ஆக வாய்ப்புள்ளது (சில மறைக்கப்பட்ட வகுப்புகளுக்கு மேல்)

இந்த எடுத்துக்காட்டில், getX ஃபங்ஷன் ஆரம்பத்தில் மோனோமார்பிக் ஆகும், ஏனெனில் அது ஒரே மறைக்கப்பட்ட வகுப்பைக் கொண்ட ஆப்ஜெக்ட்களில் மட்டுமே செயல்படுகிறது (ஆரம்பத்தில், obj1 போன்ற ஆப்ஜெக்ட்கள் மட்டுமே). இருப்பினும், obj2 உடன் அழைக்கப்படும்போது, இன்லைன் கேச் பாலிமார்பிக் ஆகிறது, ஏனெனில் அது இப்போது இரண்டு வெவ்வேறு மறைக்கப்பட்ட வகுப்புகளைக் கொண்ட ஆப்ஜெக்ட்களை (obj1 மற்றும் obj2 போன்ற ஆப்ஜெக்ட்கள்) கையாள வேண்டும். obj3 உடன் அழைக்கப்படும்போது, அதிகமான மறைக்கப்பட்ட வகுப்புகளை எதிர்கொண்டதால் இன்ஜின் இன்லைன் கேச்சை செல்லாததாக்க வேண்டியிருக்கும், மேலும் பண்பு அணுகல் குறைவாக மேம்படுத்தப்படும்.

செயல்திறனில் பாலிமார்பிஸத்தின் தாக்கம்

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

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

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

நடைமுறை எடுத்துக்காட்டுகள் மற்றும் மேம்படுத்தல் உத்திகள்

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

1. சீரான ஆப்ஜெக்ட் வடிவங்கள்

ஒரே ஃபங்ஷனுக்கு அனுப்பப்படும் ஆப்ஜெக்ட்கள் ஒரு சீரான கட்டமைப்பைக் கொண்டிருப்பதை உறுதிசெய்க. அனைத்து பண்புகளையும் ஆற்றல்மிக்க முறையில் சேர்ப்பதற்குப் பதிலாக முன்கூட்டியே வரையறுக்கவும்.

தவறு (ஆற்றல்மிக்க பண்பு சேர்த்தல்):

function Point(x, y) {
  this.x = x;
  this.y = y;
}

const p1 = new Point(10, 20);
const p2 = new Point(5, 15);

if (Math.random() > 0.5) {
  p1.z = 30; // ஒரு பண்பை ஆற்றல்மிக்க முறையில் சேர்த்தல்
}

function printPointX(point) {
  console.log(point.x);
}

printPointX(p1);
printPointX(p2);

இந்த எடுத்துக்காட்டில், p1 ஒரு z பண்பைக் கொண்டிருக்கலாம், ஆனால் p2 கொண்டிருக்காது, இது வெவ்வேறு மறைக்கப்பட்ட வகுப்புகளுக்கும் printPointX-ல் குறைந்த செயல்திறனுக்கும் வழிவகுக்கிறது.

சரி (சீரான பண்பு வரையறை):

function Point(x, y, z) {
  this.x = x;
  this.y = y;
  this.z = z === undefined ? undefined : z; // 'z' வரையறுக்கப்படாததாக இருந்தாலும், எப்போதும் வரையறுக்கவும்
}

const p1 = new Point(10, 20, 30);
const p2 = new Point(5, 15);

function printPointX(point) {
  console.log(point.x);
}

printPointX(p1);
printPointX(p2);

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

2. பண்புகளை நீக்குவதைத் தவிர்க்கவும்

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

தவறு (பண்புகளை நீக்குதல்):

const obj = { a: 1, b: 2, c: 3 };

delete obj.b;

function accessA(object) {
  return object.a;
}

accessA(obj);

obj.b-ஐ நீக்குவது obj-இன் மறைக்கப்பட்ட வகுப்பை மாற்றுகிறது, இது accessA-இன் செயல்திறனை பாதிக்கக்கூடும்.

சரி (வரையறுக்கப்படாததாக அமைத்தல்):

const obj = { a: 1, b: 2, c: 3 };

obj.b = undefined; // நீக்குவதற்கு பதிலாக வரையறுக்கப்படாததாக அமைக்கவும்

function accessA(object) {
  return object.a;
}

accessA(obj);

ஒரு பண்பை undefined என அமைப்பது ஆப்ஜெக்ட்டின் மறைக்கப்பட்ட வகுப்பைப் பாதுகாக்கிறது மற்றும் இன்லைன் கேச்கள் செல்லாததாவதைத் தவிர்க்கிறது.

3. ஃபேக்டரி ஃபங்ஷன்களைப் பயன்படுத்தவும்

ஃபேக்டரி ஃபங்ஷன்கள் சீரான ஆப்ஜெக்ட் வடிவங்களைச் செயல்படுத்தவும் பாலிமார்பிஸத்தைக் குறைக்கவும் உதவும்.

தவறு (சீரற்ற ஆப்ஜெக்ட் உருவாக்கம்):

function createObject(type, data) {
  if (type === 'A') {
    return { x: data.x, y: data.y };
  } else if (type === 'B') {
    return { a: data.a, b: data.b };
  }
}

const objA = createObject('A', { x: 10, y: 20 });
const objB = createObject('B', { a: 5, b: 15 });

function processX(obj) {
  return obj.x;
}

processX(objA);
processX(objB); // 'objB'-ல் 'x' இல்லை, இது சிக்கல்களையும் பாலிமார்பிஸத்தையும் ஏற்படுத்துகிறது

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

சரி (சீரான வடிவத்துடன் ஃபேக்டரி ஃபங்ஷன்):

function createObjectA(data) {
  return { x: data.x, y: data.y, a: undefined, b: undefined }; // சீரான பண்புகளைச் செயல்படுத்தவும்
}

function createObjectB(data) {
  return { x: undefined, y: undefined, a: data.a, b: data.b }; // சீரான பண்புகளைச் செயல்படுத்தவும்
}

const objA = createObjectA({ x: 10, y: 20 });
const objB = createObjectB({ a: 5, b: 15 });

function processX(obj) {
  return obj.x;
}

// இது நேரடியாக processX-க்கு உதவவில்லை என்றாலும், இது வகை குழப்பத்தைத் தவிர்க்க நல்ல நடைமுறைகளை எடுத்துக்காட்டுகிறது.
// ஒரு நிஜ உலக சூழ்நிலையில், நீங்கள் A மற்றும் B-க்கு மேலும் குறிப்பிட்ட ஃபங்ஷன்களை விரும்புவீர்கள்.
// மூலத்தில் பாலிமார்பிஸத்தைக் குறைக்க ஃபேக்டரி ஃபங்ஷன்களின் பயன்பாட்டை நிரூபிக்கும் பொருட்டு, இந்த கட்டமைப்பு நன்மை பயக்கும்.

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

4. அரேக்களில் கலப்பு வகைகளைத் தவிர்க்கவும்

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

தவறு (அரேயில் கலப்பு வகைகள்):

const arr = [1, 'hello', { x: 10 }];

for (let i = 0; i < arr.length; i++) {
  console.log(arr[i]);
}

இது செயல்திறன் சிக்கல்களுக்கு வழிவகுக்கும், ஏனெனில் இன்ஜின் அரேக்குள் வெவ்வேறு வகையான கூறுகளைக் கையாள வேண்டும்.

சரி (அரேயில் சீரான வகைகள்):

const arr = [1, 2, 3]; // எண்களின் அரே

for (let i = 0; i < arr.length; i++) {
  console.log(arr[i]);
}

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

5. டைப் ஹின்ட்களைப் பயன்படுத்தவும் (கவனத்துடன்)

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

உதாரணம் (டைப்ஸ்கிரிப்ட் டைப் ஹின்ட்களைப் பயன்படுத்துதல்):

function add(a: number, b: number): number {
  return a + b;
}

console.log(add(5, 10));

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

மேம்பட்ட V8 கருத்துக்கள் மற்றும் பரிசீலனைகள்

இன்னும் ஆழமான மேம்படுத்தலுக்கு, V8-இன் வெவ்வேறு தொகுப்பு அடுக்குகளின் தொடர்புகளைப் புரிந்துகொள்வது மதிப்புமிக்கதாக இருக்கும்.

• இக்னிஷன் (Ignition): V8-இன் இன்டர்ப்ரெட்டர், ஆரம்பத்தில் ஜாவாஸ்கிரிப்ட் குறியீட்டை இயக்குவதற்குப் பொறுப்பானது. இது மேம்படுத்தலுக்கு வழிகாட்டப் பயன்படுத்தப்படும் சுயவிவரத் தரவைச் சேகரிக்கிறது.
• டர்போஃபேன் (TurboFan): V8-இன் மேம்படுத்தும் கம்பைலர். இக்னிஷனிலிருந்து பெறப்பட்ட சுயவிவரத் தரவுகளின் அடிப்படையில், டர்போஃபேன் அடிக்கடி செயல்படுத்தப்படும் குறியீட்டை மிகவும் மேம்படுத்தப்பட்ட மெஷின் குறியீடாகத் தொகுக்கிறது. டர்போஃபேன் திறமையான மேம்படுத்தலுக்கு இன்லைன் கேச்சிங் மற்றும் மறைக்கப்பட்ட வகுப்புகளை பெரிதும் நம்பியுள்ளது.

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

நிஜ உலக தாக்கங்கள்: உலகளாவிய பயன்பாடுகள்

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

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

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

செயல்திறனைப் பகுப்பாய்வு செய்வதற்கும் மேம்படுத்துவதற்குமான கருவிகள்

உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டின் செயல்திறனைப் பகுப்பாய்வு செய்யவும் மேம்படுத்தவும் பல கருவிகள் உதவும்:

• Chrome DevTools: Chrome DevTools உங்கள் குறியீட்டில் செயல்திறன் தடைகளை அடையாளம் காண உதவும் சக்திவாய்ந்த சுயவிவரக் கருவிகளின் தொகுப்பை வழங்குகிறது. உங்கள் பயன்பாட்டின் செயல்பாட்டின் காலவரிசையைப் பதிவுசெய்யவும் மற்றும் CPU பயன்பாடு, நினைவக ஒதுக்கீடு மற்றும் குப்பை சேகரிப்பு ஆகியவற்றை பகுப்பாய்வு செய்யவும் செயல்திறன் தாவலைப் பயன்படுத்தவும்.
• Node.js Profiler: Node.js உங்கள் சர்வர் பக்க ஜாவாஸ்கிரிப்ட் குறியீட்டின் செயல்திறனைப் பகுப்பாய்வு செய்ய உதவும் உள்ளமைக்கப்பட்ட சுயவிவரத்தை வழங்குகிறது. ஒரு சுயவிவரக் கோப்பை உருவாக்க உங்கள் Node.js பயன்பாட்டை இயக்கும்போது --prof கொடியைப் பயன்படுத்தவும்.
• Lighthouse: Lighthouse என்பது வலைப்பக்கங்களின் செயல்திறன், அணுகல் மற்றும் SEO-ஐ தணிக்கை செய்யும் ஒரு திறந்த மூல கருவியாகும். உங்கள் வலைத்தளம் மேம்படுத்தப்படக்கூடிய பகுதிகள் குறித்த மதிப்புமிக்க நுண்ணறிவுகளை இது வழங்க முடியும்.
• Benchmark.js: Benchmark.js என்பது வெவ்வேறு குறியீட்டுத் துணுக்குகளின் செயல்திறனை ஒப்பிட உங்களை அனுமதிக்கும் ஒரு ஜாவாஸ்கிரிப்ட் பெஞ்ச்மார்க்கிங் நூலகமாகும். உங்கள் மேம்படுத்தல் முயற்சிகளின் தாக்கத்தை அளவிட Benchmark.js-ஐப் பயன்படுத்தவும்.

முடிவுரை

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

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