अपने HTML5 ऐप्लिकेशन की परफ़ॉर्मेंस को बेहतर बनाना

परिचय

HTML5 हमें वेब ऐप्लिकेशन के विज़ुअल को बेहतर बनाने के लिए बेहतरीन टूल देता है. खास तौर पर, ऐनिमेशन के मामले में ऐसा होता है. हालांकि, इस नई सुविधा के साथ नई चुनौतियां भी आती हैं. दरअसल, ये चुनौतियां नई नहीं हैं. कभी-कभी अपने सहकर्मी से पूछना सही रहता है. जैसे, Flash प्रोग्रामर से पूछें कि उसने पहले इस तरह की समस्याओं को कैसे हल किया था.

ऐनिमेशन पर काम करते समय, यह बेहद ज़रूरी है कि उपयोगकर्ताओं को ये ऐनिमेशन स्मूद लगें. हमें यह समझना होगा कि ऐनिमेशन को स्मूद बनाने के लिए, सिर्फ़ फ़्रेम प्रति सेकंड को किसी कॉग्निटिव थ्रेशोल्ड से ज़्यादा बढ़ाना काफ़ी नहीं है. हालांकि, हमारा दिमाग इससे ज़्यादा स्मार्ट है. आपको यह पता चलेगा कि 30 फ़्रेम प्रति सेकंड (एफ़पीएस) वाला ऐनिमेशन, 60 एफ़पीएस वाले ऐनिमेशन से कहीं बेहतर है. ऐसा इसलिए, क्योंकि 60 एफ़पीएस वाले ऐनिमेशन में बीच-बीच में कुछ फ़्रेम ड्रॉप हो जाते हैं. लोगों को जैग्डनेस पसंद नहीं है.

इस लेख में, आपको अपने ऐप्लिकेशन के अनुभव को बेहतर बनाने के लिए टूल और तकनीकों के बारे में बताया जाएगा.

रणनीति

हमारा मकसद आपको HTML5 का इस्तेमाल करके, शानदार विज़ुअल वाले बेहतरीन ऐप्लिकेशन बनाने से रोकना नहीं है.

इसके बाद, जब आपको लगे कि परफ़ॉर्मेंस को थोड़ा और बेहतर किया जा सकता है, तो यहां वापस आएं और अपने ऐप्लिकेशन के एलिमेंट को बेहतर बनाने का तरीका जानें. बेशक, इससे आपको कुछ चीज़ों को पहली बार में ही सही तरीके से करने में मदद मिल सकती है. हालांकि, इसे अपनी प्रॉडक्टिविटी में रुकावट न बनने दें.

HTML5 की मदद से विज़ुअल फ़िडेलिटी++

हार्डवेयर से तेज़ी लाएं

ब्राउज़र में रेंडरिंग की परफ़ॉर्मेंस को बेहतर बनाने के लिए, हार्डवेयर से तेज़ी लाने की सुविधा एक अहम माइलस्टोन है. आम तौर पर, इस सुविधा का इस्तेमाल उन टास्क को ग्राफ़िक्स प्रोसेसिंग यूनिट (जीपीयू) पर ऑफ़लोड करने के लिए किया जाता है जिन्हें मुख्य सीपीयू कैलकुलेट करता है. जीपीयू, आपके कंप्यूटर के ग्राफ़िक्स अडैप्टर में होता है. इससे परफ़ॉर्मेंस में काफ़ी सुधार हो सकता है. साथ ही, मोबाइल डिवाइसों पर रिसॉर्स की खपत भी कम हो सकती है.

आपके दस्तावेज़ के इन पहलुओं को जीपीयू की मदद से तेज़ी से प्रोसेस किया जा सकता है

  • सामान्य लेआउट कंपोज़िटिंग
  • CSS3 ट्रांज़िशन
  • CSS3 3D ट्रांसफ़ॉर्म
  • कैनवस ड्रॉइंग
  • WebGL 3D ड्रॉइंग

कैनवस और WebGL की स्पीड बढ़ाने की सुविधा, खास मकसद के लिए इस्तेमाल की जाती है. ऐसा हो सकता है कि यह आपके ऐप्लिकेशन पर लागू न हो. हालांकि, पहले तीन पहलुओं से, ज़्यादातर ऐप्लिकेशन की स्पीड बढ़ाई जा सकती है.

किन कामों को तेज़ी से पूरा किया जा सकता है?

जीपीयू ऐक्सेलरेटर, खास कामों को खास हार्डवेयर पर ऑफ़लोड करके काम करता है. सामान्य स्कीम यह है कि आपके दस्तावेज़ को कई "लेयर" में बांटा जाता है. ये लेयर, आपके पेज के उन पहलुओं के हिसाब से नहीं बदलती हैं जिन्हें तेज़ी से लोड किया जाता है. इन लेयर को रेंडर करने के लिए, ट्रेडिशनल रेंडर पाइपलाइन का इस्तेमाल किया जाता है. इसके बाद, जीपीयू का इस्तेमाल करके लेयर को एक पेज पर कंपोज़िट किया जाता है. साथ ही, "इफ़ेक्ट" लागू किए जाते हैं, जिन्हें तुरंत तेज़ किया जा सकता है. ऐसा हो सकता है कि स्क्रीन पर ऐनिमेट किए गए किसी ऑब्जेक्ट को ऐनिमेशन के दौरान, पेज के "रीलेआउट" की ज़रूरत न पड़े.

आपको यह समझना होगा कि रेंडरिंग इंजन के लिए यह पहचानना आसान बनाना होगा कि वह जीपीयू ऐक्सेलरेटर का इस्तेमाल कब कर सकता है. नीचे दिए गए उदाहरण पर ध्यान दें:

