React பண்டில் பிரித்தல்: செயல்திறனுக்கான உத்திசார்ந்த குறியீடு அமைப்பு

இன்றைய வலைத்தள மேம்பாட்டுச் சூழலில், செயல்திறன் மிகவும் முக்கியமானது. பயனர்கள் வேகமான, பதிலளிக்கக்கூடிய செயலிகளை எதிர்பார்க்கிறார்கள், மேலும் சிறிய தாமதங்கள் கூட விரக்திக்கும், கைவிடுதலுக்கும் வழிவகுக்கும். React செயலிகளுக்கு, பண்டில் பிரித்தல் என்பது ஆரம்ப ஏற்றுதல் நேரங்களைக் குறைப்பதன் மூலமும், ஒட்டுமொத்த பயனர் அனுபவத்தை மேம்படுத்துவதன் மூலமும் செயல்திறனை மேம்படுத்துவதற்கான ஒரு முக்கியமான நுட்பமாகும்.

பண்டில் பிரித்தல் என்றால் என்ன?

பண்டில் பிரித்தல், குறியீடு பிரித்தல் என்றும் அழைக்கப்படுகிறது, இது உங்கள் செயலியின் ஜாவாஸ்கிரிப்ட் குறியீட்டை சிறிய துண்டுகளாக அல்லது பண்டில்களாகப் பிரிக்கும் செயல்முறையாகும். உங்கள் செயலியின் அனைத்துக் குறியீட்டையும் கொண்ட ஒரு பெரிய பண்டிலைப் பதிவிறக்குவதற்குப் பதிலாக, உலாவி ஆரம்பப் பக்க ஏற்றுதலுக்குத் தேவையான குறியீட்டை மட்டுமே பதிவிறக்குகிறது. பயனர் செயலி வழியாக செல்லும்போது, கூடுதல் பண்டில்கள் தேவைக்கேற்ப ஏற்றப்படுகின்றன. இந்த அணுகுமுறை பல குறிப்பிடத்தக்க நன்மைகளை வழங்குகிறது:

• வேகமான ஆரம்ப ஏற்றுதல் நேரங்கள்: ஆரம்பத்தில் பதிவிறக்கம் செய்யப்பட்டு பாகுபடுத்தப்பட வேண்டிய குறியீட்டின் அளவைக் குறைப்பதன் மூலம், பண்டில் பிரித்தல் பயனர் செயலியைக் கண்டு அதனுடன் தொடர்புகொள்வதற்கு எடுக்கும் நேரத்தை கணிசமாக மேம்படுத்துகிறது.
• மேம்பட்ட பயனர் அனுபவம்: வேகமான ஏற்றுதல் நேரங்கள் நேரடியாக ஒரு மென்மையான, அதிக பதிலளிக்கக்கூடிய பயனர் அனுபவத்திற்கு வழிவகுக்கிறது. பயனர்கள் தாமதங்கள் அல்லது முடங்குதல்களை அனுபவிப்பது குறைவு, இது அதிக ஈடுபாடு மற்றும் திருப்திக்கு வழிவகுக்கிறது.
• திறமையான குறியீடு மேலாண்மை: பண்டில் பிரித்தல் மாடுலாரிட்டி மற்றும் குறியீடு அமைப்பை ஊக்குவிக்கிறது, இது உங்கள் செயலியைப் பராமரிப்பதையும் புதுப்பிப்பதையும் எளிதாக்குகிறது.
• குறைக்கப்பட்ட நெட்வொர்க் நெரிசல்: சிறிய பண்டில்களைப் பதிவிறக்குவது நெட்வொர்க் நெரிசலைக் குறைக்கும், குறிப்பாக மெதுவான இணைய இணைப்புகளைக் கொண்ட பயனர்களுக்கு.

React செயலிகளுக்கு பண்டில் பிரித்தல் ஏன் முக்கியமானது?

React செயலிகள், குறிப்பாக பெரிய மற்றும் சிக்கலானவை, விரைவாக அளவில் வளரக்கூடும். குறியீட்டுத் தளம் அதிகரிக்கும்போது, ஒற்றை ஜாவாஸ்கிரிப்ட் பண்டில் மிகவும் பெரியதாகி, மெதுவான ஆரம்ப ஏற்றுதல் நேரங்களுக்கு வழிவகுக்கும். இது மொபைல் சாதனங்கள் அல்லது வரையறுக்கப்பட்ட அலைவரிசை கொண்ட பயனர்களுக்கு குறிப்பாக சிக்கலானது. பண்டில் பிரித்தல் இந்த சிக்கலைத் தீர்க்கிறது, தேவைப்படும்போது தேவையான குறியீட்டை மட்டும் ஏற்றுவதற்கு உங்களை அனுமதிக்கிறது.

