రియాక్ట్ పనితీరు ఆప్టిమైజేషన్: బండిల్ సైజును తగ్గించడంలో నైపుణ్యం | MLOG | MLOG

ఈ ఉదాహరణలోని ప్రతి రౌట్ దాని సంబంధిత కాంపోనెంట్‌ను ఆలస్యంగా లోడ్ చేస్తుంది, అప్లికేషన్ యొక్క ప్రారంభ లోడ్ సమయాన్ని మెరుగుపరుస్తుంది.

2. ట్రీ షేకింగ్

ట్రీ షేకింగ్ అనేది మీ అప్లికేషన్ నుండి డెడ్ కోడ్‌ను తొలగించే ఒక టెక్నిక్. డెడ్ కోడ్ అంటే మీ అప్లికేషన్‌లో వాస్తవంగా ఎప్పుడూ ఉపయోగించని కోడ్, కానీ బండిల్‌లో చేర్చబడిన కోడ్. మీరు మొత్తం లైబ్రరీలను ఇంపోర్ట్ చేసి వాటిలో కొంత భాగాన్ని మాత్రమే ఉపయోగించినప్పుడు ఇది తరచుగా జరుగుతుంది.

వెబ్‌ప్యాక్ మరియు రోలప్ వంటి ఆధునిక జావాస్క్రిప్ట్ బండ్లర్‌లు స్వయంచాలకంగా ట్రీ షేకింగ్‌ను నిర్వహించగలవు. ట్రీ షేకింగ్ సమర్థవంతంగా పనిచేయడానికి, కామన్‌జేఎస్ (require సింటాక్స్) బదులుగా ES మాడ్యూల్స్ (import మరియు export సింటాక్స్) ఉపయోగించడం ముఖ్యం. ES మాడ్యూల్స్ బండ్లర్‌కు మీ కోడ్‌ను స్టాటిక్‌గా విశ్లేషించడానికి మరియు ఏ ఎగుమతులు వాస్తవంగా ఉపయోగించబడ్డాయో నిర్ధారించడానికి అనుమతిస్తాయి.

ఉదాహరణ:

మీరు lodash అనే యుటిలిటీ లైబ్రరీని ఉపయోగిస్తున్నారని అనుకుందాం. మొత్తం లైబ్రరీని ఇంపోర్ట్ చేయడానికి బదులుగా:

            import _ from 'lodash';

_.map([1, 2, 3], (n) => n * 2);
            

మీకు అవసరమైన ఫంక్షన్‌లను మాత్రమే ఇంపోర్ట్ చేయండి:

            import map from 'lodash/map';

map([1, 2, 3], (n) => n * 2);
            

ఇది మీ బండిల్‌లో map ఫంక్షన్ మాత్రమే చేర్చబడిందని నిర్ధారిస్తుంది, దాని సైజును గణనీయంగా తగ్గిస్తుంది.

3. డైనమిక్ ఇంపోర్ట్స్

React.lazy() మాదిరిగానే, డైనమిక్ ఇంపోర్ట్స్ (import() సింటాక్స్ ఉపయోగించి) మీకు డిమాండ్‌పై మాడ్యూల్స్‌ను లోడ్ చేయడానికి అనుమతిస్తాయి. ఇది నిర్దిష్ట పరిస్థితులలో మాత్రమే అవసరమైన పెద్ద లైబ్రరీలు లేదా కాంపోనెంట్‌లను లోడ్ చేయడానికి ఉపయోగపడుతుంది.

ఉదాహరణ:

            async function handleClick() {
  const module = await import('./MyLargeComponent');
  const MyLargeComponent = module.default;
  // Use MyLargeComponent
}

            

ఈ ఉదాహరణలో, MyLargeComponent సాధారణంగా వినియోగదారు చర్యకు ప్రతిస్పందనగా, handleClick ఫంక్షన్ పిలిచినప్పుడు మాత్రమే లోడ్ చేయబడుతుంది.

