आपको अपने उपयोगकर्ताओं को ज़रूरत से ज़्यादा कोड भेजने की ज़रूरत नहीं है. इसलिए, अपने बंडल को स्प्लिट करें, ताकि ऐसा कभी न हो!
React.lazy तरीके से, डाइनैमिक इंपोर्ट का इस्तेमाल करके कॉम्पोनेंट लेवल पर React ऐप्लिकेशन को कोड-स्प्लिट करना आसान हो जाता है.
import React, { lazy } from 'react';
const AvatarComponent = lazy(() => import('./AvatarComponent'));
const DetailsComponent = () => (
<div>
<AvatarComponent />
</div>
)
यह जानकारी आपके काम की क्यों है?
एक बड़े React ऐप्लिकेशन में आम तौर पर कई कॉम्पोनेंट, यूटिलिटी मेथड, और तीसरे पक्ष की लाइब्रेरी शामिल होती हैं. अगर किसी ऐप्लिकेशन के अलग-अलग हिस्सों को सिर्फ़ ज़रूरत पड़ने पर लोड करने की कोशिश नहीं की जाती है, तो JavaScript का एक बड़ा बंडल आपके उपयोगकर्ताओं को भेज दिया जाएगा. ऐसा तब होगा, जब वे पहला पेज लोड करेंगे. इससे पेज की परफ़ॉर्मेंस पर काफ़ी असर पड़ सकता है.
React.lazy फ़ंक्शन, किसी ऐप्लिकेशन में कॉम्पोनेंट को JavaScript के अलग-अलग हिस्सों में बांटने का एक आसान तरीका उपलब्ध कराता है. इसके लिए, आपको ज़्यादा मेहनत नहीं करनी पड़ती. इसके बाद, Suspense कॉम्पोनेंट के साथ जोड़ने पर, लोडिंग स्टेटस को मैनेज किया जा सकता है.
सस्पेंस
उपयोगकर्ताओं को बड़ा JavaScript पेलोड भेजने में समस्या यह है कि पेज को लोड होने में ज़्यादा समय लगता है. खास तौर पर, कमज़ोर डिवाइसों और इंटरनेट कनेक्शन पर. इसलिए, कोड स्प्लिटिंग और लेज़ी लोडिंग बेहद मददगार साबित होती है.
हालांकि, जब नेटवर्क पर कोड-स्प्लिट कॉम्पोनेंट फ़ेच किया जाता है, तो उपयोगकर्ताओं को हमेशा थोड़ी देरी का सामना करना पड़ता है. इसलिए, लोड होने की स्थिति को दिखाना ज़रूरी है. Suspense कॉम्पोनेंट के साथ React.lazy का इस्तेमाल करने से, यह समस्या हल हो जाती है.
import React, { lazy, Suspense } from 'react';
const AvatarComponent = lazy(() => import('./AvatarComponent'));
const renderLoader = () => <p>Loading</p>;
const DetailsComponent = () => (
<Suspense fallback={renderLoader()}>
<AvatarComponent />
</Suspense>
)
Suspense, fallback कॉम्पोनेंट को स्वीकार करता है. इससे आपको किसी भी React कॉम्पोनेंट को लोडिंग स्टेटस के तौर पर दिखाने की सुविधा मिलती है. यहां दिए गए उदाहरण से जानें कि यह कैसे काम करता है.
अवतार सिर्फ़ तब रेंडर होता है, जब बटन पर क्लिक किया जाता है. इसके बाद, निलंबित किए गए AvatarComponent के लिए ज़रूरी कोड को वापस पाने का अनुरोध किया जाता है.
इस दौरान, फ़ॉलबैक लोडिंग कॉम्पोनेंट दिखता है.
यहां, AvatarComponent को बनाने वाला कोड छोटा है. इसलिए, लोडिंग स्पिनर सिर्फ़ कुछ समय के लिए दिखता है. बड़े कॉम्पोनेंट को लोड होने में ज़्यादा समय लग सकता है. खास तौर पर, कमज़ोर इंटरनेट कनेक्शन पर.
यह कैसे काम करता है, इसे बेहतर तरीके से समझाने के लिए:
- साइट की झलक देखने के लिए, ऐप्लिकेशन देखें को दबाएं. इसके बाद, फ़ुलस्क्रीन
को दबाएं.
- DevTools खोलने के लिए, `Control+Shift+J` (या Mac पर `Command+Option+J`) दबाएं.
- नेटवर्क टैब पर क्लिक करें.
- थ्रॉटलिंग ड्रॉपडाउन पर क्लिक करें. यह डिफ़ॉल्ट रूप से, कोई थ्रॉटलिंग नहीं पर सेट होता है. Fast 3G को चुनें.
- ऐप्लिकेशन में, Click Me बटन पर क्लिक करें.
लोड होने की जानकारी देने वाला इंडिकेटर अब ज़्यादा देर तक दिखेगा. ध्यान दें कि AvatarComponent बनाने वाला सारा कोड, अलग-अलग हिस्सों में फ़ेच किया जाता है.
एक से ज़्यादा कॉम्पोनेंट निलंबित करना
Suspense की एक और सुविधा यह है कि इसकी मदद से, कई कॉम्पोनेंट को लोड होने से रोका जा सकता है. भले ही, वे सभी लेज़ी लोड किए गए हों.
उदाहरण के लिए:
import React, { lazy, Suspense } from 'react';
const AvatarComponent = lazy(() => import('./AvatarComponent'));
const InfoComponent = lazy(() => import('./InfoComponent'));
const MoreInfoComponent = lazy(() => import('./MoreInfoComponent'));
const renderLoader = () => <p>Loading</p>;
const DetailsComponent = () => (
<Suspense fallback={renderLoader()}>
<AvatarComponent />
<InfoComponent />
<MoreInfoComponent />
</Suspense>
)
यह कई कॉम्पोनेंट को रेंडर होने में लगने वाले समय को बढ़ाने का एक बेहद मददगार तरीका है. इससे सिर्फ़ एक लोडिंग स्टेट दिखती है. सभी कॉम्पोनेंट फ़ेच होने के बाद, उपयोगकर्ता को वे सभी एक साथ दिखते हैं.
इसे यहां एम्बेड किए गए वीडियो में देखा जा सकता है:
इसके बिना, स्टैगर्ड लोडिंग की समस्या आ सकती है या यूज़र इंटरफ़ेस (यूआई) के अलग-अलग हिस्से एक के बाद एक लोड हो सकते हैं. साथ ही, हर हिस्से का अपना लोडिंग इंडिकेटर हो सकता है. इससे उपयोगकर्ता अनुभव खराब हो सकता है.
लोड न हो पाने की गड़बड़ियों को मैनेज करना
Suspense की मदद से, बैकग्राउंड में नेटवर्क के अनुरोध किए जाने के दौरान, कुछ समय के लिए लोडिंग की स्थिति दिखाई जा सकती है. लेकिन अगर किसी वजह से नेटवर्क के अनुरोध पूरे न हो पाएं, तो क्या होगा? ऐसा हो सकता है कि आप ऑफ़लाइन हों या आपका वेब ऐप्लिकेशन, किसी ऐसे वर्शन वाले यूआरएल को लेज़ी-लोड करने की कोशिश कर रहा हो जो पुराना हो चुका है. साथ ही, सर्वर को फिर से डिप्लॉय करने के बाद, वह यूआरएल अब उपलब्ध नहीं है.
React में, लोड होने से जुड़ी इस तरह की गड़बड़ियों को आसानी से मैनेज करने के लिए एक स्टैंडर्ड पैटर्न होता है: गड़बड़ी की सीमा का इस्तेमाल करना. दस्तावेज़ में बताए गए तरीके के मुताबिक, कोई भी React कॉम्पोनेंट, गड़बड़ी की सीमा के तौर पर काम कर सकता है. इसके लिए, उसे लाइफ़साइकल के तरीकों static getDerivedStateFromError() या componentDidCatch() में से किसी एक या दोनों को लागू करना होगा.
लेज़ी लोडिंग की गड़बड़ियों का पता लगाने और उन्हें ठीक करने के लिए, अपने Suspense कॉम्पोनेंट को पैरंट कॉम्पोनेंट के साथ रैप किया जा सकता है. यह कॉम्पोनेंट, गड़बड़ी की सीमा के तौर पर काम करता है. गड़बड़ी की सीमा के render() तरीके में, गड़बड़ी न होने पर चिल्ड्रन को पहले की तरह रेंडर किया जा सकता है. इसके अलावा, कुछ गड़बड़ी होने पर, गड़बड़ी का कस्टम मैसेज रेंडर किया जा सकता है:
import React, { lazy, Suspense } from 'react';
const AvatarComponent = lazy(() => import('./AvatarComponent'));
const InfoComponent = lazy(() => import('./InfoComponent'));
const MoreInfoComponent = lazy(() => import('./MoreInfoComponent'));
const renderLoader = () => <p>Loading</p>;
class ErrorBoundary extends React.Component {
constructor(props) {
super(props);
this.state = {hasError: false};
}
static getDerivedStateFromError(error) {
return {hasError: true};
}
render() {
if (this.state.hasError) {
return <p>Loading failed! Please reload.</p>;
}
return this.props.children;
}
}
const DetailsComponent = () => (
<ErrorBoundary>
<Suspense fallback={renderLoader()}>
<AvatarComponent />
<InfoComponent />
<MoreInfoComponent />
</Suspense>
</ErrorBoundary>
)
नतीजा
अगर आपको यह नहीं पता कि अपने React ऐप्लिकेशन में कोड स्प्लिटिंग को लागू करने की शुरुआत कहां से करनी है, तो यह तरीका अपनाएं:
- रूट लेवल से शुरू करें. रास्तों की मदद से, अपने ऐप्लिकेशन के उन हिस्सों की पहचान आसानी से की जा सकती है जिन्हें अलग किया जा सकता है. React के दस्तावेज़ में बताया गया है कि
Suspenseकोreact-routerके साथ कैसे इस्तेमाल किया जा सकता है. - अपनी साइट के किसी पेज पर मौजूद ऐसे बड़े कॉम्पोनेंट की पहचान करें जो उपयोगकर्ता के कुछ इंटरैक्शन (जैसे, किसी बटन पर क्लिक करना) पर ही रेंडर होते हैं. इन कॉम्पोनेंट को अलग-अलग करने से, JavaScript पेलोड कम हो जाएंगे.
- इसके अलावा, ऑफ़स्क्रीन और उपयोगकर्ता के लिए ज़रूरी न होने वाले अन्य कॉन्टेंट को भी छोटे-छोटे हिस्सों में बांटें.