Acht React-Rendering-Verbesserungen, die die Neuberechnungen um 80 Prozent reduzieren, ohne dass ein Neuschreiben erforderlich ist.
Zuerst das Profil erstellen und anschließend Memo, useMemo, useCallback, Übergänge, virtuelle Liste, Code-Splitting sowie eng gefasste Selektoren einsetzen, um eine große React-Dashboard-Anwendung zu beschleunigen.
Quellen: How I Optimized a Slow React App Without Rewriting It
Stellen Sie sich eine Dashboard-Demo vor, bei der jeder Klick auf ein Filterfeld den Bildschirm eine volle Sekunde lang einfriert. Der Code ist ordentlich und folgt den besten Praktiken, ist dennoch äußerst langsam. Die Codebasis umfasst 50.000 Zeilen, und niemand hat ein Budget für einen Neuaufbau – daher bleibt nur die Möglichkeit, das Rendering intelligenter zu gestalten, ohne Funktionen zu ändern. Die unten aufgeführten Schritte folgen diesem Ansatz und reduzieren im Beispiel Szenario die erneuten Renderungen um etwa 80 %.
Messen, bevor man etwas anfasst
Blinder Optimismus verschwendet Zeit, daher kommt zunächst das Profilieren. Drei Tools übernehmen den größten Teil der Arbeit:
- Der React DevTools Profiler, um Interaktionen aufzuzeichnen und den Flame Graph zu analysieren, um zu erkennen, welche Komponenten unnötig neu gerendert werden.
why-did-you-render, eine Bibliothek, die vermeidbare erneute Renderungen protokolliert.- Die Performance-Tab der Chrome DevTools, um tatsächliche Frame-Zeiten zu ermitteln.
Muster wie dieses sind leicht zu erkennen. Ein Elternteil ändert seinen Zustand, und alle darunterliegenden Kinder werden neu gerendert – unabhängig davon, ob sie die geänderten Daten verwenden oder nicht. In einer kleinen Anwendung spielt das kaum eine Rolle. In einem Dashboard mit Hunderten von Komponenten kann bereits eine Zustandsänderung an der Spitze eine Kettenreaktion auslösen.
Komponenten mit React.memo memorisieren
Wenn eine Komponente dieselben Props erhält, sollte sie dasselbe Ergebnis liefern, und React.memo speichert dieses Ergebnis. Der sinnvolle Ansatz besteht darin, mit den reinen Komponenten zu beginnen, die am häufigsten in der Liste der Neu-Renderungen des Profilers auftauchen, anstatt alles zu umhüllen.
const ExpensiveComponent = React.memo(({ data, onUpdate }) => {
// Component logic
});
Eine Einschränkung: React.memo vergleicht die Props nur oberflächlich. Eine als Prop übergebene Funktion wird bei jeder Renderung neu erstellt, wodurch die Memoisierung nie ausgelöst wird. useCallback behebt dieses Problem. Sobald die Memoisierung an den richtigen Stellen angewandt wird, rendern Komponenten, die früher bei jeder Zustandsänderung neu renderiert wurden, nun nur noch, wenn ihre eigenen Props sich ändern.
Eine Warnung: Nicht jede Komponente profitiert davon. Nur diejenigen, die häufig mit identischen Props neu rendern, erhalten einen Vorteil. Die Memoisierung aller Elemente kann schädlich sein, da das Speichern früherer Ergebnisse Speicher verbraucht.
useMemo und useCallback
React.memo verhindert das erneute Rendern von Komponenten. useMemo und useCallback verhindern wiederholte Berechnungen innerhalb dieser Komponenten.
Nehmen wir ein Komponente, das aggregierte Statistiken aus einem großen Array berechnet. Wenn dies bei jeder Renderung ausgeführt wird – auch dann, wenn sich die Daten nicht geändert haben – ist das verschwenderisch. Indem man es in useMemo einhüllt und die Daten als Abhängigkeit angibt, wird es nur dann erneut ausgeführt, wenn sich die Daten tatsächlich ändern:
const computedStats = useMemo(() => {
return expensiveAggregation(data);
}, [data]);
useCallback löst ein anderes Problem. Event-Handler, die an Kinderkomponenten übergeben werden, erhalten bei jeder Neuzeichnung eine neue Identität, was der oberflächlichen Vergleichsfunktion in React.memo zuwiderläuft. Durch das Einhüllen des Handlers bleibt seine Referenz stabil:
const handleUpdate = useCallback((id) => {
updateItem(id);
}, []);
Dadurch werden teure Berechnungen nicht mehr wiederholt, Kinder-Elemente werden nicht mehr unnötig neu gerendert, und die Benutzeroberfläche reagiert schneller.
Die Reaktionsfähigkeit beim Tippen mit useTransition beibehalten
Ein Klick sollte sofort eine Reaktion hervorrufen, doch eine aufwändige Aktualisierung des Zustands kann den Browser blockieren, bis sie abgeschlossen ist. Stellen Sie sich ein Suchfeld vor, das eine Liste mit 10.000 Elementen filtert. Ohne Unterstützung blockiert jede Tasteneingabe den Bildschirm für Hunderte von Millisekunden.
useTransition markiert die Aktualisierung als von geringer Priorität, sodass React die Benutzeroberfläche am Laufen hält, während die aufwändige Arbeit im Hintergrund stattfindet:
const [isPending, startTransition] = useTransition();
const handleSearch = (term) => {
startTransition(() => {
setSearchTerm(term);
// Filtering happens in the background
});
};
Die Filterung findet weiterhin statt, nur nicht auf Kosten des Eintippens. Der Unterschied wird sofort deutlich, sobald jemand das Feld verwendet.
Verzögerungswerte mit useDeferredValue
useDeferredValue ähnelt useTransition, bezieht sich jedoch auf einen Wert statt auf eine Zustandsänderung. Es teilt React mit, dass der Wert verzögert angezeigt werden kann, wenn etwas Dringenderes vorliegt.
Stellen Sie sich ein Live-Chart vor, das jedes Mal neu gerendert wird, wenn sich die Daten ändern. Seine Darstellung ist aufwändig und blockiert andere Aktualisierungen. Durch die Verzögerung des empfangenen Wertes kann React zuerst die dringenden Teile darstellen:
const deferredData = useDeferredValue(data);
// Chart receives deferredData and updates only when React has idle time
Diagramme und Visualisierungen behindern dann nicht mehr die Interaktion, und die App bleibt auch bei großen Datensätzen reibungslos.
Langen Listen virtualisieren
Ein Benutzer sieht zu jedem Zeitpunkt nur einen kleinen Teil einer Liste, wodurch die Darstellung der gesamten Liste Ressourcen verschwendet. Eine Tabelle mit 500 Zeilen, die bei jeder Aktualisierung als DOM-Nodee dargestellt werden, eignet sich hier gut. Durch den Ersatz eines einfachen map() durch react-window, das nur die sichtbaren Zeilen darstellt, ändert sich das:
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>
In dem Beispiel wurde eine Tabelle mit etwa 20 Zeilen anstelle von 500 angezeigt. Der Speicherverbrauch sank, das Scrollen wurde flüssiger und die Seite lud schneller.
Das Bundle nach Route aufteilen
Die gesamte Anwendung beim ersten Laden zu übertragen, ist ein weiterer häufiger Fehler. Wenn die Ansichten für das Dashboard, die Analytik, Einstellungen und Berichte alle in einer einzigen JavaScript-Datei kompiliert werden, verlangsamt sich der erste Laden erheblich. Reacts lazy und Suspense teilen das Bundle je nach Route auf, sodass jede Ansicht geladen wird, sobald der Benutzer dorthin navigiert:
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>
);
}
In diesem Szenario sank die anfängliche Größe des Pakets von 2,5 MB auf 800 KB, und die erste Ladezeit verbesserte sich deutlich.
Verengen Sie Ihre State-Selektoren
Mit Redux oder Zustand wählen Komponenten oft mehr State aus, als sie benötigen. Wenn eine Wurzelkomponente den gesamten Store über useSelector abruft, führt jede Änderung im Store dazu, dass diese Komponente neu gerendert wird. Die Lösung besteht darin, nur diejenigen Datenabschnitte auszuwählen, die jede Komponente verwendet, und abgeleitete Daten mithilfe von createSelector aus Redux Toolkit zu memoisieren:
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);
Nun werden Komponenten nur dann neu gerendert, wenn sich die Daten ändern, die sie tatsächlich abrufen, und die Kaskade der Aktualisierungen stoppt.
Vorher und nachher
| Metrik | Vorher | Nachher |
|---|---|---|
| Durchschnittliche Anzahl der Neu-Renderungen pro Interaktion | 47 | 9 |
| Zeit bis zur Interaktivität | 2,3 s | 1,1 s |
| Frame-Verluste während Animationen | Häufig | Selten |
Das bedeutet im Großen und Ganzen etwa 80 Prozent weniger Neu-Renderungen – bei derselben Codebasis und denselben Funktionen.
Was das zeigt
Das Beschleunigen einer React-Anwendung besteht hauptsächlich darin, Zusammenhänge zu verstehen, anstatt alles neu zu schreiben. Der Profiler bestimmt, wo nach Problemen gesucht werden soll, sodass die Anstrengungen nicht auf zufällige Komponenten gerichtet sind. Jede Änderung behebt ein spezifisches Problem und hat einen messbaren Effekt; die meisten dauern eine halbe Stunde oder weniger. Es handelt sich dabei um präzise Optimierungen, keine umfassenden architektonischen Überarbeitungen.
Kurz gesagt: Das Werkzeugset umfasst React.memo für reine Komponenten, useMemo für aufwändige Berechnungen, useCallback für stabile Handler, die beiden koncurrenten Hooks für Aufgaben, die warten können, react-window für lange Listen, das Lazy Loading für Routen sowie präzise Selektoren für den Store-Zustand.
Wenn man diese Muster nacheinander und konsequent anwendet, verwandelt sich eine langsame Anwendung in eine, die sofortig reagiert. Beginnen Sie mit dem Profiler in den DevTools, finden Sie das größte Engpassproblem und beheben Sie dieses zuerst.