हालांकि, यह तरीका काम करता है, लेकिन ब्राउज़र को यह नहीं पता होता कि आपने कोई ऐसा काम किया है जिसे किसी व्यक्ति को स्मूद ऐनिमेशन के तौर पर देखना चाहिए. इसके बजाय, CSS3 ट्रांज़िशन का इस्तेमाल करके एक जैसा विज़ुअल अपियरेंस पाने पर क्या होता है:

ब्राउज़र इस ऐनिमेशन को कैसे लागू करता है, यह डेवलपर को नहीं दिखता. इसका मतलब है कि ब्राउज़र, तय किए गए लक्ष्य को हासिल करने के लिए, जीपीयू ऐक्सेलरेटर जैसी तरकीबें लागू कर सकता है.

Chrome के लिए, दो काम के कमांड-लाइन फ़्लैग हैं. इनकी मदद से, जीपीयू की मदद से प्रोसेसिंग की रफ़्तार बढ़ाने की सुविधा को डीबग किया जा सकता है:

  1. --show-composited-layer-borders, उन एलिमेंट के आस-पास लाल बॉर्डर दिखाता है जिनमें जीपीयू लेवल पर बदलाव किया जा रहा है. यह पुष्टि करने के लिए अच्छा है कि आपके बदलाव, जीपीयू लेयर में हो रहे हैं.
  2. --show-paint-rects सभी नॉन-जीपीयू बदलावों को पेंट किया जाता है. इससे, फिर से पेंट किए गए सभी हिस्सों के आस-पास एक हल्की बॉर्डर बन जाती है. ब्राउज़र को पेंट एरिया को ऑप्टिमाइज़ करते हुए देखा जा सकता है.

Safari में भी रनटाइम फ़्लैग होते हैं. इनके बारे में यहां बताया गया है.

CSS3 ट्रांज़िशन

सीएसएस ट्रांज़िशन की मदद से, स्टाइल ऐनिमेशन बनाना सभी के लिए आसान हो जाता है. साथ ही, यह परफ़ॉर्मेंस को बेहतर बनाने वाली एक स्मार्ट सुविधा भी है. सीएसएस ट्रांज़िशन को ब्राउज़र मैनेज करता है. इसलिए, इसके ऐनिमेशन की क्वालिटी को काफ़ी बेहतर बनाया जा सकता है. साथ ही, कई मामलों में हार्डवेयर से तेज़ी लाई जा सकती है. फ़िलहाल, WebKit (Chrome, Safari, iOS) में हार्डवेयर से तेज़ी लाने वाले सीएसएस ट्रांसफ़ॉर्म मौजूद हैं. हालांकि, यह सुविधा जल्द ही अन्य ब्राउज़र और प्लैटफ़ॉर्म पर भी उपलब्ध होगी.

transitionEnd इवेंट का इस्तेमाल करके, इसे बेहतरीन कॉम्बिनेशन में स्क्रिप्ट किया जा सकता है. हालांकि, फ़िलहाल ट्रांज़िशन के खत्म होने से जुड़े सभी इवेंट कैप्चर करने का मतलब है कि webkitTransitionEnd transitionend oTransitionEnd को देखना.

कई लाइब्रेरी ने अब ऐनिमेशन एपीआई लॉन्च किए हैं. ये एपीआई, ट्रांज़िशन मौजूद होने पर उनका इस्तेमाल करते हैं. अगर ट्रांज़िशन मौजूद नहीं होते हैं, तो ये एपीआई स्टैंडर्ड डीओएम स्टाइल वाले ऐनिमेशन का इस्तेमाल करते हैं. scripty2, YUI transition, jQuery animate enhanced.

CSS3 translate

हमें यकीन है कि आपने पहले भी पेज पर किसी एलिमेंट की x/y पोज़िशन को ऐनिमेट किया होगा. ऐसा हो सकता है कि आपने इनलाइन स्टाइल की बाईं और सबसे ऊपर वाली प्रॉपर्टी में बदलाव किया हो. 2D ट्रांसफ़ॉर्म की मदद से, translate() फ़ंक्शन का इस्तेमाल करके इस व्यवहार को दोहराया जा सकता है.

हम इसे डीओएम ऐनिमेशन के साथ जोड़ सकते हैं, ताकि सबसे बेहतर चीज़ का इस्तेमाल किया जा सके

<div style="position:relative; height:120px;" class="hwaccel">

  <div style="padding:5px; width:100px; height:100px; background:papayaWhip;
              position:absolute;" id="box">
  </div>
</div>

<script>
document.querySelector('#box').addEventListener('click', moveIt, false);

function moveIt(evt) {
  var elem = evt.target;

  if (Modernizr.csstransforms && Modernizr.csstransitions) {
    // vendor prefixes omitted here for brevity
    elem.style.transition = 'all 3s ease-out';
    elem.style.transform = 'translateX(600px)';

  } else {
    // if an older browser, fall back to jQuery animate
    jQuery(elem).animate({ 'left': '600px'}, 3000);
  }
}
</script>

हम सीएसएस 2D ट्रांसफ़ॉर्म और सीएसएस ट्रांज़िशन की जांच करने के लिए, Modernizr का इस्तेमाल करते हैं. अगर ऐसा है, तो हम पोज़िशन बदलने के लिए, ट्रांसलेट का इस्तेमाल करेंगे. अगर इसे ट्रांज़िशन का इस्तेमाल करके ऐनिमेट किया जाता है, तो इस बात की काफ़ी संभावना है कि ब्राउज़र, हार्डवेयर से तेज़ी लाने की सुविधा का इस्तेमाल कर सकता है. ब्राउज़र को सही दिशा में एक और पुश देने के लिए, हम ऊपर दिए गए "मैजिक सीएसएस बुलेट" का इस्तेमाल करेंगे.

अगर हमारा ब्राउज़र कम क्षमता वाला है, तो हम अपने एलिमेंट को मूव करने के लिए jQuery का इस्तेमाल करेंगे. इस पूरी प्रोसेस को ऑटोमैटिक बनाने के लिए, लुई-रेमी बेब का jQuery ट्रांसफ़ॉर्म पॉलीफ़िल प्लग इन इस्तेमाल किया जा सकता है.

