ஜாவாஸ்கிரிப்ட் செயல்திறன் API: இயக்கநேர அளவீடுகளை சேகரிப்பதில் தேர்ச்சி பெறுதல்

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

ஜாவாஸ்கிரிப்ட் செயல்திறன் API என்றால் என்ன?

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

• வழிசெலுத்தல் நேரம் (Navigation Timing): DNS தேடல், TCP இணைப்பு, கோரிக்கை மற்றும் பதில் நேரம் போன்ற பக்கத்தை ஏற்றுவதற்கான பல்வேறு நிலைகளுக்கு ஆகும் நேரத்தை அளவிடுகிறது.
• வள நேரம் (Resource Timing): படங்கள், ஸ்கிரிப்டுகள் மற்றும் ஸ்டைல்ஷீட்கள் போன்ற பக்கத்தால் ஏற்றப்பட்ட தனிப்பட்ட வளங்களுக்கான விரிவான நேரத் தகவலை வழங்குகிறது.
• பயனர் நேரம் (User Timing): டெவலப்பர்களை தங்கள் பயன்பாட்டின் தர்க்கத்திற்கு குறிப்பிட்ட தனிப்பயன் செயல்திறன் அளவீடுகளை வரையறுக்கவும் அளவிடவும் அனுமதிக்கிறது.
• நீண்ட பணிகள் (Long Tasks): முக்கிய த்ரெட்டை நீண்ட காலத்திற்குத் தடுக்கும் பணிகளை அடையாளம் காட்டுகிறது, இது UI உறைவுக்கு காரணமாகலாம்.
• நினைவக அளவீடு (Memory Measurement): (சில உலாவிகளில் கிடைக்கிறது) பக்கத்தின் நினைவகப் பயன்பாடு பற்றிய தகவலை வழங்குகிறது.
• உறுப்பு நேரம் (Element Timing): குறிப்பிட்ட HTML உறுப்புகள் பயனருக்கு எப்போது தெரியும் என்பதற்கான நேர அளவீடுகளை வழங்குகிறது.
• நிகழ்வு நேரம் (Event Timing): கிளிக்குகள், விசை அழுத்தங்கள் மற்றும் பிற பயனர் தொடர்புகள் போன்ற நிகழ்வுகளின் கால அளவை அளவிடுகிறது.

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

செயல்திறன் API-ன் முக்கிய கூறுகள்

1. performance பொருள் (Object)

performance பொருள் செயல்திறன் API-ஐ அணுகுவதற்கான முக்கிய நுழைவாயிலாகும். இது window பொருளின் ஒரு பண்பு மற்றும் செயல்திறன் தரவை அளவிடுவதற்கும் பகுப்பாய்வு செய்வதற்கும் பல்வேறு முறைகள் மற்றும் பண்புகளுக்கு அணுகலை வழங்குகிறது. பொதுவாகப் பயன்படுத்தப்படும் பண்புகள் performance.timing மற்றும் performance.now().

2. performance.now()

performance.now() ஆவணத்தின் வழிசெலுத்தல் தொடங்கியதிலிருந்து கடந்துபோன நேரத்தைக் குறிக்கும் உயர்-தெளிவுத்திறன் நேரமுத்திரையை (மில்லி வினாடிகளில்) வழங்குகிறது. இது குறியீடு செயலாக்கத்தின் கால அளவை அளவிடுவதற்கான அடித்தளமாகும். Date.now() போலல்லாமல், performance.now() ஒருதிசைப்போக்கானது (monotonic), அதாவது இது கணினி கடிகார மாற்றங்களால் பாதிக்கப்படாது.

எடுத்துக்காட்டு: ஒரு செயல்பாட்டின் செயலாக்க நேரத்தை அளவிடுதல்

            const startTime = performance.now();
