वेब ऐप्लिकेशन को तेज़ी से लोड करने के तरीके. भले ही, वह फ़ीचर फ़ोन पर हो

हमने PROXX में कोड स्प्लिटिंग, कोड इनलाइनिंग, और सर्वर-साइड रेंडरिंग का इस्तेमाल कैसे किया.

Google I/O 2019 में, मारिको, जेक, और मैंने PROXX को लॉन्च किया. यह वेब के लिए, Minesweeper का एक आधुनिक क्लोन है. PROXX को जो चीज़ सबसे अलग बनाती है वह है सुलभता पर इसका फ़ोकस (इसे स्क्रीनरीडर की मदद से खेला जा सकता है!) और फ़ीचर फ़ोन के साथ-साथ हाई-एंड कंप्यूटर पर भी चलने की इसकी क्षमता. फ़ीचर फ़ोन में कई तरह की पाबंदियां होती हैं:

  • कमज़ोर सीपीयू
  • कमज़ोर या मौजूद न होने वाले जीपीयू
  • टच इनपुट के बिना छोटी स्क्रीन
  • बहुत कम मेमोरी

हालांकि, इनमें मॉडर्न ब्राउज़र काम करता है और ये काफ़ी किफ़ायती होते हैं. इस वजह से, उभरते बाज़ारों में फ़ीचर फ़ोन फिर से लोकप्रिय हो रहे हैं. इनकी कीमत की वजह से, ऐसे नए दर्शक भी ऑनलाइन आ सकते हैं जो पहले इन्हें नहीं खरीद सकते थे. साथ ही, वे मॉडर्न वेब का इस्तेमाल कर सकते हैं. साल 2019 में, यह अनुमान लगाया गया था कि सिर्फ़ भारत में करीब 40 करोड़ फ़ीचर फ़ोन बेचे जाएंगे. इसलिए, फ़ीचर फ़ोन इस्तेमाल करने वाले लोग आपकी ऑडियंस का एक अहम हिस्सा हो सकते हैं. इसके अलावा, उभरते हुए बाज़ारों में 2G जैसी कनेक्शन स्पीड आम बात है. हमने PROXX को फ़ीचर फ़ोन पर बेहतर तरीके से काम करने लायक कैसे बनाया?

PROXX गेमप्ले.

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

यह दो हिस्सों की सीरीज़ का पहला हिस्सा है. पहले हिस्से में, पेज लोड होने की परफ़ॉर्मेंस पर फ़ोकस किया गया है. वहीं, दूसरे हिस्से में रनटाइम परफ़ॉर्मेंस पर फ़ोकस किया जाएगा.

मौजूदा स्थिति को कैप्चर करना

असल डिवाइस पर, पेज लोड होने की परफ़ॉर्मेंस की जांच करना ज़रूरी है. अगर आपके पास कोई असली डिवाइस नहीं है, तो हमारा सुझाव है कि आप WebPageTest का इस्तेमाल करें. खास तौर पर, "सिंपल" सेटअप का इस्तेमाल करें. WPT, एम्युलेट किए गए 3G कनेक्शन वाले असली डिवाइस पर, लोड होने से जुड़े कई टेस्ट करता है.

3G, मेज़र करने के लिए अच्छी स्पीड है. भले ही, आपको 4G, एलटीई या जल्द ही 5G इस्तेमाल करने की आदत हो, लेकिन मोबाइल इंटरनेट की असलियत काफ़ी अलग है. शायद आप किसी ट्रेन, कॉन्फ़्रेंस, कॉन्सर्ट या फ़्लाइट में हों. वहां आपको 3G या उससे भी खराब नेटवर्क मिल सकता है.

हालांकि, इस लेख में हम 2G पर फ़ोकस करेंगे. इसकी वजह यह है कि PROXX, अपनी टारगेट ऑडियंस में खास तौर पर फ़ीचर फ़ोन और उभरते बाज़ारों को टारगेट कर रहा है. WebPageTest की जांच पूरी होने के बाद, आपको वॉटरफ़ॉल (DevTools में दिखने वाले वॉटरफ़ॉल जैसा) और सबसे ऊपर एक फ़िल्मस्ट्रिप दिखती है. फ़िल्म स्ट्रिप से पता चलता है कि ऐप्लिकेशन लोड होने के दौरान, उपयोगकर्ता को क्या दिखता है. 2G पर, PROXX के ऑप्टिमाइज़ नहीं किए गए वर्शन को लोड होने में काफ़ी समय लगता है:

फ़िल्मस्ट्रिप वीडियो से पता चलता है कि जब PROXX को किसी असली, कम क्षमता वाले डिवाइस पर एम्युलेट किए गए 2G कनेक्शन पर लोड किया जाता है, तो उपयोगकर्ता को क्या दिखता है.

3G नेटवर्क पर लोड होने पर, उपयोगकर्ता को चार सेकंड तक सफ़ेद स्क्रीन दिखती है. 2G नेटवर्क पर, उपयोगकर्ता को आठ सेकंड से ज़्यादा समय तक कुछ भी नहीं दिखता. अगर आपने परफ़ॉर्मेंस क्यों मायने रखती है लेख पढ़ा है, तो आपको पता होगा कि इंतज़ार न कर पाने की वजह से, हमने अपने संभावित उपयोगकर्ताओं का एक बड़ा हिस्सा खो दिया है. स्क्रीन पर कुछ भी दिखने के लिए, उपयोगकर्ता को 62 केबी का पूरा JavaScript डाउनलोड करना होगा. इस मामले में अच्छी बात यह है कि स्क्रीन पर कुछ भी दिखने पर, वह इंटरैक्टिव भी होता है. या फिर ऐसा होना चाहिए?

PROXX के ऑप्टिमाइज़ नहीं किए गए वर्शन में [फ़र्स्ट मीनिंगफ़ुल पेंट][FMP] _तकनीकी तौर पर_ [इंटरैक्टिव][TTI] है, लेकिन उपयोगकर्ता के लिए बेकार है.

जब gzip'd JS का करीब 62 केबी डेटा डाउनलोड हो जाता है और डीओएम जनरेट हो जाता है, तब उपयोगकर्ता को हमारा ऐप्लिकेशन दिखता है. ऐप्लिकेशन तकनीकी तौर पर इंटरैक्टिव होता है. हालांकि, विज़ुअल को देखने पर एक अलग ही सच्चाई सामने आती है. वेब फ़ॉन्ट अब भी बैकग्राउंड में लोड हो रहे हैं. जब तक वे लोड नहीं हो जाते, तब तक उपयोगकर्ता को कोई टेक्स्ट नहीं दिखेगा. हालांकि, इस स्थिति को फ़र्स्ट मीनिंगफ़ुल पेंट (एफ़एमपी) के तौर पर माना जाता है, लेकिन इसे पूरी तरह से इंटरैक्टिव नहीं माना जाता. इसकी वजह यह है कि उपयोगकर्ता को यह नहीं पता होता कि इनपुट किस बारे में हैं. ऐप्लिकेशन को इस्तेमाल के लिए तैयार होने में, 3G पर एक सेकंड और 2G पर तीन सेकंड और लगते हैं. कुल मिलाकर, ऐप्लिकेशन को इंटरैक्टिव होने में 3G पर छह सेकंड और 2G पर 11 सेकंड लगते हैं.

वॉटरफ़ॉल ऐनलिसिस

अब जब हमें पता चल गया है कि उपयोगकर्ता को क्या दिखता है, तो हमें यह पता लगाना होगा कि क्यों. इसके लिए, हम वॉटरफ़ॉल को देख सकते हैं और विश्लेषण कर सकते हैं कि रिसॉर्स लोड होने में इतना समय क्यों लग रहा है. PROXX के लिए, हमारे 2G ट्रेस में दो बड़ी गड़बड़ियां दिखती हैं:

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

कनेक्शन की संख्या कम करना

हर पतली लाइन (dns, connect, ssl) का मतलब है कि एक नया एचटीटीपी कनेक्शन बनाया गया है. नया कनेक्शन सेट अप करना महंगा होता है, क्योंकि इसमें 3G पर करीब एक सेकंड और 2G पर करीब 2.5 सेकंड लगते हैं. हमारे वॉटरफ़ॉल में, हमें इसके लिए एक नया कनेक्शन दिखता है:

  • अनुरोध #1: हमारा index.html
  • fonts.googleapis.com से फ़ॉन्ट स्टाइल का अनुरोध #5
  • अनुरोध #8: Google Analytics
  • fonts.gstatic.com से फ़ॉन्ट फ़ाइल अपलोड करने की ज़रूरी शर्त #9
  • अनुरोध #14: वेब ऐप्लिकेशन मेनिफ़ेस्ट