window.requestAnimationFrame

requestAnimationFrame को Mozilla ने पेश किया था और WebKit ने इसे बेहतर बनाया था. इसका मकसद आपको ऐनिमेशन चलाने के लिए नेटिव एपीआई उपलब्ध कराना था. भले ही, वे DOM/CSS पर आधारित हों या <canvas> या WebGL पर. ब्राउज़र, एक साथ चलने वाले ऐनिमेशन को एक ही रीफ़्लो और रीपेंट साइकल में ऑप्टिमाइज़ कर सकता है. इससे ऐनिमेशन की क्वालिटी बेहतर होती है. उदाहरण के लिए, सीएसएस ट्रांज़िशन या SVG SMIL के साथ सिंक किए गए JS-आधारित ऐनिमेशन. इसके अलावा, अगर ऐनिमेशन लूप को किसी ऐसे टैब में चलाया जा रहा है जो दिख नहीं रहा है, तो ब्राउज़र उसे चलाना बंद कर देगा. इससे सीपीयू, जीपीयू, और मेमोरी का कम इस्तेमाल होगा. साथ ही, बैटरी लाइफ़ भी ज़्यादा होगी.

requestAnimationFrame को इस्तेमाल करने के तरीके और वजहों के बारे में ज़्यादा जानने के लिए, पॉल आयरिश का लेख requestAnimationFrame for smart animating पढ़ें.

प्रोफ़ाइलिंग

जब आपको पता चलता है कि आपके ऐप्लिकेशन की स्पीड को बेहतर बनाया जा सकता है, तो प्रोफ़ाइलिंग की मदद से यह पता लगाएं कि किन जगहों पर ऑप्टिमाइज़ेशन करने से सबसे ज़्यादा फ़ायदा मिल सकता है. ऑप्टिमाइज़ेशन से अक्सर आपके सोर्स कोड के रखरखाव पर बुरा असर पड़ता है. इसलिए, इसे सिर्फ़ ज़रूरत पड़ने पर ही लागू किया जाना चाहिए. प्रोफ़ाइलिंग से आपको पता चलता है कि आपके कोड के किन हिस्सों की परफ़ॉर्मेंस को बेहतर बनाने से, आपको सबसे ज़्यादा फ़ायदा मिलेगा.

JavaScript प्रोफ़ाइलिंग

JavaScript प्रोफ़ाइलर, JavaScript फ़ंक्शन लेवल पर आपके ऐप्लिकेशन की परफ़ॉर्मेंस की खास जानकारी देते हैं. इसके लिए, वे हर फ़ंक्शन को शुरू से लेकर आखिर तक एक्ज़ीक्यूट होने में लगने वाले समय को मेज़र करते हैं.

किसी फ़ंक्शन को एक्ज़ीक्यूट करने में लगने वाला कुल समय, उसे ऊपर से नीचे तक एक्ज़ीक्यूट करने में लगने वाला कुल समय होता है. नेट एक्ज़ीक्यूशन टाइम, ग्रॉस एक्ज़ीक्यूशन टाइम में से फ़ंक्शन से कॉल किए गए फ़ंक्शन को एक्ज़ीक्यूट करने में लगे समय को घटाने पर मिलता है.

कुछ फ़ंक्शन को दूसरों की तुलना में ज़्यादा बार कॉल किया जाता है. प्रोफ़ाइलर आम तौर पर, आपको सभी इन्वोकेशन को चलाने में लगने वाले समय के साथ-साथ, उन्हें चलाने में लगने वाले औसत, कम से कम, और ज़्यादा से ज़्यादा समय की जानकारी देते हैं.

ज़्यादा जानकारी के लिए, प्रोफ़ाइलिंग के बारे में Chrome DevTools के दस्तावेज़ देखें.

डीओएम

JavaScript की परफ़ॉर्मेंस का इस बात पर काफ़ी असर पड़ता है कि आपका ऐप्लिकेशन कितना आसान और रिस्पॉन्सिव होगा. यह समझना ज़रूरी है कि JavaScript प्रोफ़ाइलर, आपके JavaScript के लागू होने में लगने वाले समय को मेज़र करते हैं. साथ ही, वे डीओएम ऑपरेशन में लगने वाले समय को भी मेज़र करते हैं. ये डीओएम ऑपरेशन, अक्सर आपकी परफ़ॉर्मेंस से जुड़ी समस्याओं की मुख्य वजह होते हैं.

function drawArray(array) {
  for(var i = 0; i < array.length; i++) {
    document.getElementById('test').innerHTML += array[i]; // No good :(
  }
}

उदाहरण के लिए, ऊपर दिए गए कोड में असल JavaScript को लागू करने में बिलकुल भी समय नहीं लगता. हालांकि, drawArray-फ़ंक्शन अब भी आपकी प्रोफ़ाइलों में दिख सकता है, क्योंकि यह डीओएम के साथ बहुत ही खराब तरीके से इंटरैक्ट कर रहा है.

सुझाव और तरकीबें

बिना नाम वाले फ़ंक्शन

बिना नाम वाले फ़ंक्शन की प्रोफ़ाइल बनाना आसान नहीं होता, क्योंकि उनका कोई नाम नहीं होता. इस वजह से, वे प्रोफ़ाइलर में नहीं दिखते. इस समस्या को हल करने के दो तरीके हैं:

$('.stuff').each(function() { ... });

इस तरह से फिर से लिखें:

$('.stuff').each(function workOnStuff() { ... });

