Strona główna / Artykuły

Osiem rozwiązań związanych z renderowaniem w React, które zmniejszają liczba ponownych renderowań o 80% bez konieczności przepisywania kodu.

Najpierw profilowanie, a następnie stosowanie funkcji memo, useMemo, useCallback, efektów przejść, wirtualizacji listy, dzielenia kodu oraz wąskich selektorów w celu przyspieszenia dużej konsoli React.

Wydawca: REACTAPP.TOP5 min czytania1245 słów

Źródła: How I Optimized a Slow React App Without Rewriting It

Wyobraź sobie demonstrację panelu sterowania, w której każde kliknięcie filtru zamraża ekran na całą sekundę. Kod jest uporządkowany i odpowiada najlepszym praktykom, a mimo to jest nieznośnie wolny. Baza kodu liczy 50 000 linii, a nikt nie ma budżetu na jej przebudowę, więc jedyną opcją jest uczynienie procesu renderowania bardziej efektywnym bez zmiany funkcjonalności. Poniższe kroki prowadzą w tym kierunku i w przykładowym scenariuszu pozwalają zmniejszyć liczba ponownych renderowań o około 80%.

Pomiar przed jakimikolwiek zmianami

Optymalizacja bez analizy to marnowanie czasu, dlatego najpierw należy przeprowadzić profilowanie. Trzy narzędzia wykonują większość pracy:

  • React DevTools Profiler – służy do rejestrowania interakcji i analizy wykresu, aby zobaczyć, które komponenty są renderowane niepotrzebnie.
  • why-did-you-render – biblioteka, która rejestruje uniknione możliwe ponowne renderowania.
  • Karta Performance w Chrome DevTools – pokazuje rzeczywiste czasy klatek.

Typowy wzorzec jest łatwy do zauważenia. Rodzic aktualizuje swój stan, a wszystkie podległe mu komponenty ponownie się renderują, niezależnie od tego, czy wykorzystują zmienione dane, czy nie. W małej aplikacji to ma niewielkie znaczenie. W panelu sterowania z setkami komponentów jedna zmiana stanu na górze może wywołać łańcuchową reakcję.

Memoizacja komponentów za pomocą React.memo

Gdy komponent otrzymuje te same propsy, powinien generować ten sam wynik, a React.memo zapisuje ten wynik w pamięci. Rozsądnym podejściem jest zacząć od czystych komponentów, które najczęściej pojawiają się na liście ponownych renderowań w narzędziu analizy, a nie otaczać nimi wszystkiego.

const ExpensiveComponent = React.memo(({ data, onUpdate }) => {
  // Component logic
});

Jedna wada: React.memo porównuje właściwości na powierzchniowym poziomie. Funkcja przekazana jako właściwość jest tworzona na nowo przy każdym renderowaniu, więc mechanizm memoizacji nigdy nie zostaje uruchomiony. useCallback rozwiązuje ten problem. Gdy memoizacja zostanie zastosowana we właściwym miejscu, komponenty, które wcześniej renderowały się przy każdej zmianie stanu, teraz robią to tylko wtedy, gdy zmieniają się ich własne właściwości.

Uwaga: nie każdy komponent odniesie korzyść. Tylko te, które często renderują się ponownie z identycznymi właściwościami, czerpią z tego korzyści. Memoizacja wszystkiego może być szkodliwa, ponieważ przechowywanie poprzednich wyników zużywa pamięć.

useMemo i useCallback

React.memo zapobiega ponownemu renderowaniu komponentów. useMemo i useCallback zapobiegają powtarzaniu się obliczeń wewnątrz nich.

Weź komponent, który oblicza statystyki zbiorcze z dużego tablicy. Jeśli jest on wykonywany przy każdym renderowaniu, włącznie z tymi, przy których dane się nie zmieniły, jest to marnotrawstwo zasobów. Umieszczenie go w funkcji useMemo z danymi jako zależnością oznacza, że zostanie ponownie wykonywany tylko wtedy, gdy dane się zmienią:

const computedStats = useMemo(() => {
  return expensiveAggregation(data);
}, [data]);

useCallback rozwiązuje inne problemy. Obsługi zdarzeń przekazywane dzieciom otrzymują nową tożsamość przy każdym renderowaniu, co unieważnia płytkie porównanie wewnątrz React.memo. Otoczenie obsługi zdarzeń utrzymuje jej referencję stabilną:

const handleUpdate = useCallback((id) => {
  updateItem(id);
}, []);

Skutkiem jest to, że kosztowne obliczenia przestają się powtarzać, dzieci przestają bez potrzeby ponownie renderować treść, a interfejs wydaje się bardziej responsywny.

Zachowaj responsywność podczas pisania za pomocą useTransition

Kliknięcie powinno wywołać natychmiastową reakcję, ale intensywne aktualizacje stanu mogą zamarzyć przeglądarkę do czasu ich zakończenia. Weźmy pod uwagę pole wyszukiwania, które filtruje listę 10 000 elementów. Bez żadnej pomocy każde naciśnięcie klawisza blokuje ekran na setki milisekund.

useTransition oznacza taką aktualizację jako o niskiej priorytecie, dzięki czemu React utrzymuje interfejs aktywny, podczas gdy intensywne obliczenia odbywają się w tle:

const [isPending, startTransition] = useTransition();
const handleSearch = (term) => {
  startTransition(() => {
    setSearchTerm(term);
    // Filtering happens in the background
  });
};