ஒரு பெரிய இ-காமர்ஸ் செயலியை கருத்தில் கொள்ளுங்கள். தயாரிப்புப் பட்டியல் பக்கத்திற்கான குறியீடு, செக்அவுட் செயல்முறைக்கான குறியீட்டிலிருந்து வேறுபட்டதாக இருக்கலாம். பண்டில் பிரித்தல் மூலம், செயலியின் இந்த வெவ்வேறு பகுதிகளை தனித்தனி பண்டில்களாக ஏற்றலாம், இது பயனர் எந்த நேரத்திலும் தங்களுக்குத் தேவையான குறியீட்டை மட்டுமே பதிவிறக்குவதை உறுதி செய்கிறது.

React-இல் பண்டில் பிரித்தலை எவ்வாறு செயல்படுத்துவது

React-இல் பண்டில் பிரித்தலைச் செயல்படுத்த பல வழிகள் உள்ளன, அவற்றுள்:

1. டைனமிக் இறக்குமதிகளைப் பயன்படுத்துதல்

டைனமிக் இறக்குமதிகள் React செயலிகளில் பண்டில் பிரித்தலுக்கான பரிந்துரைக்கப்பட்ட அணுகுமுறையாகும். அவை மாட்யூல்களை ஒத்திசைவின்றி இறக்குமதி செய்ய உங்களை அனுமதிக்கின்றன, ஒவ்வொரு இறக்குமதி செய்யப்பட்ட மாட்யூலுக்கும் தனித்தனி பண்டில்களை உருவாக்குகின்றன. டைனமிக் இறக்குமதிகள் நவீன உலாவிகள் மற்றும் வெப்பேக் போன்ற பண்டலர்களால் இயல்பாகவே ஆதரிக்கப்படுகின்றன.

உதாரணம்:

import React, { useState, useEffect } from 'react';

function MyComponent() {
  const [module, setModule] = useState(null);

  useEffect(() => {
    import('./my-module') // இது my-module.js-க்கு ஒரு தனி பண்டிலை உருவாக்குகிறது
      .then((loadedModule) => {
        setModule(loadedModule.default);
      })
      .catch((error) => {
        console.error('Error loading module:', error);
      });
  }, []);

  if (!module) {
    return 
ஏற்றுகிறது...
;
  }

  return ; // இறக்குமதி செய்யப்பட்ட மாட்யூலை ரெண்டர் செய்யவும்
}

export default MyComponent;

இந்த எடுத்துக்காட்டில், `my-module.js` கோப்பு காம்போனென்ட் மவுண்ட் செய்யப்படும்போது ஒரு தனி பண்டிலாக ஏற்றப்படும். `useEffect` ஹூக் மாட்யூலை ஒத்திசைவின்றி ஏற்றுவதற்குப் பயன்படுத்தப்படுகிறது. மாட்யூல் ஏற்றப்படும்போது, "ஏற்றுகிறது..." செய்தி காட்டப்படும். மாட்யூல் ஏற்றப்பட்டவுடன், அது ரெண்டர் செய்யப்படும்.

2. React.lazy மற்றும் Suspense

React.lazy மற்றும் Suspense ஆகியவை React காம்போனென்ட்களில் குறியீடு பிரித்தல் மற்றும் சோம்பேறி ஏற்றுதலைக் கையாள ஒரு விளக்கமான வழியை வழங்குகின்றன. `React.lazy` உங்களை ஒத்திசைவின்றி ஏற்றப்படும் ஒரு காம்போனென்ட்டை வரையறுக்க அனுமதிக்கிறது, அதே நேரத்தில் `Suspense` காம்போனென்ட் ஏற்றப்படும்போது ஒரு பின்னடைவு UI-ஐக் காட்ட உங்களை அனுமதிக்கிறது.

உதாரணம்:

import React, { Suspense } from 'react';

const MyComponent = React.lazy(() => import('./MyComponent')); // இது ஒரு தனி பண்டிலை உருவாக்குகிறது

function App() {
  return (
    ஏற்றுகிறது...
}>
      
    
  );
}