आम तौर पर, लोगों को यह नहीं पता होता कि JavaScript में फ़ंक्शन एक्सप्रेशन को नाम दिया जा सकता है. ऐसा करने से, वे प्रोफ़ाइलर में सही तरीके से दिखेंगे. इस समाधान में एक समस्या है: नाम वाला एक्सप्रेशन, फ़ंक्शन के नाम को मौजूदा लेक्सिकल स्कोप में डाल देता है. इससे अन्य सिंबल पर असर पड़ सकता है. इसलिए, सावधानी बरतें.

लंबे फ़ंक्शन की प्रोफ़ाइलिंग

मान लें कि आपके पास एक लंबा फ़ंक्शन है और आपको लगता है कि उसका एक छोटा हिस्सा, परफ़ॉर्मेंस से जुड़ी समस्याओं की वजह हो सकता है. यह पता लगाने के दो तरीके हैं कि किस हिस्से में समस्या है:

  1. सही तरीका: अपने कोड को फिर से लिखें, ताकि उसमें कोई लंबा फ़ंक्शन शामिल न हो.
  2. काम पूरा करने का गलत तरीका: अपने कोड में, नाम वाले सेल्फ़ कॉलिंग फ़ंक्शन के तौर पर स्टेटमेंट जोड़ना. अगर थोड़ा ध्यान दिया जाए, तो इससे सिमैंटिक में कोई बदलाव नहीं होता. साथ ही, प्रोफ़ाइलर में आपके फ़ंक्शन के कुछ हिस्से अलग-अलग फ़ंक्शन के तौर पर दिखते हैं: js function myLongFunction() { ... (function doAPartOfTheWork() { ... })(); ... } प्रोफ़ाइलिंग पूरी होने के बाद, इन अतिरिक्त फ़ंक्शन को हटाना न भूलें. इसके अलावा, अपने कोड को रीफ़ैक्टर करने के लिए, इन्हें शुरुआती पॉइंट के तौर पर भी इस्तेमाल किया जा सकता है.

डीओएम प्रोफ़ाइलिंग

Chrome वेब इंस्पेक्टर के नए डेवलपमेंट टूल में, नया "टाइमलाइन व्यू" शामिल है. इसमें ब्राउज़र की ओर से की गई लो लेवल कार्रवाइयों की टाइमलाइन दिखती है. इस जानकारी का इस्तेमाल करके, डीओएम ऑपरेशन को ऑप्टिमाइज़ किया जा सकता है. आपका मकसद, कोड के एक्ज़ीक्यूशन के दौरान ब्राउज़र को की जाने वाली "कार्रवाइयों" की संख्या को कम करना होना चाहिए.

टाइमलाइन व्यू में बहुत ज़्यादा जानकारी दिख सकती है. इसलिए, आपको कम से कम टेस्ट केस बनाने चाहिए, ताकि उन्हें अलग-अलग चलाया जा सके.

डीओएम प्रोफ़ाइलिंग

ऊपर दी गई इमेज में, एक आसान स्क्रिप्ट के लिए टाइमलाइन व्यू का आउटपुट दिखाया गया है. बाईं ओर मौजूद पैनल में, ब्राउज़र की ओर से की गई कार्रवाइयां क्रम से दिखती हैं. वहीं, दाईं ओर मौजूद पैनल में, हर कार्रवाई में लगने वाला असल समय दिखता है.

टाइमलाइन व्यू के बारे में ज़्यादा जानकारी. Internet Explorer में प्रोफ़ाइलिंग के लिए, DynaTrace Ajax Edition एक वैकल्पिक टूल है.

प्रोफ़ाइलिंग की रणनीतियां

अलग-अलग पहलुओं को हाइलाइट करना

अपने ऐप्लिकेशन की प्रोफ़ाइल बनाते समय, उसकी सुविधाओं के उन पहलुओं को अलग करने की कोशिश करें जिनकी वजह से ऐप्लिकेशन की परफ़ॉर्मेंस धीमी हो सकती है. इसके बाद, प्रोफ़ाइल रन करने की कोशिश करें. इससे आपके कोड के सिर्फ़ वे हिस्से लागू होंगे जो आपके ऐप्लिकेशन के इन पहलुओं से जुड़े हैं. इससे प्रोफ़ाइलिंग डेटा को समझना आसान हो जाएगा, क्योंकि यह उन कोड पाथ के साथ नहीं मिलाया जाता है जो आपकी असल समस्या से जुड़े नहीं हैं. आपके आवेदन के अलग-अलग पहलुओं के लिए, ये उदाहरण सही हो सकते हैं:

  1. स्टार्ट अप टाइम (प्रोफ़ाइलर को चालू करें, ऐप्लिकेशन को फिर से लोड करें, शुरू होने की प्रोसेस पूरी होने तक इंतज़ार करें, प्रोफ़ाइलर को बंद करें.
  2. किसी बटन पर क्लिक करें और उसके बाद होने वाले ऐनिमेशन को रिकॉर्ड करें. इसके लिए, प्रोफ़ाइलर को चालू करें, बटन पर क्लिक करें, ऐनिमेशन पूरा होने तक इंतज़ार करें, और प्रोफ़ाइलर को बंद करें.
जीयूआई प्रोफ़ाइलिंग

जीयूआई प्रोग्राम में, अपने ऐप्लिकेशन के सिर्फ़ सही हिस्से को लागू करना ज़्यादा मुश्किल हो सकता है. ऐसा तब होता है, जब अपने 3D इंजन के रे ट्रेसर को ऑप्टिमाइज़ किया जाता है. उदाहरण के लिए, अगर आपको किसी बटन पर क्लिक करने पर होने वाली गतिविधियों की प्रोफ़ाइल बनानी है, तो हो सकता है कि आप इस दौरान माउसओवर से जुड़े ऐसे इवेंट ट्रिगर कर दें जो काम के न हों. इससे आपके नतीजे कम सटीक हो सकते हैं. ऐसा करने से बचें :)

प्रोग्रामैटिक इंटरफ़ेस