// Code to be measured
for (let i = 0; i < 1000000; i++) {
  // Perform some operation
}
const endTime = performance.now();
const executionTime = endTime - startTime;
console.log(`Execution time: ${executionTime} milliseconds`);

            

              
                Copy
              
            
          

3. செயல்திறன் காலவரிசை (Performance Timeline)

செயல்திறன் காலவரிசை என்பது ஒரு பக்கத்தின் வாழ்நாளில் நிகழும் செயல்திறன் தொடர்பான நிகழ்வுகளின் பதிவாகும். இதில் வழிசெலுத்தல் நேரம், வள நேரம், பயனர் நேரம் மற்றும் பலவற்றிற்கான உள்ளீடுகள் அடங்கும். performance.getEntries(), performance.getEntriesByType(), மற்றும் performance.getEntriesByName() போன்ற முறைகளைப் பயன்படுத்தி செயல்திறன் காலவரிசையை அணுகலாம்.

4. PerformanceEntry இடைமுகம்

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

இயக்கநேர அளவீடுகளை சேகரித்தல் மற்றும் பகுப்பாய்வு செய்தல்

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

1. பக்க ஏற்றுதல் நேரத்தை அளவிடுதல்

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

எடுத்துக்காட்டு: DOMContentLoaded நிகழ்வு நேரத்தைக் கணக்கிடுதல்

            window.addEventListener('load', () => {
  const loadTime = performance.timing.domContentLoadedEventEnd - performance.timing.navigationStart;
  console.log(`DOMContentLoaded event time: ${loadTime} milliseconds`);
});

            

              
                Copy
              
            
          

முடிவுகளை விளக்குதல்: ஒரு உயர் domContentLoadedEventEnd மதிப்பு, உலாவி ஜாவாஸ்கிரிப்ட் குறியீட்டைப் பாகுபடுத்துவதற்கும் செயல்படுத்துவதற்கும், DOM-ஐ ரெண்டர் செய்வதற்கும் அல்லது வளங்கள் ஏற்றப்படுவதற்கு காத்திருப்பதற்கும் அதிக நேரம் செலவிடுகிறது என்பதைக் குறிக்கலாம். தனிப்பட்ட வள நேரங்களை (கீழே காண்க) பகுப்பாய்வு செய்வது தாமதங்களை ஏற்படுத்தும் குறிப்பிட்ட வளங்களைக் கண்டறிய உதவும்.

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

2. வள ஏற்றுதல் நேரங்களை அளவிடுதல்

வள நேர API (Resource Timing API) பக்கத்தால் ஏற்றப்பட்ட ஒவ்வொரு வளத்திற்கும் விரிவான நேரத் தகவலை வழங்குகிறது. இது மெதுவாக ஏற்றப்படும் வளங்களை அடையாளம் காணவும் அவற்றின் விநியோகத்தை மேம்படுத்தவும் உங்களை அனுமதிக்கிறது.

எடுத்துக்காட்டு: வள நேரத் தகவலைப் பெறுதல்

            const resourceEntries = performance.getEntriesByType('resource');

resourceEntries.forEach(entry => {
  console.log(`Resource: ${entry.name}`);
  console.log(`  Duration: ${entry.duration} milliseconds`);
  console.log(`  Fetch Start: ${entry.fetchStart}`);
  console.log(`  Response End: ${entry.responseEnd}`);
});

            

              
                Copy
              
            
          

முடிவுகளை விளக்குதல்: ஒவ்வொரு வள உள்ளீட்டின் duration பண்பையும் ஆராய்வது மெதுவாக ஏற்றப்படும் வளங்களை அடையாளம் காண உதவும். ஒரு உயர் duration மதிப்பு நெட்வொர்க் தாமதம், பெரிய கோப்பு அளவுகள் அல்லது திறமையற்ற சர்வர் பக்க செயலாக்கத்தைக் குறிக்கலாம்.