export default App;

இந்த எடுத்துக்காட்டில், `MyComponent` காம்போனென்ட் ஒரு தனி பண்டிலாக ஏற்றப்படும். `Suspense` காம்போனென்ட், காம்போனென்ட் ஏற்றப்படும்போது "ஏற்றுகிறது..." செய்தியைக் காட்டுகிறது. காம்போனென்ட் ஏற்றப்பட்டவுடன், அது ரெண்டர் செய்யப்படும்.

3. ரூட்-அடிப்படையிலான குறியீடு பிரித்தல்

ரூட்-அடிப்படையிலான குறியீடு பிரித்தல் என்பது பயனர் செல்லும் ரூட்களின் அடிப்படையில் உங்கள் செயலியை வெவ்வேறு பண்டில்களாகப் பிரிப்பதாகும். இது ஆரம்ப ஏற்றுதல் நேரங்களை மேம்படுத்துவதற்கான ஒரு பொதுவான மற்றும் பயனுள்ள உத்தி, குறிப்பாக ஒற்றைப் பக்க செயலிகளில் (SPAs).

ரூட்-அடிப்படையிலான குறியீடு பிரித்தலைச் செயல்படுத்த, உங்கள் ரூட்டிங் லைப்ரரியுடன் (எ.கா., React Router) இணைந்து டைனமிக் இறக்குமதிகள் அல்லது React.lazy மற்றும் Suspense-ஐப் பயன்படுத்தலாம்.

React Router மற்றும் React.lazy-ஐப் பயன்படுத்தும் உதாரணம்:

import React, { Suspense } from 'react';
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';

const Home = React.lazy(() => import('./pages/Home'));
const About = React.lazy(() => import('./pages/About'));
const Products = React.lazy(() => import('./pages/Products'));

function App() {
  return (
    
      ஏற்றுகிறது...
}>
        
          
            
          
          
            
          
          
            
          
        
      
    
  );
}

export default App;

இந்த எடுத்துக்காட்டில், ஒவ்வொரு ரூட்டும் (`/`, `/about`, `/products`) `React.lazy`-ஐப் பயன்படுத்தி ஒத்திசைவின்றி ஏற்றப்படும் ஒரு தனி காம்போனென்ட்டுடன் தொடர்புடையது. பயனர் ஒரு குறிப்பிட்ட ரூட்டிற்குச் செல்லும்போது, அதனுடன் தொடர்புடைய காம்போனென்ட் மற்றும் அதன் சார்புகள் தேவைக்கேற்ப ஏற்றப்படுகின்றன.

பண்டில் பிரித்தலுக்கான Webpack உள்ளமைவு

Webpack என்பது ஒரு பிரபலமான மாட்யூல் பண்டலராகும், இது பண்டில் பிரித்தலுக்கு சிறந்த ஆதரவை வழங்குகிறது. இயல்பாக, Webpack பகிரப்பட்ட சார்புகளின் அடிப்படையில் சில நிலை குறியீடு பிரித்தலை தானாகவே செய்கிறது. இருப்பினும், Webpack-இன் உள்ளமைவு விருப்பங்களைப் பயன்படுத்தி பண்டில் பிரித்தல் நடத்தையை மேலும் தனிப்பயனாக்கலாம்.

முக்கிய Webpack உள்ளமைவு விருப்பங்கள்:

• entry: உங்கள் செயலிக்கான நுழைவுப் புள்ளிகளை வரையறுக்கிறது. ஒவ்வொரு நுழைவுப் புள்ளியும் ஒரு தனி பண்டிலில் முடியலாம்.
• output.filename: வெளியீட்டு பண்டில்களின் பெயரைக் குறிப்பிடுகிறது. ஒவ்வொரு பண்டிலுக்கும் தனித்துவமான கோப்புப் பெயர்களை உருவாக்க `[name]` மற்றும் `[chunkhash]` போன்ற இடஒதுக்கீடுகளைப் பயன்படுத்தலாம்.
• optimization.splitChunks: Webpack-இன் உள்ளமைக்கப்பட்ட குறியீடு பிரித்தல் அம்சங்களை இயக்குகிறது மற்றும் உள்ளமைக்கிறது. இந்த விருப்பம் வெண்டர் லைப்ரரிகள் (எ.கா., React, Lodash) மற்றும் பகிரப்பட்ட மாட்யூல்களுக்கு தனித்தனி பண்டில்களை உருவாக்க உங்களை அனுமதிக்கிறது.

