ஜாவாஸ்கிரிப்ட் கோட் ஸ்பிளிட்டிங்கிற்கான எங்கள் விரிவான வழிகாட்டி மூலம் வேகமான வலைப் பயன்பாடுகளைத் திறக்கவும். நவீன பிரேம்வொர்க்குகளுக்கான டைனமிக் லோடிங், ரூட்-அடிப்படையிலான ஸ்பிளிட்டிங் மற்றும் செயல்திறன் மேம்படுத்தல் நுட்பங்களைக் கற்றுக்கொள்ளுங்கள்.
ஜாவாஸ்கிரிப்ட் கோட் ஸ்பிளிட்டிங்: டைனமிக் லோடிங் மற்றும் செயல்திறன் மேம்பாட்டில் ஒரு ஆழ்ந்த பார்வை
நவீன டிஜிட்டல் உலகில், உங்கள் வலைப் பயன்பாட்டைப் பற்றிய ஒரு பயனரின் முதல் அபிப்ராயம் பெரும்பாலும் ஒரே ஒரு அளவீட்டால் வரையறுக்கப்படுகிறது: வேகம். ஒரு மெதுவான, மந்தமான வலைத்தளம் பயனர் விரக்தி, அதிக பவுன்ஸ் விகிதங்கள் மற்றும் வணிக இலக்குகளில் நேரடி எதிர்மறையான தாக்கத்திற்கு வழிவகுக்கும். மெதுவான வலைப் பயன்பாடுகளுக்குப் பின்னால் உள்ள மிக முக்கியமான குற்றவாளிகளில் ஒன்று மோனோலிதிக் ஜாவாஸ்கிரிப்ட் பண்டில் ஆகும் - இது உங்கள் முழு தளத்திற்கான அனைத்து குறியீட்டையும் கொண்ட ஒரு பெரிய கோப்பாகும், பயனர் பக்கத்துடன் தொடர்புகொள்வதற்கு முன்பு இதைப் பதிவிறக்கம் செய்து, பார்ஸ் செய்து, இயக்க வேண்டும்.
இங்குதான் ஜாவாஸ்கிரிப்ட் கோட் ஸ்பிளிட்டிங் வருகிறது. இது ஒரு நுட்பம் மட்டுமல்ல; இது நாம் வலைப் பயன்பாடுகளை எவ்வாறு உருவாக்குகிறோம் மற்றும் வழங்குகிறோம் என்பதில் ஒரு fondamentale கட்டமைப்பு மாற்றமாகும். அந்த பெரிய பண்டிலை சிறிய, தேவைக்கேற்ப துண்டுகளாக உடைப்பதன் மூலம், ஆரம்ப சுமை நேரங்களை வியத்தகு முறையில் மேம்படுத்தலாம் மற்றும் மிகவும் மென்மையான பயனர் அனுபவத்தை உருவாக்கலாம். இந்த வழிகாட்டி உங்களை கோட் ஸ்பிளிட்டிங் உலகில் ஒரு ஆழ்ந்த பயணத்திற்கு அழைத்துச் செல்லும், அதன் முக்கிய கருத்துக்கள், நடைமுறை உத்திகள் மற்றும் செயல்திறனில் அதன் ஆழமான தாக்கத்தை ஆராயும்.
கோட் ஸ்பிளிட்டிங் என்றால் என்ன, நீங்கள் ஏன் அதைப் பற்றி கவலைப்பட வேண்டும்?
அதன் மையத்தில், கோட் ஸ்பிளிட்டிங் என்பது உங்கள் பயன்பாட்டின் ஜாவாஸ்கிரிப்ட் குறியீட்டை பல சிறிய கோப்புகளாகப் பிரிக்கும் நடைமுறையாகும், இவை பெரும்பாலும் "துண்டுகள்" (chunks) என்று அழைக்கப்படுகின்றன, இவற்றை டைனமிக்காக அல்லது இணையாக ஏற்றலாம். ஒரு பயனர் உங்கள் முகப்புப் பக்கத்தில் முதலில் வரும்போது அவர்களுக்கு 2MB ஜாவாஸ்கிரிப்ட் கோப்பை அனுப்புவதற்குப் பதிலாக, அந்தப் பக்கத்தை ரெண்டர் செய்யத் தேவையான 200KB-ஐ மட்டுமே நீங்கள் அனுப்பலாம். மீதமுள்ள குறியீடு—பயனர் சுயவிவரப் பக்கம், நிர்வாகி டாஷ்போர்டு அல்லது ஒரு சிக்கலான தரவுக் காட்சிப்படுத்தல் கருவி போன்ற அம்சங்களுக்கானது—பயனர் உண்மையில் அந்த அம்சங்களுக்குச் செல்லும்போது அல்லது அவற்றுடன் தொடர்பு கொள்ளும்போது மட்டுமே பெறப்படும்.
இதை ஒரு உணவகத்தில் ஆர்டர் செய்வது போல நினைத்துப் பாருங்கள். ஒரு மோனோலிதிக் பண்டில் என்பது, நீங்கள் விரும்பினாலும் விரும்பாவிட்டாலும், முழு பல-வகை மெனுவும் ஒரே நேரத்தில் பரிமாறப்படுவது போன்றது. கோட் ஸ்பிளிட்டிங் என்பது à la carte அனுபவம் போன்றது: உங்களுக்குத் தேவையானதை, உங்களுக்குத் தேவைப்படும்போது துல்லியமாகப் பெறுவீர்கள்.
மோனோலிதிக் பண்டில்களுடன் உள்ள சிக்கல்
தீர்வைப் முழுமையாகப் பாராட்ட, நாம் முதலில் சிக்கலைப் புரிந்து கொள்ள வேண்டும். ஒரு பெரிய, ஒற்றை பண்டில் செயல்திறனை பல வழிகளில் எதிர்மறையாக பாதிக்கிறது:
- அதிகரித்த நெட்வொர்க் தாமதம்: பெரிய கோப்புகள் பதிவிறக்கம் செய்ய அதிக நேரம் எடுக்கும், குறிப்பாக உலகின் பல பகுதிகளில் பரவலாக உள்ள மெதுவான மொபைல் நெட்வொர்க்குகளில். இந்த ஆரம்ப காத்திருப்பு நேரம் பெரும்பாலும் முதல் தடையாக இருக்கிறது.
- நீண்ட பார்ஸ் & கம்பைல் நேரங்கள்: பதிவிறக்கம் செய்யப்பட்டவுடன், உலாவியின் ஜாவாஸ்கிரிப்ட் இயந்திரம் முழு கோட்பேஸையும் பார்ஸ் செய்து கம்பைல் செய்ய வேண்டும். இது ஒரு CPU-தீவிரமான பணியாகும், இது மெயின் த்ரெட்டைத் தடுக்கிறது, அதாவது பயனர் இடைமுகம் உறைந்து மற்றும் பதிலளிக்காமல் இருக்கும்.
- தடுக்கப்பட்ட ரெண்டரிங்: மெயின் த்ரெட் ஜாவாஸ்கிரிப்டில் மும்முரமாக இருக்கும்போது, பக்கத்தை ரெண்டரிங் செய்வது அல்லது பயனர் உள்ளீட்டிற்கு பதிலளிப்பது போன்ற பிற முக்கியமான பணிகளைச் செய்ய முடியாது. இது நேரடியாக ஒரு மோசமான Time to Interactive (TTI)-க்கு வழிவகுக்கிறது.
- வீணடிக்கப்பட்ட வளங்கள்: ஒரு மோனோலிதிக் பண்டிலில் உள்ள குறியீட்டின் ஒரு குறிப்பிடத்தக்க பகுதி ஒரு பொதுவான பயனர் அமர்வின் போது ஒருபோதும் பயன்படுத்தப்படாமல் போகலாம். இதன் பொருள், பயனர் தங்களுக்கு எந்த மதிப்பையும் வழங்காத குறியீட்டைப் பதிவிறக்கம் செய்து தயாரிக்க டேட்டா, பேட்டரி மற்றும் செயலாக்க சக்தியை வீணாக்குகிறார்.
- மோசமான கோர் வெப் வைட்டல்ஸ்: இந்த செயல்திறன் சிக்கல்கள் உங்கள் கோர் வெப் வைட்டல்ஸ் மதிப்பெண்களை நேரடியாகப் பாதிக்கின்றன, இது உங்கள் தேடுபொறி தரவரிசையைப் பாதிக்கலாம். ஒரு தடுக்கப்பட்ட மெயின் த்ரெட் First Input Delay (FID) மற்றும் Interaction to Next Paint (INP) ஆகியவற்றை மோசமாக்குகிறது, அதே நேரத்தில் தாமதமான ரெண்டரிங் Largest Contentful Paint (LCP)-ஐ பாதிக்கிறது.
நவீன கோட் ஸ்பிளிட்டிங்கின் மையம்: டைனமிக் `import()`
பெரும்பாலான நவீன கோட் ஸ்பிளிட்டிங் உத்திகளுக்குப் பின்னால் உள்ள மேஜிக் ஒரு நிலையான ஜாவாஸ்கிரிப்ட் அம்சமாகும்: டைனமிக் `import()` வெளிப்பாடு. நிலையான `import` அறிக்கையைப் போலல்லாமல், இது பில்ட் நேரத்தில் செயலாக்கப்பட்டு மாட்யூல்களை ஒன்றாக இணைக்கிறது, டைனமிக் `import()` என்பது ஒரு செயல்பாட்டைப் போன்ற வெளிப்பாடாகும், இது தேவைக்கேற்ப ஒரு மாட்யூலை ஏற்றுகிறது.
இது எவ்வாறு செயல்படுகிறது என்பது இங்கே:
import('/path/to/module.js')
Webpack, Vite, அல்லது Rollup போன்ற ஒரு பண்ட்லர் இந்த தொடரியலைக் காணும்போது, `'./path/to/module.js'` மற்றும் அதன் சார்புகள் ஒரு தனி துண்டில் வைக்கப்பட வேண்டும் என்பதை அது புரிந்துகொள்கிறது. `import()` அழைப்பு ஒரு Promise-ஐ வழங்குகிறது, இது நெட்வொர்க்கில் வெற்றிகரமாக ஏற்றப்பட்டவுடன் மாட்யூலின் உள்ளடக்கங்களுடன் தீர்க்கப்படும்.
ஒரு பொதுவான செயலாக்கம் இதுபோல் தெரிகிறது:
// id="load-feature" உடன் ஒரு பட்டன் இருப்பதாகக் ধরেக்கொள்வோம்
const featureButton = document.getElementById('load-feature');
featureButton.addEventListener('click', () => {
import('./heavy-feature.js')
.then(module => {
// மாட்யூல் வெற்றிகரமாக ஏற்றப்பட்டது
const feature = module.default;
feature.initialize(); // ஏற்றப்பட்ட மாட்யூலில் இருந்து ஒரு செயல்பாட்டை இயக்கவும்
})
.catch(err => {
// ஏற்றும்போது ஏற்படும் பிழைகளைக் கையாளவும்
console.error('Failed to load the feature:', err);
});
});
இந்த எடுத்துக்காட்டில், `heavy-feature.js` ஆரம்ப பக்க ஏற்றத்தில் சேர்க்கப்படவில்லை. பயனர் பட்டனைக் கிளிக் செய்யும் போது மட்டுமே அது சேவையகத்திலிருந்து கோரப்படுகிறது. இது டைனமிக் லோடிங்கின் அடிப்படைக் கொள்கையாகும்.
நடைமுறை கோட் ஸ்பிளிட்டிங் உத்திகள்
"எப்படி" என்பதை அறிவது ஒரு விஷயம்; "எங்கே" மற்றும் "எப்போது" என்பதை அறிவதுதான் கோட் ஸ்பிளிட்டிங்கை உண்மையிலேயே பயனுள்ளதாக்குகிறது. நவீன வலை மேம்பாட்டில் பயன்படுத்தப்படும் மிகவும் பொதுவான மற்றும் சக்திவாய்ந்த உத்திகள் இங்கே உள்ளன.
1. ரூட்-அடிப்படையிலான ஸ்பிளிட்டிங்
இது மிகவும் தாக்கத்தை ஏற்படுத்தக்கூடிய மற்றும் பரவலாகப் பயன்படுத்தப்படும் உத்தியாகும். யோசனை எளிமையானது: உங்கள் பயன்பாட்டில் உள்ள ஒவ்வொரு பக்கத்திற்கும் அல்லது ரூட்டிற்கும் அதன் சொந்த ஜாவாஸ்கிரிப்ட் துண்டு கிடைக்கிறது. ஒரு பயனர் `/home`-க்குச் செல்லும்போது, அவர்கள் முகப்புப் பக்கத்திற்கான குறியீட்டை மட்டுமே ஏற்றுகிறார்கள். அவர்கள் `/dashboard`-க்குச் சென்றால், டாஷ்போர்டுக்கான ஜாவாஸ்கிரிப்ட் டைனமிக்காகப் பெறப்படும்.
இந்த அணுகுமுறை பயனர் நடத்தைக்கு hoàn hảoமாகப் பொருந்துகிறது மற்றும் பல-பக்கப் பயன்பாடுகளுக்கு (Single Page Applications, அல்லது SPAs உட்பட) நம்பமுடியாத அளவிற்கு பயனுள்ளதாக இருக்கும். பெரும்பாலான நவீன பிரேம்வொர்க்குகள் இதற்கு உள்ளமைக்கப்பட்ட ஆதரவைக் கொண்டுள்ளன.
ரியாக்ட் உடன் எடுத்துக்காட்டு (`React.lazy` மற்றும் `Suspense`)
ரியாக்ட், காம்பொனென்ட்களை டைனமிக்காக இறக்குமதி செய்ய `React.lazy`-ஐயும், காம்பொனென்ட்டின் குறியீடு ஏற்றப்படும்போது ஒரு ஃபால்பேக் UI-ஐ (ஒரு லோடிங் ஸ்பின்னர் போன்றவை) காட்ட `Suspense`-ஐயும் பயன்படுத்தி ரூட்-அடிப்படையிலான ஸ்பிளிட்டிங்கை தடையின்றி செய்கிறது.
import React, { Suspense, lazy } from 'react';
import { BrowserRouter as Router, Routes, Route } from 'react-router-dom';
// பொதுவான/ஆரம்ப ரூட்களுக்கான காம்பொனென்ட்களை நிலையானதாக இறக்குமதி செய்யவும்
import HomePage from './pages/HomePage';
// குறைவாகப் பயன்படுத்தப்படும் அல்லது கனமான ரூட்களுக்கான காம்பொனென்ட்களை டைனமிக்காக இறக்குமதி செய்யவும்
const DashboardPage = lazy(() => import('./pages/DashboardPage'));
const AdminPanel = lazy(() => import('./pages/AdminPanel'));
function App() {
return (
Loading page...
Vue உடன் எடுத்துக்காட்டு (Async Components)
Vue-ன் ரவுட்டர், ரூட் வரையறையில் நேரடியாக டைனமிக் `import()` தொடரியலைப் பயன்படுத்தி லேசி லோடிங் காம்பொனென்ட்களுக்கு முதல்-தர ஆதரவைக் கொண்டுள்ளது.
import { createRouter, createWebHistory } from 'vue-router';
import Home from '../views/Home.vue';
const routes = [
{
path: '/',
name: 'Home',
component: Home // ஆரம்பத்தில் ஏற்றப்பட்டது
},
{
path: '/about',
name: 'About',
// ரூட்-நிலை கோட்-ஸ்பிளிட்டிங்
// இது இந்த ரூட்டிற்கு ஒரு தனி துண்டை உருவாக்குகிறது
component: () => import(/* webpackChunkName: "about" */ '../views/About.vue')
}
];
const router = createRouter({
history: createWebHistory(),
routes
});
export default router;
2. காம்பொனென்ட்-அடிப்படையிலான ஸ்பிளிட்டிங்
சில நேரங்களில், ஒரே பக்கத்திற்குள்ளும், உடனடியாகத் தேவையில்லாத பெரிய காம்பொனென்ட்கள் இருக்கலாம். இவை காம்பொனென்ட்-அடிப்படையிலான ஸ்பிளிட்டிங்கிற்கு சரியான தேர்வாளர்கள். எடுத்துக்காட்டுகள் பின்வருமாறு:
- ஒரு பயனர் ஒரு பட்டனைக் கிளிக் செய்த பிறகு தோன்றும் மோடல்கள் அல்லது டயலாக்குகள்.
- மடக்குக்கு கீழே உள்ள சிக்கலான வரைபடங்கள் அல்லது தரவுக் காட்சிப்படுத்தல்கள்.
- ஒரு பயனர் "edit" என்பதைக் கிளிக் செய்யும்போது மட்டுமே தோன்றும் ஒரு ரிச் டெக்ஸ்ட் எடிட்டர்.
- பயனர் ப்ளே ஐகானைக் கிளிக் செய்யும் வரை ஏற்றத் தேவையில்லாத ஒரு வீடியோ பிளேயர் நூலகம்.
செயலாக்கம் ரூட்-அடிப்படையிலான ஸ்பிளிட்டிங்கைப் போன்றது, ஆனால் ஒரு ரூட் மாற்றத்திற்குப் பதிலாக பயனர் தொடர்புகளால் தூண்டப்படுகிறது.
எடுத்துக்காட்டு: ஒரு மோடலை கிளிக் செய்யும்போது ஏற்றுதல்
import React, { useState, Suspense, lazy } from 'react';
// மோடல் காம்பொனென்ட் அதன் சொந்த கோப்பில் வரையறுக்கப்பட்டுள்ளது மற்றும் ஒரு தனி துண்டில் இருக்கும்
const HeavyModal = lazy(() => import('./components/HeavyModal'));
function MyPage() {
const [isModalOpen, setIsModalOpen] = useState(false);
const openModal = () => {
setIsModalOpen(true);
};
return (
Welcome to the Page
{isModalOpen && (
Loading modal... }>
setIsModalOpen(false)} />
)}