डीबगर को चालू करने के लिए, एक प्रोग्रामैटिक इंटरफ़ेस भी है. इससे यह कंट्रोल किया जा सकता है कि प्रोफ़ाइलिंग कब शुरू और कब खत्म होगी.

प्रोफ़ाइलिंग शुरू करने के लिए, इनमें से कोई विकल्प चुनें:

console.profile()

प्रोफ़ाइलिंग बंद करने के लिए:

console.profileEnd()

रिपीटेबिलिटी

प्रोफ़ाइलिंग करते समय, पक्का करें कि आपको नतीजे फिर से मिल सकें. इसके बाद ही, आपको पता चलेगा कि ऑप्टिमाइज़ेशन से वाकई में चीज़ें बेहतर हुई हैं या नहीं. साथ ही, फ़ंक्शन लेवल प्रोफ़ाइलिंग आपके पूरे कंप्यूटर के हिसाब से की जाती है. यह कोई सटीक विज्ञान नहीं है. अलग-अलग प्रोफ़ाइल रन पर, आपके कंप्यूटर पर होने वाली कई अन्य चीज़ों का असर पड़ सकता है:

  1. आपके ऐप्लिकेशन में मौजूद कोई ऐसा टाइमर जो किसी और चीज़ को मेज़र करते समय चालू हो जाता है.
  2. गारबेज कलेक्टर अपना काम कर रहा है.
  3. आपके ब्राउज़र का कोई दूसरा टैब, उसी ऑपरेटिंग थ्रेड में ज़्यादा काम कर रहा है.
  4. आपके कंप्यूटर पर कोई दूसरा प्रोग्राम, सीपीयू का इस्तेमाल कर रहा है. इस वजह से, आपका ऐप्लिकेशन धीमा हो गया है.
  5. धरती के गुरुत्वाकर्षण क्षेत्र में अचानक होने वाले बदलाव.

एक प्रोफ़ाइलिंग सेशन में एक ही कोड पाथ को कई बार चलाना भी सही रहता है. इससे, ऊपर बताए गए फ़ैक्टर का असर कम हो जाता है और वीडियो के धीमे हिस्से ज़्यादा साफ़ तौर पर दिखते हैं.

मेज़र करें, बेहतर बनाएं, और फिर से मेज़र करें

जब आपको अपने प्रोग्राम में कोई ऐसी जगह मिले जहां प्रोग्राम धीमा हो रहा है, तो प्रोग्राम के एक्ज़ीक्यूशन को बेहतर बनाने के तरीकों के बारे में सोचें. कोड बदलने के बाद, प्रोफ़ाइल फिर से बनाएं. अगर आपको नतीजे पसंद आते हैं, तो आगे बढ़ें. अगर आपको कोई सुधार नहीं दिखता है, तो आपको बदलाव को पहले जैसा कर देना चाहिए. उसे "इससे कोई नुकसान नहीं होगा" सोचकर न छोड़ें.

ऑप्टिमाइज़ेशन की रणनीतियां

डीओएम इंटरैक्शन को कम करना

वेब क्लाइंट ऐप्लिकेशन की स्पीड को बेहतर बनाने का एक सामान्य तरीका है, डीओएम इंटरैक्शन को कम करना. JavaScript इंजन की स्पीड कई गुना बढ़ गई है. हालांकि, डीओएम को ऐक्सेस करने की स्पीड उतनी तेज़ी से नहीं बढ़ी है. ऐसा कभी नहीं होगा. इसकी कुछ व्यावहारिक वजहें भी हैं. जैसे, स्क्रीन पर लेआउट बनाने और ड्रॉइंग करने में समय लगता है.

डीओएम नोड को कैश मेमोरी में सेव करना

जब भी डीओएम से कोई नोड या नोड की सूची वापस पाई जाए, तो यह सोचें कि क्या बाद में होने वाली किसी गणना (या अगले लूप इटरेशन) में उनका फिर से इस्तेमाल किया जा सकता है. जब तक आप संबंधित क्षेत्र में नोड को जोड़ते या मिटाते नहीं हैं, तब तक ऐसा ही होता है.

पहले:

function getElements() {
  return $('.my-class');
}

बाद में:

var cachedElements;
function getElements() {
  if (cachedElements) {
    return cachedElements;
  }
  cachedElements = $('.my-class');
  return cachedElements;
}

एट्रिब्यूट की वैल्यू को कैश मेमोरी में सेव करना

जिस तरह डीओएम नोड को कैश मेमोरी में सेव किया जा सकता है उसी तरह एट्रिब्यूट की वैल्यू को भी कैश मेमोरी में सेव किया जा सकता है. मान लें कि आपको किसी नोड की स्टाइल के एट्रिब्यूट को ऐनिमेट करना है. अगर आपको पता है कि आप (कोड के उस हिस्से के तौर पर) ही उस एट्रिब्यूट को ऐक्सेस करेंगे, तो हर बार दोहराए जाने पर आखिरी वैल्यू को कैश मेमोरी में सेव किया जा सकता है. इससे आपको उसे बार-बार पढ़ने की ज़रूरत नहीं पड़ेगी.

पहले:

setInterval(function() {
  var ele = $('#element');
  var left = parseInt(ele.css('left'), 10);
  ele.css('left', (left + 5) + 'px');
}, 1000 / 30);

इसके बाद: js var ele = $('#element'); var left = parseInt(ele.css('left'), 10); setInterval(function() { left += 5; ele.css('left', left + 'px'); }, 1000 / 30);

डीओएम मैनिपुलेशन को लूप से बाहर ले जाएं

लूप, अक्सर ऑप्टिमाइज़ेशन के लिए हॉट पॉइंट होते हैं. डीओएम के साथ काम करने के लिए, असल नंबर क्रंचिंग को अलग करने के तरीके सोचें. अक्सर ऐसा होता है कि कैलकुलेशन करने के बाद, सभी नतीजों को एक साथ लागू किया जा सकता है.

पहले:

document.getElementById('target').innerHTML = '';
for(var i = 0; i < array.length; i++) {
  var val = doSomething(array[i]);
  document.getElementById('target').innerHTML += val;
}

बाद में:

var stringBuilder = [];
for(var i = 0; i < array.length; i++) {
  var val = doSomething(array[i]);
  stringBuilder.push(val);
}
document.getElementById('target').innerHTML = stringBuilder.join('');

रीड्रॉ और रीफ़्लो

जैसा कि पहले बताया गया है, डीओएम को ऐक्सेस करने में ज़्यादा समय लगता है. जब आपका कोड किसी ऐसी वैल्यू को पढ़ता है जिसका फिर से हिसाब लगाना पड़ता है, तो यह प्रोसेस बहुत धीमी हो जाती है. ऐसा इसलिए होता है, क्योंकि आपके कोड ने हाल ही में डीओएम में कुछ बदलाव किया है. इसलिए, डीओएम को पढ़ने और उसमें बदलाव करने के ऐक्सेस को आपस में मिलाने से बचना चाहिए. आम तौर पर, आपके कोड को हमेशा दो चरणों में ग्रुप किया जाना चाहिए:

  • पहला चरण: अपने कोड के लिए ज़रूरी डीओएम वैल्यू पढ़ें
  • दूसरा चरण: डीओएम में बदलाव करना

इस तरह का पैटर्न प्रोग्राम न करें:

  • पहला चरण: डीओएम वैल्यू को पढ़ना
  • दूसरा चरण: डीओएम में बदलाव करना
  • तीसरा चरण: कुछ और पढ़ें
  • चौथा चरण: डीओएम में कहीं और बदलाव करें.

पहले:

function paintSlow() {
  var left1 = $('#thing1').css('left');
  $('#otherThing1').css('left', left);
  var left2 = $('#thing2').css('left');
  $('#otherThing2').css('left', left);
}

बाद में:

function paintFast() {
  var left1 = $('#thing1').css('left');
  var left2 = $('#thing2').css('left');
  $('#otherThing1').css('left', left);
  $('#otherThing2').css('left', left);
}

यह सलाह, एक JavaScript एक्ज़ीक्यूशन कॉन्टेक्स्ट में होने वाली कार्रवाइयों के लिए है. (उदाहरण के लिए, किसी इवेंट हैंडलर में, इंटरवल हैंडलर में या Ajax रिस्पॉन्स को हैंडल करते समय.)

ऊपर दिए गए फ़ंक्शन paintSlow() को लागू करने पर, यह इमेज बनती है:

paintSlow()

तेज़ी से लागू करने के तरीके पर स्विच करने से, यह इमेज मिलती है:

तेज़ी से लागू करना

इन इमेज से पता चलता है कि कोड के DOM को ऐक्सेस करने के तरीके को फिर से क्रम में लगाने से, रेंडर करने की परफ़ॉर्मेंस को काफ़ी बेहतर बनाया जा सकता है. इस मामले में, ओरिजनल कोड को स्टाइल की फिर से गिनती करनी होगी और एक जैसा नतीजा पाने के लिए, पेज को दो बार लेआउट करना होगा. इसी तरह का ऑप्टिमाइज़ेशन, "असल दुनिया" के सभी कोड पर लागू किया जा सकता है. इससे कुछ शानदार नतीजे मिल सकते हैं.

ज़्यादा पढ़ें: स्टॉयन स्टेफ़ानोव का लेख, रेंडरिंग: फिर से पेंट करना, फिर से फ़्लो/लेआउट करना, फिर से स्टाइल करना

रीड्रॉ और इवेंट लूप

ब्राउज़र में JavaScript कोड को रन करने के लिए, "इवेंट लूप" मॉडल का इस्तेमाल किया जाता है. डिफ़ॉल्ट रूप से, ब्राउज़र "आइडल" स्थिति में होता है. उपयोगकर्ता के इंटरैक्शन से जुड़े इवेंट या JavaScript टाइमर या Ajax कॉलबैक जैसी चीज़ों की वजह से, इस स्थिति में रुकावट आ सकती है. जब भी JavaScript का कोई हिस्सा इस तरह के रुकावट वाले पॉइंट पर चलता है, तो ब्राउज़र आम तौर पर उसके खत्म होने का इंतज़ार करता है. इसके बाद ही, वह स्क्रीन को फिर से पेंट करता है. हालांकि, बहुत लंबे समय तक चलने वाले JavaScript या अलर्ट-बॉक्स जैसे मामलों में अपवाद हो सकते हैं. इनसे JavaScript के एक्ज़ीक्यूशन में रुकावट आती है.

नतीजे

  1. अगर आपके JavaScript ऐनिमेशन साइकल को लागू होने में 1/30 सेकंड से ज़्यादा समय लगता है, तो आपको स्मूद ऐनिमेशन बनाने में समस्या आएगी. ऐसा इसलिए, क्योंकि JS के लागू होने के दौरान ब्राउज़र फिर से पेंट नहीं करेगा. जब आपको उपयोगकर्ता के इवेंट भी मैनेज करने हों, तो आपको ज़्यादा तेज़ी से काम करना होगा.
  2. कभी-कभी JavaScript की कुछ कार्रवाइयों को थोड़ी देर के लिए रोकना मददगार साबित होता है. उदाहरण के लिए, setTimeout(function() { ... }, 0) इससे ब्राउज़र को यह पता चलता है कि इवेंट लूप के फिर से खाली होते ही कॉलबैक को लागू करना है. हालांकि, कुछ ब्राउज़र कम से कम 10 मिलीसेकंड तक इंतज़ार करेंगे. आपको यह ध्यान रखना होगा कि इससे दो JavaScript एक्ज़ीक्यूशन साइकल बनेंगी, जो समय के हिसाब से एक-दूसरे के बहुत करीब होंगी. दोनों की वजह से, स्क्रीन को फिर से पेंट करना पड़ सकता है. इससे पेंटिंग में लगने वाला कुल समय दोगुना हो सकता है. यह असल में दो पेंट को ट्रिगर करता है या नहीं, यह ब्राउज़र में ह्यूरिस्टिक पर निर्भर करता है.