4. మినిఫికేషన్ మరియు కంప్రెషన్

మినిఫికేషన్ మీ కోడ్ నుండి అనవసరమైన అక్షరాలను, ఉదాహరణకు వైట్‌స్పేస్, కామెంట్లు, మరియు ఉపయోగించని వేరియబుల్స్‌ను తొలగిస్తుంది. కంప్రెషన్ నమూనాలను కనుగొని వాటిని మరింత సమర్థవంతంగా సూచించే అల్గారిథమ్‌లను వర్తింపజేయడం ద్వారా మీ కోడ్ సైజును తగ్గిస్తుంది.

వెబ్‌ప్యాక్, పార్సెల్, మరియు రోలప్ వంటి చాలా ఆధునిక బిల్డ్ టూల్స్ మినిఫికేషన్ మరియు కంప్రెషన్ కోసం అంతర్నిర్మిత మద్దతును కలిగి ఉంటాయి. ఉదాహరణకు, వెబ్‌ప్యాక్ మినిఫికేషన్ కోసం టెర్సర్‌ను ఉపయోగిస్తుంది మరియు కంప్రెషన్ కోసం Gzip లేదా Brotliని ఉపయోగించడానికి కాన్ఫిగర్ చేయవచ్చు.

ఉదాహరణ (వెబ్‌ప్యాక్ కాన్ఫిగరేషన్):

            const TerserPlugin = require('terser-webpack-plugin');
const CompressionPlugin = require('compression-webpack-plugin');

module.exports = {
  // ...
  optimization: {
    minimize: true,
    minimizer: [new TerserPlugin()],
  },
  plugins: [
    new CompressionPlugin({
      algorithm: 'gzip',
      test: /\.(js|css)$/,
      threshold: 10240,
      minRatio: 0.8,
    }),
  ],
};

            

ఈ కాన్ఫిగరేషన్ టెర్సర్ ఉపయోగించి మినిఫికేషన్ మరియు Gzip ఉపయోగించి కంప్రెషన్‌ను ఎనేబుల్ చేస్తుంది. threshold ఎంపిక కంప్రెస్ చేయబడటానికి ఒక ఫైల్ యొక్క కనీస సైజును (బైట్లలో) నిర్దేశిస్తుంది.

5. ఇమేజ్ ఆప్టిమైజేషన్

చిత్రాలు తరచుగా మీ అప్లికేషన్ బండిల్ సైజుకు గణనీయమైన కారణం కావచ్చు. మీ చిత్రాలను ఆప్టిమైజ్ చేయడం వల్ల పనితీరును నాటకీయంగా మెరుగుపరచవచ్చు.

ఇమేజ్ ఆప్టిమైజేషన్ కోసం టెక్నిక్‌లు:

6. లైబ్రరీలను తెలివిగా ఎంచుకోండి

మీ అప్లికేషన్‌లో మీరు ఉపయోగించే లైబ్రరీలను జాగ్రత్తగా అంచనా వేయండి. కొన్ని లైబ్రరీలు చాలా పెద్దవిగా ఉండవచ్చు, మీరు వాటి కార్యాచరణలో కొంత భాగాన్ని మాత్రమే ఉపయోగించినప్పటికీ. మీకు అవసరమైన ఫీచర్లను మాత్రమే అందించే చిన్న, మరింత కేంద్రీకృత లైబ్రరీలను ఉపయోగించడాన్ని పరిగణించండి.

ఉదాహరణ:

Moment.js వంటి పెద్ద తేదీ ఫార్మాటింగ్ లైబ్రరీని ఉపయోగించడానికి బదులుగా, date-fns లేదా Day.js వంటి చిన్న ప్రత్యామ్నాయాలను ఉపయోగించడాన్ని పరిగణించండి. ఈ లైబ్రరీలు గణనీయంగా చిన్నవి మరియు ఇలాంటి కార్యాచరణను అందిస్తాయి.

బండిల్ సైజు పోలిక:

7. HTTP/2

