React-Performance: Warum weniger Optimierung mehr Tempo bringt

State am richtigen Ort, React Compiler, Transitions, Virtualisierung und Messung: was React-Anwendungen heute wirklich schneller macht
Aktualisiert:
Abstract
- #React
- #React Performance
- #React Compiler
- #useTransition
- #useDeferredValue
- #Code-Splitting
- #Lazy Loading
- #Virtualisierung
Eine React-App wird selten durch mehr Memoisierung schnell, sondern durch weniger überflüssige Arbeit
Angenommen, in einem Webshop ruckelt das Suchfeld. Jeder Tastendruck erscheint mit einer kleinen Verzögerung, auf älteren Smartphones deutlich spürbar. Der erste Reflex im Team: überall useMemo und useCallback einbauen. Die Lage bessert sich kaum, der Code wird schwerer lesbar. Die eigentliche Ursache liegt woanders: Der Suchbegriff steht ganz oben im Komponentenbaum, und jede Eingabe lässt Kopfzeile, Navigation, Produktraster und Fußzeile neu rendern.
Ein Bild hilft beim Verständnis. Betrachten Sie Ihre Anwendung als Autobahn: Komponenten sind die Autos, jedes Rendern ist eine Fahrt. Schneller wird eine Autobahn nicht durch zusätzliche Mautstationen, sondern dadurch, dass Engpässe verschwinden. Genau so funktioniert moderne React-Performance. Wo Sie ansetzen sollten, welche Arbeit inzwischen der React Compiler übernimmt und wie Sie Engpässe messen statt raten, zeigen die folgenden Abschnitte.
Warum viele Performance-Tipps nicht mehr passen
Lange lautete der Standardrat: Komponenten in React.memo verpacken, Funktionen in useCallback, berechnete Werte in useMemo, und „unnötige Re-Renders“ um jeden Preis vermeiden. Schon früher half das selten so viel wie erhofft. Seit es den React Compiler gibt, der diese Zwischenspeicherung automatisch einfügt, ist manuelle Memoisierung in neuem Code meist überflüssig.
Die wirklichen Bremsen liegen in der Regel an anderer Stelle:
- State am falschen Ort: Ein Zustand weit oben im Baum zieht ganze Teilbäume in jedes Rendern hinein.
- Blockierende Aktualisierungen: Aufwendiges Rendern blockiert den Hauptthread, sodass Eingaben verzögert erscheinen.
- Zu viel auf einmal: Die gesamte Anwendung wird geladen, obwohl Nutzer:innen gerade nur eine Seite sehen, oder eine Liste schreibt zehntausend Zeilen ins DOM.
- Effektketten: Ein
useEffectsetzt State, der den nächsten Effekt auslöst, und jede Stufe kostet ein weiteres Rendern.
Keines dieser Probleme löst ein zusätzliches useMemo. Für alle gibt es aber gut etablierte Gegenmittel.
Wenn ein Tastendruck die halbe Seite neu rendert
Auf einer echten Autobahn bremst ein Fahrer kurz ab, der Hintermann bremst stärker, der nächste noch stärker. Wenige Sekunden später steht der Verkehr, obwohl das erste Auto längst weitergefahren ist. In React verbreiten sich Re-Renders ähnlich.
Was bei einem Re-Render passiert
Ändert sich der State einer Komponente, rendert React diese Komponente neu und standardmäßig auch alle Komponenten, die sie in ihrem JSX erzeugt. Rendern heißt dabei zunächst nur: React ruft die Komponentenfunktion auf und vergleicht das Ergebnis mit dem vorherigen. Das DOM, also die tatsächliche Seitenstruktur im Browser, ändert React nur dort, wo sich etwas unterscheidet. Teuer wird es trotzdem, wenn bei jedem Tastendruck Hunderte Komponenten durchlaufen werden, die mit der Eingabe nichts zu tun haben. Diese Komponenten sind die Gaffer auf der Gegenfahrbahn: Sie bremsen mit, ohne beteiligt zu sein.
State dort halten, wo er gebraucht wird
Die wirksamste Gegenmaßnahme ist zugleich die einfachste. Fachleute nennen sie State-Colocation: Der Zustand wandert in die kleinste Komponente, die ihn tatsächlich braucht. Im Beispiel des Webshops bekommt die Suche eine eigene Komponente.
import { useState } from 'react';
import { SearchBar } from './SearchBar';
import { SearchResults } from './SearchResults';
export function SearchSection() {
const [searchQuery, setSearchQuery] = useState('');
return (
<section>
<SearchBar query={searchQuery} onChange={setSearchQuery} />
<SearchResults query={searchQuery} />
</section>
);
}
Tippt jemand, rendern nur noch SearchSection und ihre Kinder neu. Kopfzeile, Navigation und Produktraster bleiben unberührt, ganz ohne Memoisierung. Für viele Anwendungen ist diese strukturelle Änderung die wirkungsvollste Optimierung überhaupt.
Das Children-Muster für häufig wechselnden State
Manchmal lässt sich der State nicht nach unten verschieben, weil die besitzende Komponente auch umfangreiche Inhalte umschließt. Ein typisches Beispiel ist eine Fortschrittsanzeige, die bei jedem Scrollen aktualisiert wird. Hier hilft es, die schweren Inhalte als children von außen hineinzureichen.
import { useEffect, useState, type ReactNode } from 'react';
export function ScrollTracker({ children }: { children: ReactNode }) {
const [scrollY, setScrollY] = useState(0);
useEffect(() => {
const onScroll = () => setScrollY(window.scrollY);
window.addEventListener('scroll', onScroll, { passive: true });
return () => window.removeEventListener('scroll', onScroll);
}, []);
return (
<div>
<ScrollIndicator position={scrollY} />
{children}
</div>
);
}
function ScrollIndicator({ position }: { position: number }) {
return <div className="scroll-indicator">{Math.round(position)} px</div>;
}
Die children erzeugt die Elternkomponente, nicht der ScrollTracker. Ändert sich nur scrollY, bleibt das übergebene Element dasselbe Objekt, und React überspringt diesen Teilbaum. Auch das gelingt allein durch die Struktur des Codes.
Was der React Compiler übernimmt und was nicht
Jedes manuelle useMemo und useCallback ist wie eine Mautstation. Es kostet Speicher für den zwischengespeicherten Wert, bei jedem Rendern einen Vergleich der Abhängigkeiten und vor allem Aufmerksamkeit beim Lesen. Bei billigen Operationen, etwa dem Zusammensetzen von Vor- und Nachname, ist diese Maut teurer als die eingesparte Rechenarbeit.
Automatische Memoisierung beim Build
Der React Compiler ist ein Werkzeug, das Komponenten und Hooks beim Build analysiert und die Zwischenspeicherung selbst einfügt, und zwar feiner, als es von Hand praktikabel wäre. Das React-Team hat ihn im Oktober 2025 als stabile Version 1.0 veröffentlicht. Er ist kein fester Bestandteil von React, sondern ein Babel-Plugin (babel-plugin-react-compiler), das Sie im Build einbinden. Laut React-Team funktioniert er mit React 19 direkt und mit React 17 und 18 über ein zusätzliches Laufzeitpaket.
In Next.js lässt er sich ab Version 16 über eine Konfigurationsoption einschalten; das Babel-Plugin muss dafür als Entwicklungsabhängigkeit installiert sein.
// next.config.ts
import type { NextConfig } from 'next';
const nextConfig: NextConfig = {
reactCompiler: true,
};
export default nextConfig;
Für Vite-Projekte binden Sie den Compiler ab @vitejs/plugin-react 6 über das Paket @rolldown/plugin-babel und das mitgelieferte reactCompilerPreset ein; ältere Versionen des Vite-Plugins nehmen das Babel-Plugin direkt in ihren Babel-Optionen auf. Voraussetzung ist in jedem Fall, dass der Code die Regeln von React einhält: Komponenten müssen rein sein, also bei gleichen Eingaben das Gleiche liefern, und Props oder State dürfen nicht direkt verändert werden. Das ESLint-Plugin eslint-plugin-react-hooks enthält Regeln, die solche Verstöße anzeigen. Wo der Compiler unsicher ist, lässt er eine Komponente unverändert, statt sie falsch zu optimieren. Einzelne problematische Komponenten können Sie mit der Direktive 'use no memo' ausnehmen.
Wo Memoisierung von Hand bleibt
Es gibt weiterhin berechtigte Fälle für gezielte Eingriffe: sehr teure Berechnungen, etwa das Sortieren tausender Einträge bei jedem Rendern, Bibliotheken, die auf stabile Objektreferenzen angewiesen sind, und Effekt-Abhängigkeiten, bei denen eine instabile Referenz den Effekt ständig neu auslöst. In bestehendem Code mit Compiler sollten Sie vorhandenes useMemo nicht pauschal löschen, sondern erst nach Tests, denn manche Logik verlässt sich auf genau diese Stabilität.
Wichtig ist auch, was der Compiler nicht leistet. Er verkleinert kein Bundle, virtualisiert keine Listen und entzerrt keine Datenabfragen, die nacheinander statt parallel laufen. Wie sich Hooks und Memoisierung über die Jahre verändert haben, beschreibt der Beitrag Von React Hooks zu Server Components. Welche Folgen der Compiler für die Struktur größerer Anwendungen hat, ordnet React-Architektur: Komponenten, Zustand und Performance im Großen ein.
Die Überholspur: Transitions und zurückgestellte Werte
React kann Aktualisierungen nach Dringlichkeit sortieren. Diese sogenannten nebenläufigen Funktionen (Concurrent Features) gibt es seit React 18; sie gehören zu den am meisten unterschätzten Werkzeugen für flüssige Oberflächen.
useTransition für Aktualisierungen, die Sie selbst auslösen
Mit useTransition kennzeichnen Sie eine State-Änderung als nicht dringend. React zeigt die Eingabe dann sofort an und rendert die aufwendige Ergebnisliste im Hintergrund. Tippt jemand weiter, bevor die Liste fertig ist, bricht React das veraltete Rendern ab und beginnt mit dem neuen Wert.
import { useState, useTransition, type ChangeEvent } from 'react';
import { ProductList } from './ProductList';
export function ProductSearch() {
const [input, setInput] = useState('');
const [filter, setFilter] = useState('');
const [isPending, startTransition] = useTransition();
function handleChange(event: ChangeEvent<HTMLInputElement>) {
const value = event.target.value;
setInput(value); // dringend: das Eingabefeld reagiert sofort
startTransition(() => {
setFilter(value); // nicht dringend: die Liste darf warten
});
}
return (
<>
<input value={input} onChange={handleChange} />
<div style={{ opacity: isPending ? 0.6 : 1 }}>
<ProductList filter={filter} />
</div>
</>
);
}
Ein Detail entscheidet über den Erfolg: Die teure Arbeit muss im Rendern der Liste stecken, also in ProductList, die mit dem Filter rechnet und viele Einträge darstellt. Eine Berechnung, die Sie selbst in der Callback-Funktion von startTransition ausführen, läuft dagegen synchron und blockiert wie zuvor. Der Wert isPending liefert nebenbei einen Ladezustand, mit dem Sie die Liste während der Aktualisierung dezent abdunkeln können. Seit React 19 darf die Funktion in startTransition auch asynchron sein; React nennt solche Übergänge Actions und nutzt sie etwa für Formulare.
useDeferredValue für Werte, die von außen kommen
useDeferredValue hilft, wenn Sie die Aktualisierung nicht selbst auslösen, etwa weil der Wert als Prop von der Elternkomponente oder aus der URL kommt. React rendert dann zunächst mit dem alten Wert weiter und holt das Rendern mit dem neuen Wert im Hintergrund nach.
import { useDeferredValue } from 'react';
import { ProductList } from './ProductList';
export function Results({ query }: { query: string }) {
const deferredQuery = useDeferredValue(query);
const isStale = query !== deferredQuery;
return (
<div style={{ opacity: isStale ? 0.6 : 1 }}>
<ProductList filter={deferredQuery} />
</div>
);
}
Damit das wirkt, darf ProductList nicht bei jedem Rendern von Results ohnehin neu rendern. Mit dem React Compiler ist das automatisch gegeben, ohne ihn verpacken Sie die Liste in memo. Die Faustregel: useTransition, wenn Sie die Änderung selbst anstoßen; useDeferredValue, wenn der Wert von außen kommt.
Lange Listen: nur zeichnen, was sichtbar ist
Ein Kundenverzeichnis mit 20.000 Einträgen, ein Protokoll mit Tausenden Zeilen, eine Artikelliste im Shop-Backend: Hier hilft keine Memoisierung, denn schon das erste Rendern erzeugt zu viele DOM-Knoten. Der Browser muss sie anlegen, berechnen und zeichnen, und jede Interaktion wird träge.
Die Lösung heißt Virtualisierung, auch Windowing genannt. Die Liste rendert nur die Zeilen, die gerade im sichtbaren Bereich liegen, plus einen kleinen Puffer. Beim Scrollen tauscht sie die Inhalte aus. Verbreitete Bibliotheken dafür sind TanStack Virtual und react-window. Ein Beispiel mit TanStack Virtual:
import { useRef } from 'react';
import { useVirtualizer } from '@tanstack/react-virtual';
export function CustomerList({ customers }: { customers: string[] }) {
const parentRef = useRef<HTMLDivElement>(null);
const virtualizer = useVirtualizer({
count: customers.length,
getScrollElement: () => parentRef.current,
estimateSize: () => 40, // geschätzte Zeilenhöhe in Pixeln
overscan: 5, // Puffer ober- und unterhalb des sichtbaren Bereichs
});
return (
<div ref={parentRef} style={{ height: 600, overflow: 'auto' }}>
<div style={{ height: virtualizer.getTotalSize(), position: 'relative' }}>
{virtualizer.getVirtualItems().map((row) => (
<div
key={row.key}
style={{
position: 'absolute',
top: 0,
left: 0,
width: '100%',
height: row.size,
transform: `translateY(${row.start}px)`,
}}
>
{customers[row.index]}
</div>
))}
</div>
</div>
);
}
Statt 20.000 Zeilen liegen so nur einige Dutzend im DOM. Virtualisierung hat allerdings ihren Preis: Die Suche des Browsers per Tastenkürzel findet nur gerenderte Zeilen, und für Screenreader müssen Sie Rollen und Positionsangaben sorgfältig setzen. Für Listen mit einigen Hundert einfachen Einträgen lohnt sich der Aufwand meist nicht. Eine leichtere Alternative für lange, statische Seiten ist die CSS-Eigenschaft content-visibility: auto, mit der der Browser das Zeichnen von Bereichen außerhalb des sichtbaren Ausschnitts überspringt.
Weniger laden: Code-Splitting und Lazy Loading
Sie würden nicht jede Autobahnabfahrt gleichzeitig ausbauen, wenn die meisten Fahrer nur eine davon nutzen. Ebenso wenig muss der Browser die gesamte Anwendung laden, wenn jemand nur die Startseite aufruft. Code-Splitting teilt das JavaScript in Pakete (Chunks), die erst bei Bedarf nachgeladen werden. In React geht das mit lazy und Suspense:
import { lazy, Suspense } from 'react';
const Dashboard = lazy(() => import('./pages/Dashboard'));
export function App() {
return (
<Suspense fallback={<p>Dashboard wird geladen …</p>}>
<Dashboard />
</Suspense>
);
}
Der Code für Dashboard wird erst geladen, wenn die Komponente das erste Mal angezeigt wird. Frameworks wie Next.js teilen den Code automatisch nach Routen auf, sodass der Browser nur den Code für die aufgerufene Route lädt. Server Components gehen einen Schritt weiter: Sie laufen nur auf dem Server und schicken gar kein JavaScript für die betreffenden Bausteine an den Browser. Wie React 19 und Server Components zusammen mit Next.js 15 in die Praxis kamen, beschreibt der Rückblick Next.js 15 und React 19.
Teilen Sie nicht zu kleinteilig auf. Jede lazy-Grenze bedeutet eine zusätzliche Netzwerkanfrage und einen Ladezustand. Sinnvoll sind Routen und schwere Funktionsbereiche wie Diagramme, Editoren oder Kartenansichten, nicht einzelne Schaltflächen.
Erst messen, dann optimieren
Alle genannten Techniken helfen nur, wenn Sie den tatsächlichen Engpass kennen. Wer rät, optimiert häufig die falsche Stelle.
Profiler und Performance-Panel
Der Profiler in den React DevTools zeichnet auf, welche Komponenten bei einer Interaktion rendern, warum sie rendern und wie lange das dauert. Im Flame-Chart stehen die breitesten Balken für die teuersten Komponenten. Komponenten mit Renderzeiten unter einer Millisekunde sind selten das Problem. Interessant wird es, wenn ein einzelnes Rendern in die Nähe von 16 Millisekunden kommt, denn so lang ist bei 60 Bildern pro Sekunde ein ganzes Frame.
Ergänzend zeigt das Performance-Panel der Chrome DevTools sogenannte Long Tasks, also Aufgaben, die den Hauptthread länger als 50 Millisekunden blockieren. Seit React 19.2 erscheinen dort zusätzlich eigene React-Spuren, die zeigen, welche Arbeit React mit welcher Priorität erledigt. Messen Sie möglichst mit einem Produktions-Build und gedrosselter CPU, denn der Entwicklungsmodus ist deutlich langsamer und ein schneller Entwicklerrechner verdeckt Probleme, die auf Mittelklasse-Smartphones auffallen.
Core Web Vitals als Kompass
Für Nutzer:innen und für Google zählen drei Kennzahlen, die Google als Core Web Vitals zusammenfasst:
| Kennzahl | Was sie misst | Gut ist |
|---|---|---|
| LCP (Largest Contentful Paint) | wann der größte sichtbare Inhalt erscheint | höchstens 2,5 Sekunden |
| INP (Interaction to Next Paint) | wie schnell die Oberfläche auf Eingaben reagiert | höchstens 200 Millisekunden |
| CLS (Cumulative Layout Shift) | wie stark Inhalte beim Laden verrutschen | höchstens 0,1 |
Google bewertet dabei den Wert, den 75 Prozent der Seitenaufrufe erreichen. INP hat im März 2024 die ältere Kennzahl FID abgelöst und ist für React-Anwendungen besonders aufschlussreich, weil er blockierendes Rendern direkt abbildet. Ist der INP schlecht, helfen State-Colocation, Transitions und Virtualisierung. Ist der LCP schlecht, liegt die Ursache eher beim Laden: zu viel JavaScript, große Bilder, späte Datenabfragen. Labormessungen mit Lighthouse ersetzen dabei keine Felddaten echter Besucher, etwa aus dem Chrome UX Report oder einem eigenen Monitoring.
Fehlerquellen, die kein Compiler behebt
Einige Muster bremsen Anwendungen, unabhängig davon, ob der Compiler aktiv ist:
- Komponenten in Komponenten definieren. Steht eine Komponentenfunktion innerhalb einer anderen, entsteht bei jedem Rendern eine neue Funktion. React hält sie für einen anderen Komponententyp, baut den Teilbaum komplett neu auf und verliert dessen State.
- Instabile Schlüssel in Listen. Mit
Math.random()alskeybaut React jede Zeile bei jedem Rendern neu auf. Der Array-Index als Schlüssel führt bei sortier- oder filterbaren Listen dazu, dass Zustände wie Eingaben oder Aufklappzustände an der falschen Zeile hängen. Verwenden Sie stabile IDs aus den Daten. - Zu breit gefasster Context. Ändert sich der Wert eines Context-Providers, rendern alle Komponenten neu, die ihn lesen. Trennen Sie häufig wechselnde Werte von selten wechselnden, und legen Sie Werte und Setter-Funktionen in getrennte Contexts.
- Effektketten. Werte, die sich aus Props oder State ableiten lassen, berechnen Sie direkt beim Rendern, statt sie in einem Effekt in weiteren State zu kopieren. Für das Laden von Daten eignen sich Framework-Funktionen oder spezialisierte Bibliotheken wie TanStack Query besser als selbst gebaute Effekte.
- Wasserfälle beim Datenladen. Lädt jede Komponente ihre Daten erst, nachdem die übergeordnete fertig ist, addieren sich die Wartezeiten. Starten Sie unabhängige Abfragen parallel oder verlagern Sie sie auf den Server.
Was das für Ihr Team bedeutet
React-Performance ist heute weniger eine Frage von Spezialtricks als von Aufräumarbeit. Die größten Gewinne bringen fast immer strukturelle Entscheidungen: State am richtigen Ort, weniger JavaScript im Browser, virtualisierte Listen, parallele Datenabfragen. Der React Compiler nimmt Teams die mühsame Memoisierung weitgehend ab und ist für die meisten Projekte eine lohnende Umstellung, sofern der Code die Regeln von React einhält. Überschätzt wird er dort, wo Erwartungen an ihn als Allheilmittel entstehen: Ein aufgeblähtes Bundle bleibt aufgebläht.
Unsere Empfehlung: Messen Sie zuerst mit Profiler und Felddaten, beheben Sie den größten Engpass und messen Sie erneut. Aktivieren Sie den Compiler schrittweise, nehmen Sie die Lint-Warnungen ernst und entfernen Sie bestehende manuelle Memoisierung erst nach Tests. Wer Ladezeiten und Core Web Vitals systematisch angehen möchte, findet Hintergründe zu Beratung und Seminaren auf der Seite Web Performance optimieren sowie unter Web-Performance und Optimierung.
Häufige Fragen zur React-Performance
Sind useMemo und useCallback mit dem React Compiler noch nötig?
In neuem Code meist nicht. Der Compiler fügt die Memoisierung dort ein, wo sie nützt. Manuell greifen Sie nur ein, wenn eine Messung eine wirklich teure Berechnung zeigt oder eine Bibliothek stabile Referenzen verlangt. In bestehendem Code bleiben vorhandene Aufrufe zunächst stehen, bis Tests zeigen, dass sie entbehrlich sind.
Wann passt useTransition und wann useDeferredValue?
Entscheidend ist, wer die Aktualisierung auslöst. useTransition passt, wenn Sie die State-Änderung selbst anstoßen und als nicht dringend markieren. useDeferredValue passt, wenn der Wert von außen kommt, etwa als Prop, aus einem Context oder aus URL-Parametern, und Sie nur das Rendern mit dem neuen Wert verzögern wollen.
Ab wann lohnt sich Virtualisierung?
Eine feste Grenze gibt es nicht, sie hängt davon ab, wie aufwendig eine Zeile ist und auf welchen Geräten die Anwendung läuft. Ein guter Anhaltspunkt ist die Messung: Wenn das erste Rendern einer Liste spürbar dauert oder das Scrollen ruckelt, ist Virtualisierung der nächste Schritt. Bei wenigen Hundert schlichten Einträgen genügt meist eine normale Liste.
Wie lässt sich herausfinden, welche Komponente eine Anwendung ausbremst?
Zeichnen Sie die langsame Interaktion mit dem Profiler der React DevTools auf. Die breitesten Balken im Flame-Chart zeigen die teuersten Komponenten, ein Klick verrät den Grund für das Rendern. Das Performance-Panel von Chrome ergänzt das um Long Tasks, die den Hauptthread blockieren, und zeigt, ob die Zeit beim Rendern, bei Skripten von Drittanbietern oder beim Zeichnen verloren geht.
Kategorien
Schlagworte