index.html के लिए नया कनेक्शन ज़रूरी है. कॉन्टेंट पाने के लिए, ब्राउज़र को हमारे सर्वर से कनेक्शन बनाना होगा. Google Analytics के लिए नए कनेक्शन से बचा जा सकता है. इसके लिए, Minimal Analytics जैसी किसी चीज़ को इनलाइन किया जा सकता है. हालांकि, Google Analytics हमारे ऐप्लिकेशन को रेंडर होने या इंटरैक्टिव बनने से नहीं रोकता है. इसलिए, हमें इस बात की परवाह नहीं है कि यह कितनी तेज़ी से लोड होता है. Google Analytics को आइडल टाइम में लोड किया जाना चाहिए, जब बाकी सब कुछ पहले ही लोड हो चुका हो. इस तरह, शुरुआती लोड के दौरान यह बैंडविड्थ या प्रोसेसिंग पावर का इस्तेमाल नहीं करेगा. वेब ऐप्लिकेशन मेनिफ़ेस्ट के लिए नया कनेक्शन, फ़ेच स्पेक के मुताबिक तय किया गया है. ऐसा इसलिए, क्योंकि मेनिफ़ेस्ट को बिना क्रेडेंशियल वाले कनेक्शन पर लोड करना होता है. वेब ऐप्लिकेशन मेनिफ़ेस्ट, हमारे ऐप्लिकेशन को रेंडर होने या इंटरैक्टिव बनने से नहीं रोकता. इसलिए, हमें इस बारे में ज़्यादा चिंता करने की ज़रूरत नहीं है.

हालांकि, दो फ़ॉन्ट और उनकी स्टाइल की वजह से समस्या होती है, क्योंकि वे रेंडरिंग और इंटरैक्टिविटी को ब्लॉक करते हैं. अगर हम fonts.googleapis.com से डिलीवर की गई सीएसएस को देखें, तो इसमें सिर्फ़ दो @font-face नियम हैं. हर फ़ॉन्ट के लिए एक नियम. फ़ॉन्ट की स्टाइल इतनी छोटी हैं कि हमने उन्हें अपने एचटीएमएल में इनलाइन करने का फ़ैसला किया. इससे एक ग़ैर-ज़रूरी कनेक्शन हट गया. फ़ॉन्ट फ़ाइलों के लिए कनेक्शन सेटअप की लागत से बचने के लिए, हम उन्हें अपने सर्वर पर कॉपी कर सकते हैं.

लोड को पैरलल करना

वॉटरफ़ॉल को देखकर, हमें पता चलता है कि पहली JavaScript फ़ाइल लोड होने के बाद, नई फ़ाइलें तुरंत लोड होने लगती हैं. आम तौर पर, ऐसा मॉड्यूल डिपेंडेंसी के लिए होता है. ऐसा हो सकता है कि हमारे मुख्य मॉड्यूल में स्टैटिक इंपोर्ट हों. इसलिए, JavaScript तब तक नहीं चल सकता, जब तक वे इंपोर्ट लोड नहीं हो जाते. यहां ध्यान देने वाली बात यह है कि इस तरह की डिपेंडेंसी, बिल्ड के समय ही पता चल जाती हैं. हम <link rel="preload"> टैग का इस्तेमाल करके यह पक्का कर सकते हैं कि एचटीएमएल मिलते ही, सभी डिपेंडेंसी लोड होने लगें.

नतीजे

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

हम WebPageTest की फ़िल्मस्ट्रिप का इस्तेमाल करके देखते हैं कि हमारे बदलावों से क्या हासिल हुआ है.

इन बदलावों से हमारा टीटीआई 11 से घटकर 8.5 हो गया. यह कनेक्शन सेटअप करने में लगने वाले समय से करीब 2.5 सेकंड कम है. हमारा मकसद, कनेक्शन सेटअप करने में लगने वाले समय को कम करना था. हमने बहुत अच्छा काम किया.

प्रीरेंडरिंग

हमने TTI को कम कर दिया है, लेकिन हमने उस सफ़ेद स्क्रीन पर कोई असर नहीं डाला है जो उपयोगकर्ता को 8.5 सेकंड तक दिखती है. FMP में सबसे बड़े सुधार, index.html में स्टाइल किया गया मार्कअप भेजकर किए जा सकते हैं. इसके लिए, प्रीरेंडरिंग और सर्वर-साइड रेंडरिंग जैसी सामान्य तकनीकों का इस्तेमाल किया जाता है. ये दोनों तकनीकें एक-दूसरे से काफ़ी मिलती-जुलती हैं. इनके बारे में वेब पर रेंडरिंग में बताया गया है. दोनों तकनीकों में, वेब ऐप्लिकेशन को Node में चलाया जाता है और नतीजे के तौर पर मिलने वाले डीओएम को एचटीएमएल में सीरियलाइज़ किया जाता है. सर्वर-साइड रेंडरिंग, सर्वर साइड पर हर अनुरोध के लिए ऐसा करती है. वहीं, प्रीरेंडरिंग, बिल्ड टाइम के दौरान ऐसा करती है और आउटपुट को आपके नए index.html के तौर पर सेव करती है. PROXX एक JAMStack ऐप्लिकेशन है और इसमें कोई सर्वर साइड नहीं है. इसलिए, हमने प्रीरेंडरिंग लागू करने का फ़ैसला लिया.