HTTP/2 అనేది HTTP ప్రోటోకాల్ యొక్క కొత్త వెర్షన్, ఇది HTTP/1.1 కంటే అనేక పనితీరు మెరుగుదలలను అందిస్తుంది, వీటిలో:

మీ సర్వర్‌లో HTTP/2ని ఎనేబుల్ చేయడం వల్ల మీ రియాక్ట్ అప్లికేషన్ పనితీరును గణనీయంగా మెరుగుపరచవచ్చు, ముఖ్యంగా చాలా చిన్న ఫైల్‌లతో వ్యవహరించేటప్పుడు. చాలా ఆధునిక వెబ్ సర్వర్‌లు మరియు CDNలు HTTP/2కి మద్దతు ఇస్తాయి.

8. బ్రౌజర్ కాషింగ్

బ్రౌజర్ కాషింగ్ బ్రౌజర్‌లకు స్టాటిక్ ఆస్తులను (చిత్రాలు, జావాస్క్రిప్ట్ ఫైల్‌లు, మరియు CSS ఫైల్‌లు వంటివి) స్థానికంగా నిల్వ చేయడానికి అనుమతిస్తుంది. ఒక వినియోగదారు మీ అప్లికేషన్‌ను మళ్లీ సందర్శించినప్పుడు, బ్రౌజర్ ఈ ఆస్తులను మళ్లీ డౌన్‌లోడ్ చేయడానికి బదులుగా కాష్ నుండి తిరిగి పొందవచ్చు, ఇది లోడ్ సమయాలను గణనీయంగా తగ్గిస్తుంది.

మీ స్టాటిక్ ఆస్తుల కోసం తగిన కాష్ హెడర్‌లను సెట్ చేయడానికి మీ సర్వర్‌ను కాన్ఫిగర్ చేయండి. Cache-Control హెడర్ అత్యంత ముఖ్యమైనది. ఇది బ్రౌజర్ ఒక ఆస్తిని ఎంతకాలం కాష్ చేయాలో పేర్కొనడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఉదాహరణ:

            Cache-Control: public, max-age=31536000
            

ఈ హెడర్ బ్రౌజర్‌కు ఆస్తిని ఒక సంవత్సరం పాటు కాష్ చేయమని చెబుతుంది.

9. సర్వర్-సైడ్ రెండరింగ్ (SSR)

సర్వర్-సైడ్ రెండరింగ్ (SSR) మీ రియాక్ట్ కాంపోనెంట్‌లను సర్వర్‌లో రెండర్ చేయడం మరియు ప్రారంభ HTMLను క్లయింట్‌కు పంపడం కలిగి ఉంటుంది. ఇది ప్రారంభ లోడ్ సమయం మరియు SEOని మెరుగుపరుస్తుంది, ఎందుకంటే సెర్చ్ ఇంజన్లు HTML కంటెంట్‌ను సులభంగా క్రాల్ చేయగలవు.

Next.js మరియు Gatsby వంటి ఫ్రేమ్‌వర్క్‌లు మీ రియాక్ట్ అప్లికేషన్‌లలో SSRని అమలు చేయడం సులభం చేస్తాయి.

