ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆ, ಬಳಕೆದಾರರ ಅನುಭವ, ಮತ್ತು ಆರಂಭಿಕ ಲೋಡ್ ಸಮಯವನ್ನು ಗಣನೀಯವಾಗಿ ಸುಧಾರಿಸಲು ಕಾಂಪೊನೆಂಟ್ ಕೋಡ್ ಸ್ಪ್ಲಿಟ್ಟಿಂಗ್ನೊಂದಿಗೆ ರಿಯಾಕ್ಟ್ ಲೇಜಿ ಲೋಡಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಎಂದು ತಿಳಿಯಿರಿ.
ರಿಯಾಕ್ಟ್ ಲೇಜಿ ಲೋಡಿಂಗ್: ಕಾಂಪೊನೆಂಟ್ ಕೋಡ್ ಸ್ಪ್ಲಿಟ್ಟಿಂಗ್ ಮೂಲಕ ಕಾರ್ಯಕ್ಷಮತೆ ಹೆಚ್ಚಿಸುವುದು
ಇಂದಿನ ವೆಬ್ ಡೆವಲಪ್ಮೆಂಟ್ ಜಗತ್ತಿನಲ್ಲಿ, ಕಾರ್ಯಕ್ಷಮತೆ ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿದೆ. ಬಳಕೆದಾರರು ವೇಗವಾದ ಲೋಡಿಂಗ್ ಸಮಯ ಮತ್ತು ಸುಗಮ ಸಂವಹನಗಳನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತಾರೆ. ದೊಡ್ಡ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಂಡಲ್ಗಳು, ವಿಶೇಷವಾಗಿ ಸಂಕೀರ್ಣ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ, ಆರಂಭಿಕ ಲೋಡ್ ಸಮಯ ಮತ್ತು ಒಟ್ಟಾರೆ ಬಳಕೆದಾರರ ಅನುಭವದ ಮೇಲೆ ಗಮನಾರ್ಹವಾಗಿ ಪರಿಣಾಮ ಬೀರಬಹುದು. ಇದನ್ನು ಪರಿಹರಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ತಂತ್ರವೆಂದರೆ ಲೇಜಿ ಲೋಡಿಂಗ್, ನಿರ್ದಿಷ್ಟವಾಗಿ ಕಾಂಪೊನೆಂಟ್ ಕೋಡ್ ಸ್ಪ್ಲಿಟ್ಟಿಂಗ್. ಈ ಲೇಖನವು React.lazy
ಮತ್ತು Suspense
ಬಳಸಿ ರಿಯಾಕ್ಟ್ ಲೇಜಿ ಲೋಡಿಂಗ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಲೇಜಿ ಲೋಡಿಂಗ್ ಮತ್ತು ಕೋಡ್ ಸ್ಪ್ಲಿಟ್ಟಿಂಗ್ ಎಂದರೇನು?
ಲೇಜಿ ಲೋಡಿಂಗ್, ಆನ್-ಡಿಮಾಂಡ್ ಲೋಡಿಂಗ್ ಎಂದೂ ಕರೆಯಲ್ಪಡುತ್ತದೆ, ಇದು ಸಂಪನ್ಮೂಲಗಳನ್ನು (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ರಿಯಾಕ್ಟ್ ಕಾಂಪೊನೆಂಟ್ಗಳು) ಅವು ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಿರುವವರೆಗೆ ಲೋಡ್ ಮಾಡುವುದನ್ನು ಮುಂದೂಡುವ ತಂತ್ರವಾಗಿದೆ. ಅಪ್ಲಿಕೇಶನ್ನ ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ಒಟ್ಟಿಗೆ ಲೋಡ್ ಮಾಡುವ ಬದಲು, ಕೇವಲ ಅಗತ್ಯ ಭಾಗಗಳನ್ನು ಆರಂಭದಲ್ಲಿ ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ, ಮತ್ತು ಬಳಕೆದಾರರು ನಿರ್ದಿಷ್ಟ ಮಾರ್ಗಕ್ಕೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಿದಾಗ ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಕಾಂಪೊನೆಂಟ್ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಿದಾಗ ಉಳಿದ ಕೋಡ್ ಅನ್ನು ಅಸಮಕಾಲಿಕವಾಗಿ ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ. ಇದು ಆರಂಭಿಕ ಬಂಡಲ್ ಗಾತ್ರವನ್ನು ಗಣನೀಯವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಟೈಮ್ ಟು ಇಂಟರಾಕ್ಟಿವ್ (TTI) ಅನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
ಕೋಡ್ ಸ್ಪ್ಲಿಟ್ಟಿಂಗ್ ಎನ್ನುವುದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ನ ಕೋಡ್ ಅನ್ನು ಸಣ್ಣ, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾದ ತುಣುಕುಗಳಾಗಿ (ಬಂಡಲ್ಗಳು) ವಿಭಜಿಸುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. ಈ ಬಂಡಲ್ಗಳನ್ನು ನಂತರ ಸ್ವತಂತ್ರವಾಗಿ ಮತ್ತು ಬೇಡಿಕೆಯ ಮೇರೆಗೆ ಲೋಡ್ ಮಾಡಬಹುದು. ರಿಯಾಕ್ಟ್ ಲೇಜಿ ಲೋಡಿಂಗ್ ಕಾಂಪೊನೆಂಟ್ಗಳನ್ನು ಅಗತ್ಯವಿದ್ದಾಗ ಮಾತ್ರ ಲೋಡ್ ಮಾಡಲು ಕೋಡ್ ಸ್ಪ್ಲಿಟ್ಟಿಂಗ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ.
ಲೇಜಿ ಲೋಡಿಂಗ್ ಮತ್ತು ಕೋಡ್ ಸ್ಪ್ಲಿಟ್ಟಿಂಗ್ನ ಪ್ರಯೋಜನಗಳು
- ಸುಧಾರಿತ ಆರಂಭಿಕ ಲೋಡ್ ಸಮಯ: ಆರಂಭಿಕ ಬಂಡಲ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ, ಬ್ರೌಸರ್ ಕಡಿಮೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ, ಇದರಿಂದಾಗಿ ಪುಟ ಲೋಡ್ ಸಮಯ ವೇಗವಾಗಿರುತ್ತದೆ. ನಿಧಾನವಾದ ನೆಟ್ವರ್ಕ್ ಸಂಪರ್ಕಗಳು ಅಥವಾ ಸಾಧನಗಳಲ್ಲಿರುವ ಬಳಕೆದಾರರಿಗೆ ಇದು ವಿಶೇಷವಾಗಿ ನಿರ್ಣಾಯಕವಾಗಿದೆ.
- ಉತ್ತಮ ಬಳಕೆದಾರರ ಅನುಭವ: ವೇಗದ ಲೋಡಿಂಗ್ ಸಮಯಗಳು ಹೆಚ್ಚು ಸ್ಪಂದಿಸುವ ಮತ್ತು ಆನಂದದಾಯಕ ಬಳಕೆದಾರರ ಅನುಭವಕ್ಕೆ ಕಾರಣವಾಗುತ್ತವೆ, ಬೌನ್ಸ್ ದರಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತವೆ ಮತ್ತು ಬಳಕೆದಾರರ ತೊಡಗಿಸಿಕೊಳ್ಳುವಿಕೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತವೆ.
- ಕಡಿಮೆ ಸಂಪನ್ಮೂಲ ಬಳಕೆ: ಕೇವಲ ಅಗತ್ಯವಿರುವ ಕೋಡ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವುದರಿಂದ ಅಪ್ಲಿಕೇಶನ್ನ ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ಇದು ವಿಶೇಷವಾಗಿ ಮೊಬೈಲ್ ಸಾಧನಗಳಿಗೆ ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ.
- ಉತ್ತಮ ಎಸ್ಇಒ: ಸರ್ಚ್ ಇಂಜಿನ್ಗಳು ವೇಗದ ಲೋಡಿಂಗ್ ಸಮಯವನ್ನು ಹೊಂದಿರುವ ವೆಬ್ಸೈಟ್ಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡುತ್ತವೆ, ಇದು ನಿಮ್ಮ ವೆಬ್ಸೈಟ್ನ ಸರ್ಚ್ ಇಂಜಿನ್ ಶ್ರೇಯಾಂಕವನ್ನು ಸುಧಾರಿಸಬಹುದು.
React.lazy
ಮತ್ತು Suspense
ನೊಂದಿಗೆ ರಿಯಾಕ್ಟ್ ಲೇಜಿ ಲೋಡಿಂಗ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು
ರಿಯಾಕ್ಟ್ React.lazy
ಮತ್ತು Suspense
ಬಳಸಿ ಕಾಂಪೊನೆಂಟ್ಗಳನ್ನು ಲೇಜಿ ಲೋಡ್ ಮಾಡಲು ಅಂತರ್ನಿರ್ಮಿತ ಯಾಂತ್ರಿಕತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. React.lazy
ನಿಮಗೆ ಡೈನಾಮಿಕ್ ಆಗಿ ಕಾಂಪೊನೆಂಟ್ ಅನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ Suspense
ಕಾಂಪೊನೆಂಟ್ ಲೋಡ್ ಆಗುತ್ತಿರುವಾಗ ಫಾಲ್ಬ್ಯಾಕ್ UI ಅನ್ನು ಪ್ರದರ್ಶಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಹಂತ 1: React.lazy
ಜೊತೆಗೆ ಡೈನಾಮಿಕ್ ಇಂಪೋರ್ಟ್ಸ್
React.lazy
import()
ಅನ್ನು ಕರೆಯುವ ಫಂಕ್ಷನ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. import()
ಫಂಕ್ಷನ್ ಒಂದು ಡೈನಾಮಿಕ್ ಇಂಪೋರ್ಟ್ ಆಗಿದ್ದು, ಅದು ಒಂದು ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದು ನೀವು ಲೇಜಿ ಲೋಡ್ ಮಾಡಲು ಬಯಸುವ ಕಾಂಪೊನೆಂಟ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಮಾಡ್ಯೂಲ್ಗೆ ಪರಿಹಾರವಾಗುತ್ತದೆ.
import React, { lazy, Suspense } from 'react';
const MyComponent = lazy(() => import('./MyComponent'));
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, MyComponent
ಅನ್ನು ರೆಂಡರ್ ಮಾಡುವವರೆಗೂ ಲೋಡ್ ಮಾಡಲಾಗುವುದಿಲ್ಲ. import('./MyComponent')
ಹೇಳಿಕೆಯು ./MyComponent
ಫೈಲ್ನಿಂದ ಕಾಂಪೊನೆಂಟ್ ಅನ್ನು ಡೈನಾಮಿಕ್ ಆಗಿ ಇಂಪೋರ್ಟ್ ಮಾಡುತ್ತದೆ. ಪಾತ್ ಪ್ರಸ್ತುತ ಫೈಲ್ಗೆ ಸಂಬಂಧಿಸಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
ಹಂತ 2: ಲೋಡಿಂಗ್ ಸ್ಥಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು Suspense
ಬಳಸುವುದು
ಲೇಜಿ ಲೋಡಿಂಗ್ ಕಾಂಪೊನೆಂಟ್ಗಳ ಅಸಮಕಾಲಿಕ ಲೋಡಿಂಗ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವುದರಿಂದ, ಲೋಡಿಂಗ್ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಕಾಂಪೊನೆಂಟ್ ಅನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತಿರುವಾಗ ಫಾಲ್ಬ್ಯಾಕ್ UI ಅನ್ನು ಪ್ರದರ್ಶಿಸಲು ನಿಮಗೆ ಒಂದು ಮಾರ್ಗ ಬೇಕು. ಇಲ್ಲಿಯೇ Suspense
ಬರುತ್ತದೆ. Suspense
ಎನ್ನುವುದು ಒಂದು ರಿಯಾಕ್ಟ್ ಕಾಂಪೊನೆಂಟ್ ಆಗಿದ್ದು, ಅದು ಸಿದ್ಧವಾಗುವವರೆಗೆ ಅದರ ಮಕ್ಕಳ ರೆಂಡರಿಂಗ್ ಅನ್ನು "ಸಸ್ಪೆಂಡ್" ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು fallback
ಪ್ರಾಪ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಇದು ಮಕ್ಕಳು ಲೋಡ್ ಆಗುತ್ತಿರುವಾಗ ರೆಂಡರ್ ಮಾಡಬೇಕಾದ UI ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
import React, { lazy, Suspense } from 'react';
const MyComponent = lazy(() => import('./MyComponent'));
function App() {
return (
ಲೋಡ್ ಆಗುತ್ತಿದೆ...
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, Suspense
ಕಾಂಪೊನೆಂಟ್ MyComponent
ಅನ್ನು ಸುತ್ತುವರಿಯುತ್ತದೆ. MyComponent
ಲೋಡ್ ಆಗುತ್ತಿರುವಾಗ, fallback
ಪ್ರಾಪ್ (
) ರೆಂಡರ್ ಆಗುತ್ತದೆ. ಒಮ್ಮೆ MyComponent
ಲೋಡ್ ಆದ ನಂತರ, ಅದು ಫಾಲ್ಬ್ಯಾಕ್ UI ಅನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ: ರಿಯಾಕ್ಟ್ ರೂಟರ್ ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿ ರೂಟ್ ಅನ್ನು ಲೇಜಿ ಲೋಡ್ ಮಾಡುವುದು
ರಿಯಾಕ್ಟ್ ರೂಟರ್ ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿನ ರೂಟ್ಗಳಿಗೆ ಲೇಜಿ ಲೋಡಿಂಗ್ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ನೀವು ಸಂಪೂರ್ಣ ಪುಟಗಳನ್ನು ಅಥವಾ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ನ ವಿಭಾಗಗಳನ್ನು ಲೇಜಿ ಲೋಡ್ ಮಾಡಬಹುದು, ನಿಮ್ಮ ವೆಬ್ಸೈಟ್ನ ಆರಂಭಿಕ ಲೋಡ್ ಸಮಯವನ್ನು ಸುಧಾರಿಸಬಹುದು.
import React, { lazy, Suspense } from 'react';
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
const Home = lazy(() => import('./pages/Home'));
const About = lazy(() => import('./pages/About'));
const Contact = lazy(() => import('./pages/Contact'));
function App() {
return (
ಲೋಡ್ ಆಗುತ್ತಿದೆ...