Visaptverošs ceļvedis React koda sadalīšanai pēc maršrutiem, kas uzlabo lietojumprogrammas veiktspēju un lietotāja pieredzi. Apgūstiet tehnikas un praktiskas ieviešanas stratēģijas.
React koda sadalīšana: uz maršrutiem balstīta saišķu dalīšana optimizētai veiktspējai
Mūsdienu tīmekļa izstrādes vidē ātras un atsaucīgas lietotāja pieredzes nodrošināšana ir vissvarīgākā. Lietotāji sagaida tūlītēju gandarījumu, un lēni ielādējamas lietojumprogrammas var radīt vilšanos un to pamešanu. Viena spēcīga tehnika, kā uzlabot jūsu React lietojumprogrammu veiktspēju, ir koda sadalīšana. Šis raksts iedziļinās uz maršrutiem balstītas koda sadalīšanas specifikā — stratēģijā, kas sadala jūsu lietojumprogrammu mazākos, pārvaldāmos saišķos, ielādējot tikai to kodu, kas nepieciešams pašreizējam maršrutam.
Izpratne par koda sadalīšanu
Koda sadalīšana ir prakse, kurā lietojumprogrammas kods tiek sadalīts vairākos saišķos, kurus pēc tam var ielādēt pēc pieprasījuma vai paralēli. Sadalot kodu, jūs varat ievērojami samazināt lietojumprogrammas sākotnējo ielādes laiku, jo pārlūkprogrammai ir nepieciešams lejupielādēt tikai to kodu, kas nepieciešams sākotnējā skata atveidošanai.
Tā vietā, lai pasniegtu vienu milzīgu JavaScript failu, koda sadalīšana ļauj to sadalīt mazākos gabalos, kas bieži vien ir saskaņoti ar konkrētām funkcijām vai maršrutiem jūsu lietojumprogrammā. Šī pieeja piedāvā vairākas galvenās priekšrocības:
- Samazināts sākotnējais ielādes laiks: Pārlūkprogramma lejupielādē mazāku sākotnējo saišķi, kas nodrošina ātrāku pirmo attēlojumu un uzlabotu lietotāja uztveri.
- Uzlabota veiktspēja: Mazāki saišķi nozīmē mazāk koda, kas jāanalizē un jāizpilda, kā rezultātā lietojumprogramma ir atsaucīgāka.
- Uzlabota lietotāja pieredze: Lietotāji var sākt mijiedarboties ar lietojumprogrammu ātrāk, jo kritiskais kods tiek ielādēts ātri.
- Efektīva resursu izmantošana: Katram maršrutam tiek ielādēts tikai nepieciešamais kods, samazinot joslas platuma patēriņu un uzlabojot resursu izmantošanu.
Uz maršrutiem balstīta koda sadalīšana: Stratēģiska pieeja
Uz maršrutiem balstīta koda sadalīšana koncentrējas uz lietojumprogrammas sadalīšanu, pamatojoties uz tās dažādajiem maršrutiem vai lapām. Šī ir īpaši efektīva stratēģija vienas lapas lietojumprogrammām (SPA), kur sākotnēji tiek ielādēta visa lietojumprogramma, bet jebkurā brīdī ir redzamas tikai tās daļas.
Izmantojot uz maršrutiem balstītu koda sadalīšanu, katrs maršruts vai saistīto maršrutu grupa kļūst par atsevišķu saišķi. Kad lietotājs pāriet uz konkrētu maršrutu, atbilstošais saišķis tiek ielādēts pēc pieprasījuma. Tas nodrošina, ka lietotāji lejupielādē tikai to kodu, kas nepieciešams pašreizējam skatam, samazinot sākotnējo ielādes laiku un uzlabojot kopējo veiktspēju.
Ieviešanas tehnikas: dinamiskie importi un React.lazy
React nodrošina lieliskus rīkus un API uz maršrutiem balstītas koda sadalīšanas ieviešanai, galvenokārt izmantojot dinamiskos importus un React.lazy komponenti.
Dinamiskie importi
Dinamiskie importi ir JavaScript funkcija, kas ļauj ielādēt moduļus asinhroni. Atšķirībā no statiskajiem importiem (piemēram, import Component from './Component'
), dinamiskie importi izmanto import()
funkciju, kas atgriež solījumu (promise). Šis solījums tiek atrisināts ar moduļa eksportiem, kad modulis ir ielādēts.
Tas nodrošina komponentu ielādi pēc pieprasījuma.
Piemērs:
const MyComponent = React.lazy(() => import('./MyComponent'));
Šajā piemērā MyComponent
tiks ielādēts tikai tad, kad tas būs nepieciešams, piemēram, kad tas tiks renderēts noteiktā maršrutā.
React.lazy
React.lazy
ir iebūvēta React komponente, kas atvieglo citu komponentu slinko ielādi (lazy loading). Tā pieņem funkciju, kas atgriež solījumu (promise), kas tiek atrisināts kā React komponente. To parasti izmanto kopā ar dinamiskajiem importiem.
Lai izmantotu React.lazy
, jums ir jāietver slinki ielādētā komponente ar <Suspense>
komponenti. <Suspense>
komponente ļauj attēlot rezerves lietotāja saskarni (piemēram, ielādes indikatoru), kamēr komponente tiek ielādēta.
Piemērs:
import React, { Suspense, lazy } from 'react';
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
const Home = lazy(() => import('./routes/Home'));
const About = lazy(() => import('./routes/About'));
const Contact = lazy(() => import('./routes/Contact'));
function App() {
return (
Loading...
Šajā piemērā komponentes Home
, About
un Contact
tiek slinki ielādētas, kad tiek piekļūts to attiecīgajiem maršrutiem. <Suspense>
komponente attēlo "Loading...", kamēr komponentes tiek ielādētas.
Praktiski ieviešanas soļi
Šeit ir soli pa solim ceļvedis, kā ieviest uz maršrutiem balstītu koda sadalīšanu jūsu React lietojumprogrammā:
- Identificējiet maršrutus: Nosakiet maršrutus jūsu lietojumprogrammā, kurus var sadalīt atsevišķos saišķos. Apsveriet saistīto maršrutu grupēšanu vienā saišķī, lai uzlabotu efektivitāti.
- Izveidojiet maršrutu komponentes: Izveidojiet React komponentes katram maršrutam vai maršrutu grupai. Šīs komponentes tiks slinki ielādētas, izmantojot dinamiskos importus un
React.lazy
. - Ieviesiet slinko ielādi: Izmantojiet
React.lazy
un dinamiskos importus, lai ielādētu maršrutu komponentes asinhroni. Ietveriet katru slinki ielādēto komponenti ar<Suspense>
komponenti, lai nodrošinātu rezerves lietotāja saskarni ielādes laikā. - Konfigurējiet maršrutēšanu: Izmantojiet maršrutēšanas bibliotēku, piemēram,
react-router-dom
, lai definētu maršrutus un saistītu tos ar slinki ielādētajām komponentēm. - Rūpīgi testējiet: Rūpīgi testējiet savu lietojumprogrammu, lai pārliecinātos, ka koda sadalīšana darbojas pareizi un ka slinki ielādētās komponentes tiek ielādētas, kā paredzēts.
- Optimizējiet saišķu izmēru: Analizējiet savu saišķu izmēru un identificējiet iespējas to samazināšanai. Apsveriet rīku, piemēram, Webpack Bundle Analyzer, izmantošanu, lai vizualizētu saišķu saturu un identificētu lielas atkarības.
Papildu tehnikas un apsvērumi
Lai gan uz maršrutiem balstītas koda sadalīšanas pamata ieviešana ir salīdzinoši vienkārša, ir vairākas papildu tehnikas un apsvērumi, kas var vēl vairāk uzlabot jūsu lietojumprogrammas veiktspēju un lietotāja pieredzi.
Priekšielāde (Prefetching)
Priekšielāde ietver resursu (piemēram, saišķu) ielādi, pirms tie ir faktiski nepieciešami. Tas var būt noderīgi, lai uzlabotu jūsu lietojumprogrammas uztverto veiktspēju, jo lietotāji var nepamanīt nekādu ielādes aizkavi, pārejot uz jaunu maršrutu.
Jūs varat ieviest priekšielādi, izmantojot dažādas tehnikas, piemēram:
<link rel="prefetch">
: Šis HTML tags norāda pārlūkprogrammai lejupielādēt norādīto resursu fonā.react-router-dom
's<Link>
komponente: Jūs varat izmantotprefetch
rekvizītu, lai priekšielādētu resursus, kas saistīti ar konkrētu saiti.- Pielāgota priekšielādes loģika: Jūs varat ieviest savu priekšielādes loģiku, izmantojot JavaScript un
import()
funkciju.
Piemērs, izmantojot react-router-dom
's <Link>
:
import { Link } from 'react-router-dom';
function Nav() {
return (
);
}
Servera puses renderēšana (SSR) un koda sadalīšana
Apvienojot servera puses renderēšanu (SSR) ar koda sadalīšanu, var vēl vairāk uzlabot jūsu lietojumprogrammas veiktspēju, īpaši sākotnējo ielādes laiku. SSR ļauj renderēt sākotnējo HTML uz servera, ko pēc tam var nosūtīt klientam. Tas samazina JavaScript daudzumu, kas jālejupielādē un jāizpilda klientā, nodrošinot ātrāku pirmo attēlojumu.
Izmantojot SSR ar koda sadalīšanu, ir svarīgi nodrošināt, ka serveris var apstrādāt arī dinamiskos importus un React.lazy
. Ietvari, piemēram, Next.js un Gatsby, nodrošina iebūvētu atbalstu SSR un koda sadalīšanai, atvieglojot šo tehniku ieviešanu.
Kļūdu apstrāde
Izmantojot slinko ielādi, ir svarīgi apstrādāt potenciālās kļūdas, kas var rasties ielādes procesā. Piemēram, tīkla savienojums var tikt pārtraukts vai serveris var būt nepieejams.
Jūs varat izmantot <ErrorBoundary>
komponenti, lai notvertu kļūdas, kas rodas slinki ielādēto komponentu renderēšanas laikā. <ErrorBoundary>
komponente ļauj attēlot rezerves lietotāja saskarni kļūdas gadījumā.
Piemērs:
import React, { Suspense, lazy } from 'react';
const MyComponent = lazy(() => import('./MyComponent'));
function ErrorFallback() {
return (
Oops! Something went wrong.
);
}
function MyErrorBoundary(props) {
return (
}>
{props.children}
);
}
function App() {
return (
Loading...