மேம்படுத்தல் உத்திகள்: சாத்தியமான தீர்வுகளில் படங்களை சுருக்குதல், ஜாவாஸ்கிரிப்ட் மற்றும் CSS கோப்புகளை சிறிதாக்குதல், உள்ளடக்க விநியோக நெட்வொர்க்கை (CDN) பயன்படுத்துதல் மற்றும் சர்வர் பக்க தற்காலிக சேமிப்பை மேம்படுத்துதல் ஆகியவை அடங்கும்.

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

3. பயனர் தொடர்புகளை அளவிடுதல்

பயனர் நேர API (User Timing API) உங்கள் பயன்பாட்டின் தர்க்கத்திற்கு குறிப்பிட்ட தனிப்பயன் செயல்திறன் அளவீடுகளை வரையறுக்கவும் அளவிடவும் உங்களை அனுமதிக்கிறது. படிவ சமர்ப்பிப்புகள், தேடல் வினவல்கள் மற்றும் வழிசெலுத்தல் மாற்றங்கள் போன்ற முக்கியமான பயனர் தொடர்புகளின் செயல்திறனைக் கண்காணிக்க இது பயனுள்ளதாக இருக்கும்.

எடுத்துக்காட்டு: ஒரு படிவத்தைச் சமர்ப்பிக்க ஆகும் நேரத்தை அளவிடுதல்

            const form = document.getElementById('myForm');

form.addEventListener('submit', (event) => {
  performance.mark('formSubmitStart');
  // Simulate form submission delay
  setTimeout(() => {
    performance.mark('formSubmitEnd');
    performance.measure('formSubmitDuration', 'formSubmitStart', 'formSubmitEnd');

    const measure = performance.getEntriesByName('formSubmitDuration')[0];
    console.log(`Form submission duration: ${measure.duration} milliseconds`);
  }, 1000); //Simulate network request taking 1 second

  event.preventDefault();
});

            

              
                Copy
              
            
          

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

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

4. நீண்ட பணிகளை அடையாளம் காணுதல்

நீண்ட பணிகள் என்பது முக்கிய த்ரெட்டை நீண்ட காலத்திற்கு (பொதுவாக 50 மில்லி வினாடிகளுக்கு மேல்) தடுக்கும் பணிகளாகும், இது UI உறைவு மற்றும் மோசமான பயனர் அனுபவத்திற்கு வழிவகுக்கும். நீண்ட பணிகள் API (Long Tasks API) இந்தப் பணிகளை அடையாளம் காணவும், அவற்றைத் தடுக்க உங்கள் குறியீட்டை மேம்படுத்தவும் உங்களை அனுமதிக்கிறது.

எடுத்துக்காட்டு: நீண்ட பணிகளை அடையாளம் காணுதல்

            const observer = new PerformanceObserver((list) => {
  list.getEntries().forEach((entry) => {
    console.log(`Long task: ${entry.name}`);
    console.log(`  Duration: ${entry.duration} milliseconds`);
  });
});

observer.observe({ entryTypes: ['longtask'] });

// Simulate a long task
setTimeout(() => {
  let sum = 0;
  for (let i = 0; i < 1000000000; i++) {
    sum += i;
  }
  console.log(`Long task complete: ${sum}`);
}, 0);

            

              
                Copy
              
            
          

முடிவுகளை விளக்குதல்: ஒரு நீண்ட பணி கால அளவு, உலாவியை UI-ஐ சீராகப் புதுப்பிப்பதைத் தடுக்கும் குறியீட்டை எடுத்துக்காட்டுகிறது.

மேம்படுத்தல் உத்திகள்: குறியீடு பிரித்தல் (Code splitting), டிபவுன்சிங் (debouncing), த்ராட்லிங் (throttling), மற்றும் வலைப் பணியாளர்களுக்கு (web workers) பணிகளை மாற்றுவது ஆகியவை நீண்ட பணி கால அளவைக் குறைப்பதற்கான உத்திகளாகும்.

5. உறுப்பு தெரிவுநிலையை அளவிடுதல்