Webpack உள்ளமைவு உதாரணம்:

module.exports = {
  //...
  optimization: {
    splitChunks: {
      chunks: 'all',
      cacheGroups: {
        vendor: {
          test: /[\\/]node_modules[\\/]/,
          name: 'vendors',
          chunks: 'all',
        },
      },
    },
  },
};

இந்த உள்ளமைவு, `node_modules` கோப்பகத்தில் அமைந்துள்ள அனைத்து மாட்யூல்களுக்கும் `vendors` என்ற தனி பண்டிலை உருவாக்க Webpack-க்குச் சொல்கிறது. இது ஒரு பொதுவான மேம்படுத்தல் நுட்பமாகும், ஏனெனில் வெண்டர் லைப்ரரிகள் பெரும்பாலும் பெரியதாகவும், அடிக்கடி புதுப்பிக்கப்படாதவையாகவும் இருக்கும்.

பயனுள்ள பண்டில் பிரித்தலுக்கான உத்திசார்ந்த குறியீடு அமைப்பு

பயனுள்ள பண்டில் பிரித்தலுக்கு உத்திசார்ந்த குறியீடு அமைப்பு தேவை. உங்கள் செயலியை ஒரு மாடுலர் மற்றும் நன்கு வரையறுக்கப்பட்ட முறையில் கட்டமைப்பதன் மூலம், பண்டில் பிரித்தலின் நன்மைகளை அதிகரிக்கலாம் மற்றும் ஆரம்ப ஏற்றுதல் நேரங்களில் ஏற்படும் தாக்கத்தைக் குறைக்கலாம்.

முக்கிய குறியீடு அமைப்பு உத்திகள்:

• காம்போனென்ட்-அடிப்படையிலான கட்டமைப்பு: உங்கள் செயலியை மீண்டும் பயன்படுத்தக்கூடிய காம்போனென்ட்களாக ஒழுங்கமைக்கவும். இது தனிப்பட்ட மாட்யூல்களை அடையாளம் கண்டு பிரிப்பதை எளிதாக்குகிறது.
• மாடுலர் வடிவமைப்பு: உங்கள் செயலியை தெளிவான பொறுப்புகளுடன் சிறிய, தன்னிறைவான மாட்யூல்களாக உடைக்கவும்.
• சார்பு மேலாண்மை: மாட்யூல்களுக்கு இடையிலான சார்புகளை கவனமாக நிர்வகிக்கவும். வட்ட சார்புகளைத் தவிர்க்கவும், ஏனெனில் அவை பண்டில் பிரித்தலைத் தடுக்கலாம்.
• முக்கியமற்ற காம்போனென்ட்களின் சோம்பேறி ஏற்றுதல்: ஆரம்ப பயனர் அனுபவத்திற்கு உடனடியாகத் தெரியாத அல்லது அவசியமில்லாத காம்போனென்ட்களை சோம்பேறித்தனமாக ஏற்றவும். எடுத்துக்காட்டுகளில் மோடல்கள், டூல்டிப்கள் மற்றும் மேம்பட்ட அம்சங்கள் அடங்கும்.
• ரூட்-அடிப்படையிலான அமைப்பு: உங்கள் குறியீட்டுக் கட்டமைப்பை உங்கள் செயலியின் ரூட்களுடன் சீரமைக்கவும். இது ரூட்-அடிப்படையிலான குறியீடு பிரித்தலைச் செயல்படுத்துவதையும் பராமரிப்பதையும் எளிதாக்குகிறது.

உத்திசார்ந்த பண்டில் பிரித்தலின் நன்மைகள்

உத்திசார்ந்த பண்டில் பிரித்தல் குறிப்பிடத்தக்க நன்மைகளைத் தருகிறது, அவற்றுள்:

• மேம்படுத்தப்பட்ட செயல்திறன்: வேகமான ஆரம்ப ஏற்றுதல் நேரங்கள் மற்றும் குறைக்கப்பட்ட நெட்வொர்க் நெரிசல் ஆகியவை ஒரு மென்மையான, அதிக பதிலளிக்கக்கூடிய பயனர் அனுபவத்திற்கு வழிவகுக்கும்.
• மேம்பட்ட பயனர் அனுபவம்: விரைவாக ஏற்றப்படும் மற்றும் அவர்களின் தொடர்புகளுக்கு உடனடியாக பதிலளிக்கும் செயலிகளுடன் பயனர்கள் ஈடுபடுவதற்கான வாய்ப்புகள் அதிகம்.
• குறைக்கப்பட்ட மேம்பாட்டுச் செலவுகள்: குறியீடு அமைப்பு மற்றும் பராமரிப்பை மேம்படுத்துவதன் மூலம், பண்டில் பிரித்தல் நீண்ட காலத்திற்கு மேம்பாட்டுச் செலவுகளைக் குறைக்கும்.
• மேம்படுத்தப்பட்ட SEO: தேடுபொறிகள் வேகமான ஏற்றுதல் நேரங்களைக் கொண்ட வலைத்தளங்களுக்கு சாதகமாக உள்ளன, இது உங்கள் தேடுபொறி தரவரிசையை மேம்படுத்தும்.
• சிறந்த மொபைல் அனுபவம்: பண்டில் பிரித்தல் மொபைல் பயனர்களுக்கு குறிப்பாக நன்மை பயக்கும், அவர்கள் பெரும்பாலும் வரையறுக்கப்பட்ட அலைவரிசை மற்றும் மெதுவான சாதனங்களைக் கொண்டுள்ளனர்.

React பண்டில் பிரித்தலுக்கான சிறந்த நடைமுறைகள்

உங்கள் பண்டில் பிரித்தல் செயல்படுத்தல் பயனுள்ளதாகவும் பராமரிக்கக்கூடியதாகவும் இருப்பதை உறுதிசெய்ய, இந்த சிறந்த நடைமுறைகளைப் பின்பற்றவும்:

• டைனமிக் இறக்குமதிகளைப் பயன்படுத்தவும்: டைனமிக் இறக்குமதிகள் React செயலிகளில் பண்டில் பிரித்தலுக்கான விருப்பமான அணுகுமுறையாகும்.
• React.lazy மற்றும் Suspense-ஐப் பயன்படுத்தவும்: விளக்கமான குறியீடு பிரித்தலுக்கு React.lazy மற்றும் Suspense-ஐப் பயன்படுத்தவும்.
• Webpack உள்ளமைவை மேம்படுத்தவும்: பண்டில் அளவுகள் மற்றும் கேச்சிங்கை மேம்படுத்த உங்கள் Webpack உள்ளமைவை நன்றாகச் சரிசெய்யவும்.
• பண்டில் அளவுகளைக் கண்காணிக்கவும்: உங்கள் பண்டில் அளவுகளைக் காட்சிப்படுத்தவும், மேம்பாட்டிற்கான பகுதிகளை அடையாளம் காணவும் Webpack Bundle Analyzer போன்ற கருவிகளைப் பயன்படுத்தவும்.
• உங்கள் செயல்படுத்தலைச் சோதிக்கவும்: உங்கள் பண்டில் பிரித்தல் செயல்படுத்தல் சரியாக வேலை செய்கிறது மற்றும் எந்த பின்னடைவுகளையும் அறிமுகப்படுத்தவில்லை என்பதை உறுதிப்படுத்த அதை முழுமையாகச் சோதிக்கவும்.
• செயல்திறனை விவரக்குறிப்பிடவும்: உங்கள் செயலியின் செயல்திறனை விவரக்குறிப்பிடவும், இடையூறுகளை அடையாளம் காணவும் உலாவி டெவலப்பர் கருவிகளைப் பயன்படுத்தவும்.
• உள்ளடக்க விநியோக நெட்வொர்க்கை (CDN) கருத்தில் கொள்ளவும்: உங்கள் ஜாவாஸ்கிரிப்ட் பண்டில்கள் உட்பட உங்கள் நிலையான சொத்துக்களை புவியியல் ரீதியாக விநியோகிக்கப்பட்ட சேவையகங்களிலிருந்து வழங்க ஒரு CDN-ஐப் பயன்படுத்தவும். இது உலகெங்கிலும் உள்ள பயனர்களுக்கான ஏற்றுதல் நேரங்களை மேலும் மேம்படுத்தும். எடுத்துக்காட்டுகளில் Cloudflare, AWS CloudFront, மற்றும் Akamai ஆகியவை அடங்கும்.
• உலாவி கேச்சிங்கைச் செயல்படுத்தவும்: உங்கள் ஜாவாஸ்கிரிப்ட் பண்டில்களுக்கு பொருத்தமான கேச் தலைப்புகளை அமைக்க உங்கள் சேவையகத்தை உள்ளமைக்கவும். இது உலாவிகள் பண்டில்களை உள்ளூரில் கேச் செய்ய அனுமதிக்கிறது, அடுத்தடுத்த வருகைகளில் அவற்றைப் பதிவிறக்குவதற்கான தேவையைக் குறைக்கிறது.
• உங்கள் செயலியைப் பகுப்பாய்வு செய்யவும்: பண்டில் பிரித்தலைச் செயல்படுத்துவதற்கு முன்பு, அடிப்படை செயல்திறன் மதிப்பெண்ணைப் பெறவும், மேம்பாட்டிற்கான பகுதிகளை அடையாளம் காணவும் Lighthouse (Chrome DevTools-இல் கிடைக்கிறது) அல்லது WebPageTest போன்ற கருவிகளைப் பயன்படுத்தவும். இது உங்கள் பண்டில் பிரித்தல் முயற்சிகளுக்கு முன்னுரிமை அளிக்க உதவும்.
• சர்வதேசமயமாக்கல் (i18n) பரிசீலனைகள்: உங்கள் செயலி பல மொழிகளை ஆதரித்தால், உங்கள் மொழி கோப்புகளை தனித்தனி பண்டில்களாகப் பிரிப்பதைக் கருத்தில் கொள்ளவும். இது பயனர்கள் தங்களுக்குத் தேவையான மொழி கோப்புகளை மட்டுமே பதிவிறக்க அனுமதிக்கிறது, ஆரம்ப ஏற்றுதல் அளவைக் குறைக்கிறது.