Filtrowanie nadal ma miejsce, tylko nie kosztem pisania. Różnica jest oczywista, gdy tylko ktoś użyje tego pola.

Wartości opóźnienia z useDeferredValue

useDeferredValue przypomina useTransition, ale odnosi się do wartości zamiast do aktualizacji stanu. Informuje React, że wartość może być opóźniona, gdy dzieje się coś pilniejszego.

Wyobraźmy sobie wykres na żywo, który przerysowuje się za każdym razem, gdy zmieniają się dane. Jego renderowanie jest kosztowne i blokuje inne aktualizacje. Odkładanie otrzymanej wartości pozwala Reactowi najpierw narysować te najważniejsze elementy:

const deferredData = useDeferredValue(data);
// Chart receives deferredData and updates only when React has idle time

Wykresy i wizualizacje przestają wtedy blokować interakcję, a aplikacja pozostaje płynna nawet przy dużych zbiorach danych.

Wirtualizacja długich list

Użytkownik widzi w każdym momencie tylko niewielki fragment listy, więc renderowanie jej całej marnuje zasoby. Tabela z 500 wierszami, wszystkie zainstalowane jako węzły DOM przy każdej aktualizacji, jest dobrym kandydatem do wirtualizacji. Zastąpienie prostego map() biblioteką react-window, która renderuje tylko widoczne wiersze, zmienia tę sytuację:

import { FixedSizeList } from 'react-window';
const Row = ({ index, style }) => (
  <div style={style}>
    {data[index].name}
  </div>
);
<FixedSizeList
  height={400}
  itemCount={data.length}
  itemSize={35}
  width="100%"
>
  {Row}
</FixedSizeList>

W tym przykładzie tabela zawierała około 20 wierszy zamiast 500. Zużycie pamięci spadło, przewijanie stało się płynniejsze, a strona ładuje się szybciej.

Dzielenie pliku pakietowego według trasy

Kolejnym powszechnym błędem jest wysyłanie całej aplikacji przy pierwszym załadowaniu. Jeśli widoki panelu sterowania, analiz, ustawień i raportów są wszystkie kompilowane do jednego pliku JavaScript, pierwsze załadowanie jest wolne. Funkcje lazy i Suspense w React dzielą plik pakietowy według trasy, dzięki czemu każdy widok ładuje się w momencie, gdy użytkownik do niego przechodzi:

const Dashboard = lazy(() => import('./views/Dashboard'));
const Analytics = lazy(() => import('./views/Analytics'));
function App() {
  return (
    <Suspense fallback={<Loading />}>
      <Routes>
        <Route path="/" element={<Dashboard />} />
        <Route path="/analytics" element={<Analytics />} />
      </Routes>
    </Suspense>
  );
}

W tym scenariuszu początkowy rozmiar pliku spadł z 2,5 MB do 800 KB, a czas pierwszego załadowania znacznie się poprawił.

Zwężenie wybieraczy stanu

W przypadku Redux lub Zustand komponenty często wybierają więcej stanu, niż jest im potrzebne. Jeśli komponent korzeniowy pobiera cały magazyn danych za pomocą useSelector, każda zmiana w magazynie powoduje ponowne renderowanie tego komponentu. Rozwiązaniem jest wybieranie tylko tych fragmentów stanu, których potrzebuje każdy komponent, oraz zapamiętywanie danych pochodnych za pomocą createSelector z Redux Toolkit:

import { createSelector } from '@reduxjs/toolkit';
const selectFilteredData = createSelector(
  (state) => state.items,
  (state) => state.filterTerm,
  (items, term) => items.filter(item =>
    item.name.toLowerCase().includes(term.toLowerCase())
  )
);
// In component:
const filteredData = useSelector(selectFilteredData);

Teraz komponenty są renderowane ponownie tylko wtedy, gdy zmieniają się dane, które faktycznie odczytują, a łańcuch aktualizacji ustaje.

Przed i po

Metryka Przed Po
Średnia liczba ponownych renderowań na interakcję 47 9
Czas do uzyskania interaktywności 2,3 s 1,1 s
Spadki klatek podczas animacji Częste Rzadkie

To oznacza mniej więcej o 80% mniej ponownych renderowań przy tej samej bazie kodu i tych samych funkcjach.

Co to pokazuje

Przyspieszenie aplikacji React to przede wszystkim kwestia zrozumienia, a nie przepisywania kodu. Profiler określa, gdzie szukać, dzięki czemu wysiłki nie są skierowane na losowe komponenty. Każda zmiana rozwiązuje konkretny problem i ma mierzalny efekt, przy czym większość z nich trwa pół godziny lub mniej. Są to precyzyjne ulepszenia, a nie gruntowne zmiany architektoniczne.

Krótko mówiąc, do dyspozycji mamy React.memo dla czystych komponentów, useMemo do złożonych obliczeń, useCallback dla stabilnych funkcji obsługi, dwa hooki do pracy asynchronicznej, react-window do obsługi długich list, ładowanie opóźnione dla tras oraz precyzyjne selektory do zarządzania stanem aplikacji.

Stosując te metody po kolei i konsekwentnie, można przekształcić wolną aplikację w taką, która działa niemal natychmiastowo. Zacznij od profilera w narzędziach deweloperskich, znajdź największy wąskie gardło i napraw je najpierw.

Literatura pokrewna