உறுப்பு நேர API (Element Timing API) குறிப்பிட்ட HTML உறுப்புகள் பயனருக்கு எப்போது தெரியும் என்பதை அளவிட உங்களை அனுமதிக்கிறது. ஹீரோ படங்கள் அல்லது முக்கியமான உள்ளடக்கப் பிரிவுகள் போன்ற முக்கியமான கூறுகளின் ஏற்றுதல் மற்றும் ரெண்டரிங் செயல்திறனைக் கண்காணிக்க இது மிகவும் பயனுள்ளதாக இருக்கும்.

எடுத்துக்காட்டு: உறுப்பு தெரிவுநிலை நேரத்தை அளவிடுதல்

            <img src="hero-image.jpg" elementtiming="hero-image" id="heroImage">

const observer = new PerformanceObserver((list) => {
  list.getEntries().forEach((entry) => {
    if (entry.name === 'hero-image') {
      console.log(`Hero image render start: ${entry.renderStart} milliseconds`);
    }
  });
});

observer.observe({ type: 'element', buffered: true });

            

              
                Copy
              
            
          

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

மேம்படுத்தல் உத்திகள்: பட சுருக்கத்தை மேம்படுத்தவும், சோம்பேறி ஏற்றுதலைப் (lazy loading) பயன்படுத்தவும், மற்றும் முக்கியமான வளங்களை ஏற்றுவதற்கு முன்னுரிமை அளிக்கவும்.

6. நிகழ்வு தாமதத்தை அளவிடுதல்

நிகழ்வு நேர API (Event Timing API) நிகழ்வு கேட்பான்கள் (event listeners) செயல்படுத்த எடுக்கும் நேரத்தை அளவிடுகிறது. பயனர் தொடர்புகளை மெதுவாக்கக்கூடிய நிகழ்வு கையாளுநர்களை (event handlers) அடையாளம் காண இது மதிப்புமிக்கது.

எடுத்துக்காட்டு: கிளிக் நிகழ்வு தாமதத்தை அளவிடுதல்

            <button id="myButton">Click Me</button>

const button = document.getElementById('myButton');

button.addEventListener('click', (event) => {
  performance.mark('clickStart');
  // Simulate some processing
  for (let i = 0; i < 1000000; i++) {
    // Perform some operation
  }
  performance.mark('clickEnd');
  performance.measure('clickDuration', 'clickStart', 'clickEnd');

  const measure = performance.getEntriesByName('clickDuration')[0];
  console.log(`Click event duration: ${measure.duration} milliseconds`);
});

            

              
                Copy
              
            
          

முடிவுகளை விளக்குதல்: ஒரு நீண்ட clickDuration, நிகழ்வு கையாளுநர் செயல்படுத்த அதிக நேரம் எடுப்பதைக் குறிக்கிறது, இது UI பதிலில் தாமதத்தை ஏற்படுத்தக்கூடும்.

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

செயல்திறன் API-ஐப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