பண்டில் அளவைப் பகுப்பாய்வு செய்வதற்கான கருவிகள்

பண்டில் அளவுகளைக் காட்சிப்படுத்துவது மேம்படுத்தலுக்கான பகுதிகளைக் கண்டறிய உதவுகிறது. கருவிகள் போன்ற:

• Webpack Bundle Analyzer: ஒரு ஊடாடும் ட்ரீமேப்பில் வெப்பேக் வெளியீட்டு கோப்புகளின் (பண்டில்கள்) அளவைக் காட்டும் ஒரு காட்சி கருவி.
• Source Map Explorer: ஒவ்வொரு மாட்யூலின் அசல் (சுருக்கப்படாத) அளவைக் காட்ட மூல வரைபடங்களைப் பயன்படுத்தி ஜாவாஸ்கிரிப்ட் பண்டில்களைப் பகுப்பாய்வு செய்கிறது.

முடிவுரை

React பண்டில் பிரித்தல் என்பது உங்கள் React செயலிகளின் செயல்திறனை மேம்படுத்துவதற்கான ஒரு அத்தியாவசிய நுட்பமாகும். உங்கள் குறியீட்டை உத்தி ரீதியாக சிறிய பண்டில்களாகப் பிரித்து, தேவைக்கேற்ப ஏற்றுவதன் மூலம், ஆரம்ப ஏற்றுதல் நேரங்களை கணிசமாக மேம்படுத்தலாம், பயனர் அனுபவத்தை மேம்படுத்தலாம், மற்றும் மேம்பாட்டுச் செலவுகளைக் குறைக்கலாம். இந்தக் கட்டுரையில் கோடிட்டுக் காட்டப்பட்டுள்ள சிறந்த நடைமுறைகளைப் பின்பற்றுவதன் மூலமும், சரியான கருவிகளைப் பயன்படுத்துவதன் மூலமும், உங்கள் பண்டில் பிரித்தல் செயல்படுத்தல் பயனுள்ளதாகவும், பராமரிக்கக்கூடியதாகவும், குறிப்பிடத்தக்க செயல்திறன் ஆதாயங்களை வழங்குவதாகவும் இருப்பதை உறுதிசெய்யலாம்.

பண்டில் பிரித்தலைச் செயல்படுத்துவது, இன்றைய தேவைமிகுந்த வலைச் சூழலில் போட்டியிடக்கூடிய உயர் செயல்திறன், பயனர் நட்பு React செயலிகளைக் உருவாக்குவதில் ஒரு முக்கியமான படியாகும். காத்திருக்க வேண்டாம் – இன்றே உங்கள் பண்டில்களைப் பிரிக்கத் தொடங்கி, வித்தியாசத்தை அனுபவியுங்கள்!