SSR యొక్క ప్రయోజనాలు:

  • మెరుగైన ప్రారంభ లోడ్ సమయం: బ్రౌజర్ ముందుగా రెండర్ చేయబడిన HTMLను అందుకుంటుంది, ఇది కంటెంట్‌ను వేగంగా ప్రదర్శించడానికి అనుమతిస్తుంది.
  • మెరుగైన SEO: సెర్చ్ ఇంజన్లు HTML కంటెంట్‌ను సులభంగా క్రాల్ చేయగలవు, మీ అప్లికేషన్ యొక్క సెర్చ్ ఇంజన్ ర్యాంకింగ్‌ను మెరుగుపరుస్తాయి.
  • మెరుగైన వినియోగదారు అనుభవం: వినియోగదారులు కంటెంట్‌ను వేగంగా చూస్తారు, ఇది మరింత ఆకర్షణీయమైన అనుభవానికి దారితీస్తుంది.
  • 10. మెమోయిజేషన్

    మెమోయిజేషన్ అనేది ఖరీదైన ఫంక్షన్ కాల్‌ల ఫలితాలను కాష్ చేయడం మరియు అవే ఇన్‌పుట్‌లు మళ్లీ సంభవించినప్పుడు వాటిని తిరిగి ఉపయోగించడం కోసం ఒక టెక్నిక్. రియాక్ట్‌లో, మీరు ఫంక్షనల్ కాంపోనెంట్‌లను మెమోయిజ్ చేయడానికి React.memo() హయ్యర్-ఆర్డర్ కాంపోనెంట్‌ను ఉపయోగించవచ్చు. ఇది కాంపోనెంట్ యొక్క ప్రాప్స్ మారనప్పుడు అనవసరమైన రీ-రెండర్‌లను నివారిస్తుంది.

    ఉదాహరణ:

                import React from 'react';
    
    const MyComponent = React.memo(function MyComponent(props) {
      // Render component
      return 
    {props.data}
    ; }); export default MyComponent;

    ఈ ఉదాహరణలో, props.data ప్రాప్ మారితేనే MyComponent మళ్లీ రెండర్ అవుతుంది. కాంపోనెంట్ ఎప్పుడు రీ-రెండర్ అవ్వాలో మరింత నియంత్రణ అవసరమైతే మీరు React.memo()కి ఒక కస్టమ్ పోలిక ఫంక్షన్‌ను కూడా అందించవచ్చు.

    వాస్తవ-ప్రపంచ ఉదాహరణలు మరియు అంతర్జాతీయ పరిగణనలు

    బండిల్ సైజును తగ్గించే సూత్రాలు సార్వత్రికమైనవి, కానీ వాటి అనువర్తనం మీ ప్రాజెక్ట్ యొక్క నిర్దిష్ట సందర్భం మరియు లక్ష్య ప్రేక్షకులపై ఆధారపడి మారవచ్చు. ఇక్కడ కొన్ని ఉదాహరణలు:

    టూల్స్ మరియు వనరులు

    బండిల్ సైజును తగ్గించడానికి ఇక్కడ కొన్ని సహాయకరమైన టూల్స్ మరియు వనరులు ఉన్నాయి:

    ముగింపు

    బండిల్ సైజును తగ్గించడం అనేది వివరాలపై జాగ్రత్తగా శ్రద్ధ అవసరమయ్యే నిరంతర ప్రక్రియ. ఈ గైడ్‌లో వివరించిన టెక్నిక్‌లను అమలు చేయడం ద్వారా, మీరు మీ రియాక్ట్ అప్లికేషన్ పనితీరును గణనీయంగా మెరుగుపరచవచ్చు మరియు మెరుగైన వినియోగదారు అనుభవాన్ని అందించవచ్చు. మీ బండిల్ సైజును క్రమం తప్పకుండా విశ్లేషించడం మరియు ఆప్టిమైజేషన్ కోసం ప్రాంతాలను గుర్తించడం గుర్తుంచుకోండి. చిన్న బండిల్ యొక్క ప్రయోజనాలు—వేగవంతమైన లోడ్ సమయాలు, మెరుగైన వినియోగదారు ఎంగేజ్‌మెంట్, మరియు మెరుగైన మొత్తం అనుభవం—ప్రయత్నానికి తగినవి.

    వెబ్ డెవలప్‌మెంట్ పద్ధతులు అభివృద్ధి చెందుతూనే ఉన్నందున, ప్రపంచ ప్రేక్షకుల డిమాండ్లను తీర్చే అధిక-పనితీరు గల రియాక్ట్ అప్లికేషన్‌లను రూపొందించడానికి బండిల్ సైజును తగ్గించడం కోసం తాజా టెక్నిక్‌లు మరియు టూల్స్‌తో నవీకరించబడటం చాలా ముఖ్యం.