प्री-रेंडरर को लागू करने के कई तरीके हैं. PROXX में, हमने Puppeteer का इस्तेमाल करने का फ़ैसला लिया. यह Chrome को बिना किसी यूज़र इंटरफ़ेस (यूआई) के शुरू करता है. साथ ही, आपको Node API की मदद से, उस इंस्टेंस को रिमोट से कंट्रोल करने की सुविधा देता है. हम इसका इस्तेमाल अपने मार्कअप और JavaScript को इंजेक्ट करने के लिए करते हैं. इसके बाद, डीओएम को एचटीएमएल की स्ट्रिंग के तौर पर पढ़ते हैं. हम सीएसएस मॉड्यूल का इस्तेमाल कर रहे हैं. इसलिए, हमें अपनी ज़रूरत के हिसाब से स्टाइल की सीएसएस इनलाइनिंग बिना किसी शुल्क के मिलती है.

  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.setContent(rawIndexHTML);
  await page.evaluate(codeToRun);
  const renderedHTML = await page.content();
  browser.close();
  await writeFile("index.html", renderedHTML);

इससे हमें उम्मीद है कि हमारे एफ़एमपी में सुधार होगा. हमें अब भी पहले की तरह ही JavaScript को लोड और एक्ज़ीक्यूट करना होगा. इसलिए, हमें टीटीआई में ज़्यादा बदलाव की उम्मीद नहीं करनी चाहिए. अगर कुछ भी हो, तो हमारा index.html बड़ा हो गया है और यह हमारे टीटीआई को थोड़ा पीछे धकेल सकता है. इसका पता लगाने का सिर्फ़ एक तरीका है: WebPageTest चलाना.

फ़िल्मस्ट्रिप से पता चलता है कि हमारी एफ़एमपी मेट्रिक में काफ़ी सुधार हुआ है. टीटीआई पर ज़्यादा असर नहीं पड़ता.

हमारा फ़र्स्ट मीनिंगफ़ुल पेंट 8.5 सेकंड से घटकर 4.9 सेकंड हो गया है, जो कि एक बहुत बड़ा सुधार है. हमारा टीटीआई अब भी करीब 8.5 सेकंड पर होता है. इसलिए, इस बदलाव से इस पर कोई खास असर नहीं पड़ा है. हमने यहां जो किया है वह परसेप्चुअल बदलाव है. कुछ लोग इसे हाथ की सफ़ाई भी कह सकते हैं. गेम के इंटरमीडिएट विज़ुअल को रेंडर करके, हम गेम लोड होने की परफ़ॉर्मेंस को बेहतर बना रहे हैं.

इनलाइन करना

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

अनुरोध का हल्का सेक्शन दिखाता है कि अनुरोध को जवाब का पहला बाइट मिलने का इंतज़ार है.

अपने वॉटरफ़ॉल को देखकर, हम यह जान सकते हैं कि सभी अनुरोधों को रिस्पॉन्स की पहली बाइट मिलने में ज़्यादातर समय इंतज़ार करने में बीत जाता है.

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

सीएसएस मॉड्यूल और Puppeteer पर आधारित प्रीरेंडरर की मदद से, हमारी ज़रूरी सीएसएस पहले से ही इनलाइन है. JavaScript के लिए, हमें अपने ज़रूरी मॉड्यूल और उन पर निर्भर मॉड्यूल को इनलाइन करना होगा. इस्तेमाल किए जा रहे बंडलर के हिसाब से, इस टास्क को पूरा करने में कम या ज़्यादा समय लग सकता है.

JavaScript को इनलाइन करके, हमने टीटीआई को 8.5 सेकंड से घटाकर 7.2 सेकंड कर दिया है.

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

अग्रैसिव कोड स्प्लिटिंग

हां, हमारे index.html में वह सब कुछ मौजूद है जो इसे इंटरैक्टिव बनाने के लिए ज़रूरी है. हालांकि, ध्यान से देखने पर पता चलता है कि इसमें बाकी सब कुछ भी शामिल है. हमारी index.html का साइज़ करीब 43 केबी है. आइए, इसे उस चीज़ से जोड़ते हैं जिससे उपयोगकर्ता शुरुआत में इंटरैक्ट कर सकता है: हमारे पास गेम को कॉन्फ़िगर करने के लिए एक फ़ॉर्म है. इसमें कुछ कॉम्पोनेंट, एक स्टार्ट बटन, और शायद उपयोगकर्ता की सेटिंग को बनाए रखने और लोड करने के लिए कुछ कोड शामिल हैं. बस इतना ही. 43 केबी बहुत ज़्यादा लग रहा है.