• துல்லியமான நேர அளவீடுகளுக்கு performance.now() ஐப் பயன்படுத்தவும். இது அதிக துல்லியத்தை வழங்குகிறது மற்றும் ஒருதிசைப்போக்கானது, இது குறியீடு செயலாக்க நேரத்தை அளவிடுவதற்கு ஏற்றதாக அமைகிறது.
• செயல்திறன் நிகழ்வுகளை பகுப்பாய்வு செய்ய செயல்திறன் காலவரிசையைப் பயன்படுத்தவும். செயல்திறன் காலவரிசை ஒரு பக்கத்தின் வாழ்நாளில் நிகழும் செயல்திறன் தொடர்பான நிகழ்வுகளின் விரிவான பதிவை வழங்குகிறது.
• தனிப்பயன் செயல்திறன் அளவீடுகளை வரையறுக்க பயனர் நேர API-ஐப் பயன்படுத்தவும். இது முக்கியமான பயனர் தொடர்புகள் மற்றும் பயன்பாடு சார்ந்த தர்க்கத்தின் செயல்திறனைக் கண்காணிக்க உங்களை அனுமதிக்கிறது.
• நிஜ உலகச் சூழல்களில் செயல்திறனைக் கண்காணிக்கவும். உண்மையான பயனர்களிடமிருந்து செயல்திறன் தரவைச் சேகரிக்க Google Analytics, New Relic அல்லது Sentry போன்ற கருவிகளைப் பயன்படுத்தவும். இது உங்கள் பயன்பாட்டின் செயல்திறனைப் பற்றிய துல்லியமான படத்தை உங்களுக்கு வழங்கும்.
• செயல்திறன் வரவுசெலவுத் திட்டங்களை அமைத்து, காலப்போக்கில் முன்னேற்றத்தைக் கண்காணிக்கவும். உங்கள் பயன்பாட்டிற்கான செயல்திறன் இலக்குகளை வரையறுத்து, காலப்போக்கில் உங்கள் முன்னேற்றத்தைக் கண்காணிக்கவும். இது செயல்திறனை மேம்படுத்துவதில் கவனம் செலுத்தவும், உங்கள் பயன்பாடு உங்கள் பயனர்களின் எதிர்பார்ப்புகளைப் பூர்த்தி செய்வதை உறுதி செய்யவும் உதவும்.
• செயல்திறன் API-ஐ மற்ற பிழைத்திருத்தக் கருவிகளுடன் இணைக்கவும். உலாவி டெவலப்பர் கருவிகள் ஜாவாஸ்கிரிப்ட் குறியீட்டை சுயவிவரப்படுத்துவதற்கும் பிழைத்திருத்துவதற்கும் சக்திவாய்ந்த திறன்களை வழங்குகின்றன. இந்த கருவிகளை செயல்திறன் API உடன் இணைப்பது செயல்திறன் தடைகளைப் பற்றிய ஆழமான நுண்ணறிவுகளை வழங்க முடியும்.

செயல்திறன் கண்காணிப்புக்கான கருவிகள் மற்றும் நூலகங்கள்

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

• Google Lighthouse: வலைத்தள செயல்திறன், அணுகல்தன்மை மற்றும் SEO ஆகியவற்றைத் தணிக்கை செய்வதற்கான ஒரு தானியங்கு கருவி. இது அளவீடுகளைச் சேகரிக்க செயல்திறன் API-ஐப் பயன்படுத்துகிறது மற்றும் மேம்பாட்டிற்கான செயல்பாட்டு பரிந்துரைகளை வழங்குகிறது.
• WebPageTest: வெவ்வேறு இடங்கள் மற்றும் உலாவிகளில் இருந்து உங்கள் வலைத்தளத்தின் செயல்திறனைச் சோதிக்க உங்களை அனுமதிக்கும் ஒரு இலவச வலைத்தள வேக சோதனை கருவி.
• New Relic Browser: பக்க ஏற்றுதல் நேரங்கள், ஜாவாஸ்கிரிப்ட் பிழைகள் மற்றும் பயனர் அனுபவ அளவீடுகள் உட்பட வலைத்தள செயல்திறன் பற்றிய நிகழ்நேர நுண்ணறிவுகளை வழங்கும் ஒரு விரிவான செயல்திறன் கண்காணிப்பு கருவி.
• Sentry: உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டில் உள்ள சிக்கல்களை அடையாளம் கண்டு தீர்க்க உதவும் ஒரு பிழை கண்காணிப்பு மற்றும் செயல்திறன் கண்காணிப்பு தளம்.
• Perfume.js: செயல்திறன் அளவீடுகளைச் சேகரிப்பதற்கும் புகாரளிப்பதற்கும் ஒரு எளிய API-ஐ வழங்கும் ஒரு சிறிய, திறந்த மூல நூலகம்.

முடிவுரை

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