रेगुलर वर्शन:

function paintFast() {
  var height1 = $('#thing1').css('height');
  var height2 = $('#thing2').css('height');
  $('#otherThing1').css('height', '20px');
  $('#otherThing2').css('height', '20px');
}
रीड्रॉ और इवेंट लूप

आइए, कुछ देरी जोड़ते हैं:

function paintALittleLater() {
  var height1 = $('#thing1').css('height');
  var height2 = $('#thing2').css('height');
  $('#otherThing1').css('height', '20px');
  setTimeout(function() {
    $('#otherThing2').css('height', '20px');
  }, 10)
}
देरी

देरी वाले वर्शन से पता चलता है कि ब्राउज़र दो बार पेंट करता है. हालांकि, पेज में किए गए दो बदलावों के बीच सिर्फ़ 1/100 सेकंड का अंतर है.

लेज़ी इनिशलाइज़ेशन

उपयोगकर्ता ऐसे वेब ऐप्लिकेशन चाहते हैं जो तेज़ी से लोड हों और रिस्पॉन्सिव हों. हालांकि, उपयोगकर्ताओं के लिए धीमेपन की सीमाएं अलग-अलग होती हैं. यह इस बात पर निर्भर करता है कि वे क्या कार्रवाई कर रहे हैं. उदाहरण के लिए, किसी ऐप्लिकेशन को माउसओवर इवेंट पर बहुत ज़्यादा कंप्यूटेशन नहीं करना चाहिए. ऐसा इसलिए, क्योंकि इससे उपयोगकर्ता को खराब अनुभव मिल सकता है. भले ही, उपयोगकर्ता अपना माउस मूव करना जारी रखे. हालांकि, उपयोगकर्ताओं को बटन पर क्लिक करने के बाद, थोड़ी देर इंतज़ार करने की आदत होती है.

इसलिए, यह बेहतर होगा कि आप अपने इनिशलाइज़ेशन कोड को जितना हो सके उतना देर से लागू करें. उदाहरण के लिए, जब उपयोगकर्ता किसी ऐसे बटन पर क्लिक करे जो आपके ऐप्लिकेशन के किसी खास कॉम्पोनेंट को चालू करता है.

पहले: js var things = $('.ele > .other * div.className'); $('#button').click(function() { things.show() });

इसके बाद: js $('#button').click(function() { $('.ele > .other * div.className').show() });

इवेंट डेलिगेशन

किसी पेज पर इवेंट हैंडलर को स्प्रेड करने में ज़्यादा समय लग सकता है. साथ ही, एलिमेंट को डाइनैमिक तौर पर बदलने के बाद, यह काम मुश्किल हो सकता है. ऐसा इसलिए, क्योंकि नए एलिमेंट में इवेंट हैंडलर को फिर से अटैच करना पड़ता है.

इस मामले में, इवेंट डेलिगेशन नाम की तकनीक का इस्तेमाल करना ही इसका समाधान है. एलिमेंट में अलग-अलग इवेंट हैंडलर अटैच करने के बजाय, कई ब्राउज़र इवेंट के बबलिंग नेचर का इस्तेमाल किया जाता है. इसके लिए, इवेंट हैंडलर को पैरंट नोड से अटैच किया जाता है और इवेंट के टारगेट नोड की जांच की जाती है, ताकि यह देखा जा सके कि इवेंट काम का है या नहीं.

jQuery में इसे आसानी से इस तरह दिखाया जा सकता है:

$('#parentNode').delegate('.button', 'click', function() { ... });

इवेंट डेलिगेशन का इस्तेमाल कब नहीं करना चाहिए

कभी-कभी इसका उल्टा भी हो सकता है: इवेंट डेलिगेशन का इस्तेमाल करने पर, आपको परफ़ॉर्मेंस से जुड़ी समस्या आ रही हो. इवेंट डेलिगेशन की मदद से, प्रोसेस शुरू करने में लगने वाले समय को कम किया जा सकता है. हालांकि, कोई इवेंट काम का है या नहीं, यह जांचने के लिए हर बार उस इवेंट को शुरू करने पर शुल्क देना पड़ता है. यह महंगा हो सकता है. खास तौर पर, "माउसओवर" या "माउस को घुमाना" जैसे बार-बार होने वाले इवेंट के लिए.

आम तौर पर होने वाली समस्याएं और उनके समाधान

$(document).ready में जो काम मैं करता/करती हूं उनमें बहुत समय लगता है

माल्टे की निजी सलाह: $(document).ready में कभी कुछ न करें. अपने दस्तावेज़ को उसके फ़ाइनल फ़ॉर्मैट में डिलीवर करने की कोशिश करें. ठीक है, आपको इवेंट लिसनर रजिस्टर करने की अनुमति है. हालांकि, इसके लिए सिर्फ़ आईडी-सिलेक्टर और/या इवेंट डेलिगेशन का इस्तेमाल किया जा सकता है. "mousemove" जैसे महंगे इवेंट के लिए, रजिस्ट्रेशन में तब तक देरी करें, जब तक उनकी ज़रूरत न हो (काम के एलिमेंट पर माउसओवर इवेंट).

अगर आपको असल डेटा पाने के लिए, Ajax अनुरोध करने जैसे काम करने हैं, तो एक अच्छा ऐनिमेशन दिखाएं. अगर यह ऐनिमेट किया गया GIF या ऐसा ही कुछ है, तो हो सकता है कि आप ऐनिमेशन को डेटा यूआरआई के तौर पर शामिल करना चाहें.

मैंने पेज पर एक Flash मूवी जोड़ी है, इसलिए सब कुछ बहुत धीमा हो गया है