PROXX का लैंडिंग पेज. यहां सिर्फ़ ज़रूरी कॉम्पोनेंट इस्तेमाल किए जाते हैं.

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

PROXX के `index.html` के कॉन्टेंट का विश्लेषण करने पर, कई ऐसे रिसॉर्स दिखते हैं जिनकी ज़रूरत नहीं है. अहम संसाधनों को हाइलाइट किया जाता है.

हमें कोड स्प्लिट करना होगा. कोड स्प्लिटिंग की मदद से, आपके मोनोलेथिक बंडल को छोटे-छोटे हिस्सों में बांटा जाता है. इन्हें मांग पर लेज़ी-लोड किया जा सकता है. Webpack, Rollup, और Parcel जैसे लोकप्रिय बंडलर, डाइनैमिक import() का इस्तेमाल करके कोड को अलग-अलग हिस्सों में बांटने की सुविधा देते हैं. बंडलर आपके कोड का विश्लेषण करेगा और स्टैटिक तौर पर इंपोर्ट किए गए सभी मॉड्यूल को इनलाइन करेगा. डाइनैमिक तौर पर इंपोर्ट की गई हर चीज़ को उसकी अपनी फ़ाइल में डाला जाएगा. साथ ही, import() कॉल के लागू होने के बाद ही, उसे नेटवर्क से फ़ेच किया जाएगा. ज़ाहिर है कि नेटवर्क पर जाने में समय लगता है. इसलिए, ऐसा तभी करें, जब आपके पास समय हो. यहां आपको उन मॉड्यूल को स्टैटिक तरीके से इंपोर्ट करना होगा जो लोड होने के समय बेहद ज़रूरी हैं. साथ ही, बाकी सभी मॉड्यूल को डाइनैमिक तरीके से लोड करना होगा. हालांकि, आपको उन मॉड्यूल को लेज़ी-लोड करने के लिए आखिरी समय तक इंतज़ार नहीं करना चाहिए जिनका इस्तेमाल ज़रूर किया जाएगा. फ़िल वॉल्टन का Idle Until Urgent, लेज़ी लोडिंग और ईगर लोडिंग के बीच संतुलन बनाने का एक बेहतरीन तरीका है.

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

export default function deferred(componentPromise) {
  return class Deferred extends Component {
    constructor(props) {
      super(props);
      this.state = {
        LoadedComponent: undefined
      };
      componentPromise.then(component => {
        this.setState({ LoadedComponent: component });
      });
    }

    render({ loaded, loading }, { LoadedComponent }) {
      if (LoadedComponent) {
        return loaded(LoadedComponent);
      }
      return loading();
    }
  };
}

इसकी मदद से, हम अपने render() फ़ंक्शन में कॉम्पोनेंट के Promise का इस्तेमाल कर सकते हैं. उदाहरण के लिए, <Nebula> कॉम्पोनेंट, ऐनिमेशन वाली बैकग्राउंड इमेज को रेंडर करता है. कॉम्पोनेंट लोड होने के दौरान, इसे खाली <div> से बदल दिया जाएगा. कॉम्पोनेंट लोड होने और इस्तेमाल के लिए तैयार होने के बाद, <div> को असल कॉम्पोनेंट से बदल दिया जाएगा.

const NebulaDeferred = deferred(
  import("/components/nebula").then(m => m.default)
);

return (
  // ...
  <NebulaDeferred
    loading={() => <div />}
    loaded={Nebula => <Nebula />}
  />
);

इन सभी बदलावों के बाद, हमने index.html का साइज़ सिर्फ़ 20 केबी कर दिया. यह ओरिजनल साइज़ के आधे से भी कम है. इसका एफ़एमपी और टीटीआई पर क्या असर पड़ता है? WebPageTest से पता चलेगा!

फ़िल्मस्ट्रिप से पुष्टि होती है कि हमारा टीटीआई अब 5.4 सेकंड पर है. यह हमारे ओरिजनल 11s मॉडल से काफ़ी बेहतर है.

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

हाथ की सफ़ाई के और वीडियो

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

नतीजा

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

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

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

दूसरे पार्ट के लिए हमारे साथ बने रहें. इसमें हम बताएंगे कि कम स्टोरेज वाले डिवाइसों पर रनटाइम की परफ़ॉर्मेंस को कैसे ऑप्टिमाइज़ किया जाए.