किसी पेज पर Flash जोड़ने से, रेंडरिंग की प्रोसेस हमेशा थोड़ी धीमी हो जाएगी. ऐसा इसलिए, क्योंकि विंडो के फ़ाइनल लेआउट को ब्राउज़र और Flash प्लग इन के बीच "नेगोशिएट" करना पड़ता है. अगर आपके लिए अपने पेजों पर Flash का इस्तेमाल करना ज़रूरी है, तो पक्का करें कि आपने "wmode" Flash-पैरामीटर को "window" वैल्यू पर सेट किया हो. यह डिफ़ॉल्ट वैल्यू होती है. इससे एचटीएमएल और फ़्लैश एलिमेंट को कंपोज़िट करने की सुविधा बंद हो जाएगी. आपको फ़्लैश मूवी के ऊपर मौजूद एचटीएमएल एलिमेंट नहीं दिखेगा और आपकी फ़्लैश मूवी पारदर्शी नहीं हो सकती. इससे आपको थोड़ी परेशानी हो सकती है, लेकिन इससे आपके कैंपेन की परफ़ॉर्मेंस में काफ़ी सुधार होगा. उदाहरण के लिए, देखें कि youtube.com किस तरह मुख्य मूवी प्लेयर के ऊपर लेयर डालने से बचता है.

मैं localStorage में चीज़ें सेव कर रहा/रही हूं, लेकिन अब मेरा ऐप्लिकेशन रुक-रुककर चल रहा है

localStorage में डेटा सेव करना एक सिंक्रोनस प्रोसेस है. इसमें आपकी हार्ड डिस्क का इस्तेमाल होता है. ऐनिमेशन के दौरान, आपको "लंबे समय तक चलने वाले" सिंक्रोनस ऑपरेशन नहीं करने चाहिए. localStorage के ऐक्सेस को अपने कोड में ऐसी जगह पर ले जाएं जहां आपको पक्का पता हो कि उपयोगकर्ता कुछ नहीं कर रहा है और कोई ऐनिमेशन नहीं चल रहा है.

प्रोफ़ाइलिंग से पता चलता है कि jQuery सिलेक्टर बहुत धीमा है

सबसे पहले, आपको यह पक्का करना होगा कि आपका सिलेक्टर, document.querySelectorAll की मदद से चलाया जा सकता है. JavaScript कंसोल में इसकी जांच की जा सकती है. अगर कोई अपवाद है, तो अपने सिलेक्टर को फिर से लिखें, ताकि आपके JavaScript फ़्रेमवर्क के किसी खास एक्सटेंशन का इस्तेमाल न किया जाए. इससे मॉडर्न ब्राउज़र में आपके सिलेक्टर की स्पीड काफ़ी बढ़ जाएगी.

अगर इससे मदद नहीं मिलती है या आपको मॉडर्न ब्राउज़र में भी तेज़ी से काम करना है, तो ये दिशा-निर्देश अपनाएं:

  • अपने सिलेक्टर के दाईं ओर, ज़्यादा से ज़्यादा सटीक जानकारी दें.
  • सबसे दाईं ओर मौजूद सिलेक्टर के तौर पर, ऐसे टैग नाम का इस्तेमाल करें जिसका इस्तेमाल अक्सर नहीं किया जाता.
  • अगर किसी भी तरीके से काम नहीं बनता है, तो कोड को फिर से लिखने के बारे में सोचें, ताकि आईडी-सिलेक्टर का इस्तेमाल किया जा सके

इन सभी डीओएम मैनिपुलेशन में काफ़ी समय लगता है

डीओएम नोड को शामिल करने, हटाने, और अपडेट करने की प्रोसेस बहुत धीमी हो सकती है. आम तौर पर, एचटीएमएल की एक बड़ी स्ट्रिंग जनरेट करके और पुराने कॉन्टेंट को बदलने के लिए domNode.innerHTML = newHTML का इस्तेमाल करके, इसे ऑप्टिमाइज़ किया जा सकता है. ध्यान दें कि इससे कोड को मैनेज करना मुश्किल हो सकता है और IE में मेमोरी लीक हो सकती है. इसलिए, सावधान रहें.

एक और आम समस्या यह है कि आपके इनिशलाइज़ेशन कोड से बहुत सारा एचटीएमएल बन सकता है. उदाहरण के लिए, एक jQuery प्लगिन जो किसी चुनिंदा बॉक्स को कई सारे div में बदल देता है. ऐसा इसलिए, क्योंकि डिज़ाइनर को उपयोगकर्ता अनुभव के सबसे सही तरीकों के बारे में जानकारी नहीं थी. अगर आपको अपने पेज को तेज़ी से लोड होने वाला बनाना है, तो ऐसा कभी न करें. इसके बजाय, सर्वर साइड से सभी मार्कअप को उनके फ़ाइनल फ़ॉर्म में डिलीवर करें. इसमें भी कई समस्याएं हैं. इसलिए, अच्छी तरह सोच लें कि क्या स्पीड के लिए, क्वालिटी से समझौता करना सही है.

टूल

  1. JSPerf - JavaScript के छोटे स्निपेट की परफ़ॉर्मेंस की तुलना करना
  2. Firebug - Firefox में प्रोफ़ाइल बनाने के लिए
  3. Google Chrome डेवलपर टूल (Safari में WebInspector के तौर पर उपलब्ध है)
  4. DOM Monster - DOM की परफ़ॉर्मेंस को ऑप्टिमाइज़ करने के लिए
  5. DynaTrace Ajax Edition - Internet Explorer में प्रोफ़ाइल बनाने और पेंट ऑप्टिमाइज़ेशन के लिए

इस बारे में और पढ़ें

  1. Google Speed
  2. jQuery की परफ़ॉर्मेंस पर पॉल आयरिश
  3. Extreme JavaScript Performance (स्लाइड डेक)