Von React Hooks zu Server Components: Wohin sich React entwickelt

Abhängigkeitsarrays, Memoisierung, Effekte: Welche Hook-Probleme React heute selbst löst und welche bleiben
Aktualisiert:
Abstract
- #Frontend-Frameworks
- #React
- #React Hooks
- #Server Components
- #React Compiler
- #Webentwicklung
- #JavaScript
Sind Hooks ein Auslaufmodell? Was React Compiler, Server Components und Actions am Alltag ändern
Ein Formular in einer React-Anwendung, das ein Jahr lang gewachsen ist: drei useEffect-Aufrufe, die sich gegenseitig anstoßen, zwei useCallback-Hüllen, damit ein Kind nicht ständig neu rendert, und ein Kommentar „nicht anfassen, sonst Endlosschleife“. Viele Teams kennen solchen Code. Er ist der Grund, warum seit einigen Jahren regelmäßig Abgesänge auf React Hooks erscheinen.
Die Wirklichkeit ist unspektakulärer. Hooks sind nicht tot, und React plant auch nicht, sie abzuschaffen. Aber React hat mit Version 19 und dem React Compiler Werkzeuge bekommen, die viele der Aufgaben übernehmen, für die Teams früher Hooks von Hand verdrahten mussten. Dieser Text sortiert, welche Hook-Probleme real sind, was React selbst dagegen setzt und wo Alternativen aus anderen Frameworks wie Signals oder State Machines tatsächlich helfen.
Was mit Hooks gut lief und warum die Kritik trotzdem berechtigt ist
Hooks kamen im Februar 2019 mit React 16.8. Sie lösten ein echtes Problem: Zustand und Seiteneffekte waren vorher an Klassenkomponenten gebunden, zusammengehörige Logik lag verstreut in Methoden wie componentDidMount und componentDidUpdate, und Wiederverwendung gelang nur über umständliche Muster. Mit Hooks wurde Logik zu einer Funktion, die sich als eigener Hook herauslösen und teilen lässt. Das hat sich bewährt, und kein ernsthafter Vorschlag will dahinter zurück.
Die Grundlagen, also wie useState, useEffect und eigene Hooks funktionieren und welche Regeln gelten, erklärt unser Beitrag React Hooks: Grundlagen, Regeln und Performance-Optimierung. Hier geht es um die Frage, was sich an der Rolle der Hooks verschiebt.
Die Kritik zielt im Kern auf drei Stellen, an denen das Modell den Teams viel Disziplin abverlangt.
Abhängigkeitsarrays: Korrektheit von Hand
Jeder useEffect, useMemo und useCallback bekommt eine Liste der Werte, von denen er abhängt. Ist sie unvollständig, arbeitet der Code mit veralteten Werten. Ist sie zu großzügig oder enthält sie Objekte, die bei jedem Rendern neu entstehen, läuft der Effekt öfter als gedacht, im schlimmsten Fall in einer Schleife. Die ESLint-Regel exhaustive-deps hilft, aber sie erzwingt nur Vollständigkeit. Ob der Effekt überhaupt nötig ist, beantwortet sie nicht.
Memoisierung: Optimierung als Daueraufgabe
React rendert eine Komponente neu, wenn sich ihr Zustand ändert, und mit ihr standardmäßig alle Kinder. Damit teure Kinder nicht unnötig mitlaufen, gibt es React.memo, useMemo und useCallback. Das funktioniert nur, wenn die gesamte Kette stimmt: Eine einzige Funktion ohne useCallback oder ein Objekt, das bei jedem Rendern neu gebaut wird, hebelt die Optimierung aus. In der Praxis führt das zu zwei Extremen: Code, der alles vorsorglich memoisiert und dadurch schwer lesbar wird, oder Code, der gar nichts memoisiert und in großen Listen träge reagiert.
Effekte als Ersatz für Ereignisse und Berechnungen
Das häufigste Missverständnis ist, useEffect für Dinge zu nutzen, die keine Seiteneffekte sind. Ein typisches Beispiel ist abgeleiteter Zustand:
// Problematisch: zusätzlicher Zustand und ein Effekt, der ihn nachzieht
const [vollerName, setVollerName] = useState('');
useEffect(() => {
setVollerName(`${vorname} ${nachname}`);
}, [vorname, nachname]);
// Besser: direkt beim Rendern berechnen
const vollerName = `${vorname} ${nachname}`;
Die erste Variante rendert zweimal und zeigt kurz einen veralteten Wert. Ähnlich ist es, wenn ein Effekt auf eine Zustandsänderung wartet, um danach etwas zu senden, statt die Aktion direkt im Klick-Handler auszuführen. Die React-Dokumentation widmet diesem Muster ein eigenes Kapitel mit dem Titel „You Might Not Need an Effect“. Viele „Hook-Probleme“ sind in Wahrheit solche Effekte, die es nicht bräuchte.
Was nicht stimmt, ist die Behauptung, Hooks ließen sich schlecht testen. Mit der React Testing Library testen Teams Komponenten über ihr sichtbares Verhalten, eigene Hooks lassen sich mit renderHook isoliert prüfen. Schwer zu testen ist Code mit verketteten Effekten, und das liegt am Entwurf, nicht am Hook-Konzept.
Der React Compiler nimmt die Memoisierung ab
Die größte Entlastung kommt nicht von einer Alternative zu Hooks, sondern von React selbst. Der React Compiler ist ein Build-Werkzeug, das Komponenten und Hooks beim Übersetzen analysiert und die Memoisierung automatisch einfügt, feiner als es ein Mensch von Hand täte. Im Oktober 2025 erschien Version 1.0 als stabile Fassung. Er arbeitet mit React 19 und lässt sich laut Projektdokumentation über ein Zusatzpaket auch mit React 17 und 18 nutzen.
Für Teams heißt das: Neuer Code kann ohne useMemo und useCallback geschrieben werden, solange er die Regeln von React einhält, also Komponenten als reine Funktionen behandelt und Props und Zustand nicht direkt verändert. Bestehende Memoisierung muss nicht entfernt werden, der Compiler kommt damit zurecht. Wo er Code nicht sicher analysieren kann, überspringt er die Komponente, statt sie falsch zu optimieren.
Zusammen mit dem Compiler hat das Team die ESLint-Regeln erweitert. Das Plugin eslint-plugin-react-hooks meldet in seinen aktuellen Versionen nicht nur fehlende Abhängigkeiten, sondern auch Verstöße gegen die Regeln, die der Compiler voraussetzt. Ein sinnvoller Einstieg ist deshalb, zuerst die Lint-Regeln einzuschalten und die Meldungen abzuarbeiten. Danach lässt sich der Compiler schrittweise aktivieren, etwa erst für ein Verzeichnis.
Die Abhängigkeitsarrays von useEffect verschwinden dadurch nicht. Für den Sonderfall, dass ein Effekt den aktuellen Wert einer Variablen lesen soll, ohne bei ihrer Änderung neu zu starten, gibt es seit React 19.2 den Hook useEffectEvent. Angenommen, ein Chat-Raum soll beim Verbinden eine Benachrichtigung im aktuellen Farbschema zeigen: Der Raumwechsel soll neu verbinden, ein Wechsel des Farbschemas nicht.
import { useEffect, useEffectEvent } from 'react';
function ChatRaum({ raumId, farbschema }) {
// Liest immer das aktuelle Farbschema, löst den Effekt aber nicht aus
const beiVerbindung = useEffectEvent(() => {
zeigeHinweis('Verbunden', farbschema);
});
useEffect(() => {
const verbindung = verbinde(raumId);
verbindung.on('connected', () => beiVerbindung());
return () => verbindung.trennen();
}, [raumId]);
return <h2>Raum {raumId}</h2>;
}
Server Components holen das Datenladen aus dem Browser
Ein großer Teil der useEffect-Aufrufe in klassischen React-Anwendungen tut immer dasselbe: Daten laden, einen Ladezustand pflegen, einen Fehler abfangen, das Ergebnis anzeigen. React Server Components setzen hier an. Sie laufen nicht im Browser, sondern beim Build oder auf dem Server, dürfen asynchron sein und direkt auf Datenbank oder interne APIs zugreifen. Ihr Code landet nicht im JavaScript-Paket, das der Browser lädt.
// Server Component: kein useState, kein useEffect, kein Ladeflag
export default async function Bestellungen() {
const bestellungen = await db.bestellung.findMany({ take: 20 });
return (
<ul>
{bestellungen.map((b) => (
<li key={b.id}>{b.nummer}</li>
))}
</ul>
);
}
Server Components sind seit React 19 Teil der stabilen Version, praktisch nutzbar sind sie über ein Framework, das Bundler und Server mitbringt. Am verbreitetsten ist der App Router von Next.js. React Router bietet Server Components bislang nur als instabil gekennzeichnete Funktion, weitere Frameworks ziehen nach. Interaktive Teile bleiben Client Components, markiert mit 'use client', und dort gelten Hooks wie bisher. Server Components ersetzen Hooks also nicht, sie verkleinern den Bereich, in dem man sie braucht. Wie die Arbeitsteilung zwischen Server und Browser im Detail aussieht, beschreibt unser Beitrag React Server Components: Wie Server und Browser sich die Arbeit teilen.
Die Kehrseite: Wer Server Components einsetzt, betreibt wieder Code auf dem Server und muss ihn wie jede Serveranwendung pflegen. Im Dezember 2025 wurde eine kritische Sicherheitslücke in den Paketen bekannt, über die React Server Components mit dem Server kommunizieren. Sie erlaubte Angreifern, ohne Anmeldung Code auf dem Server auszuführen, und betraf auch Next.js. Für Teams ist das kein Argument gegen das Modell, aber eines dafür, Framework-Updates genauso ernst zu nehmen wie Updates des Backends.
Actions und use: weniger Zustand für Formulare und asynchrone Daten
Formulare waren eine der Hauptquellen für Hook-Wildwuchs: ein Zustand für die Eingaben, einer für „wird gesendet“, einer für Fehler, dazu ein Handler, der alles koordiniert. React 19 hat dafür Actions eingeführt, also asynchrone Funktionen, die React als Übergang behandelt und deren Lade- und Fehlerzustand es selbst verwaltet.
'use client';
import { useActionState } from 'react';
export function Newsletter({ anmelden }) {
// anmelden ist eine Server Function: async (vorher, formData) => Meldung
const [meldung, formAction, sendetGerade] = useActionState(anmelden, null);
return (
<form action={formAction}>
<input name="email" type="email" required />
<button disabled={sendetGerade}>Anmelden</button>
{meldung && <p>{meldung}</p>}
</form>
);
}
useActionState liefert das Ergebnis der letzten Ausführung und ein Flag für den laufenden Vorgang. Ergänzend gibt es useFormStatus für Kindkomponenten eines Formulars und useOptimistic, um eine Änderung sofort anzuzeigen, bevor der Server sie bestätigt. Auffällig ist: Das sind wieder Hooks. React ersetzt das Hook-Prinzip nicht, sondern liefert spezialisierte Hooks für Aufgaben, die Teams vorher aus useState und useEffect selbst zusammensetzen mussten.
Dasselbe gilt für use. Die Funktion liest den Wert eines Promise oder eines Context und darf, anders als Hooks, auch in Bedingungen und Schleifen aufgerufen werden. Solange das Promise noch läuft, zeigt die nächste Suspense-Grenze einen Platzhalter. Ladezustände werden damit deklarativ: Die Oberfläche beschreibt, was während des Wartens erscheint, statt ein Ladeflag zu pflegen. Wichtig ist, dass das Promise nicht bei jedem Rendern neu erzeugt wird. Es sollte aus einer Server Component, einem Cache oder einer Datenbibliothek kommen.
Signals und State Machines: Ideen von außerhalb
Wer über die Zukunft von Hooks schreibt, landet schnell bei Signals. Ein Signal ist ein Wertbehälter, der sich merkt, wer ihn liest. Ändert sich der Wert, aktualisiert das Framework gezielt die abhängigen Stellen, ohne ganze Komponenten neu auszuführen. SolidJS hat das Prinzip bekannt gemacht, Preact, Vue, Svelte mit seinen Runes und Angular nutzen es in eigenen Varianten. Für JavaScript selbst gibt es einen Vorschlag beim Standardisierungsgremium TC39, der sich noch in einem frühen Stadium befindet.
React verfolgt bewusst einen anderen Weg: Es rendert Komponenten neu und setzt auf den Compiler, um die Kosten dafür klein zu halten. Ein eingebautes Signal-Modell hat das React-Team nicht angekündigt. Das Paket @preact/signals-react bringt Signals zwar in React-Anwendungen, braucht dafür aber ein Babel-Plugin oder den Hook useSignals in jeder Komponente. Seine frühere automatische Variante, die sich in Reacts Interna einklinkte, wurde entfernt, weil sie mit React 19 nicht mehr funktionierte. Für die meisten Teams ist das ein Risiko bei jedem Update. Wenn feingranulare Reaktivität für ein Projekt entscheidend ist, spricht das eher für die Wahl eines Frameworks, das sie nativ mitbringt. Wie sich die Rendering-Modelle von React, Vue, Svelte und Solid unterscheiden, zeigt der Beitrag JavaScript-Frameworks und das DOM: Wie Rendering wirklich funktioniert.
State Machines sind dagegen keine Konkurrenz zu Hooks, sondern eine Art, Zustand zu modellieren. Statt mehrerer Flags wie isLoading, isError und isSuccess, die theoretisch gleichzeitig wahr sein können, beschreibt eine Zustandsmaschine eine endliche Menge von Zuständen und die erlaubten Übergänge. Bibliotheken wie XState setzen das um und werden in React über Hooks angebunden. Für Abläufe mit vielen Schritten, etwa einen mehrstufigen Bestellprozess oder einen Upload mit Wiederholungen, lohnt sich das. Für ein Suchfeld ist es zu viel Aufwand. Oft genügt schon ein einzelner Zustand mit einem Statusfeld statt vier Booleans.
Was bestehende Hook-Codebasen jetzt tun sollten
Ein Stopp für neue Hooks, wie ihn manche Abgesänge empfehlen, ergibt keinen Sinn: Client Components brauchen Hooks, auch mit Compiler und Server Components. Sinnvoll ist eine Reihenfolge, die mit kleinem Risiko beginnt.
- Effekte aufräumen. Abgeleiteten Zustand beim Rendern berechnen, Aktionen in Ereignis-Handler verlagern, Effekte nur für echte Synchronisation mit der Außenwelt nutzen, etwa Verbindungen, Timer oder Browser-APIs.
- Lint-Regeln aktualisieren. Die aktuellen Regeln von
eslint-plugin-react-hookszeigen, welcher Code die Voraussetzungen des Compilers verletzt. - React 19 und Compiler einführen. Erst das Upgrade, dann den Compiler schrittweise, begleitet von Tests und Messungen. Manuelle Memoisierung darf vorerst bleiben.
- Datenladen auslagern. Wo kein Framework mit Server Components im Einsatz ist, übernimmt eine Bibliothek wie TanStack Query Caching und Ladezustände. Selbstgeschriebene Lade-Effekte sind fast immer die schwächere Lösung.
- Server Components dort, wo die Architektur es hergibt. Für neue Projekte mit Next.js ist das der Standard. Bestehende Single-Page-Anwendungen müssen nicht umziehen, nur weil es die Technik gibt.
Wie Komponenten danach am besten Daten austauschen, also wann Props, Context, ein Store oder die URL der richtige Ort für einen Wert ist, behandelt unser Beitrag React-Komponenten verbinden: Welcher Weg passt wann?.
Einordnung: Hooks werden kleiner, nicht überflüssig
Die These vom Ende der Hooks verwechselt zwei Dinge. Das Hook-Prinzip, also Logik als Funktion, die React einer Komponente zuordnet, bleibt die Grundlage von React, und neue Funktionen wie useActionState, useOptimistic oder useEffectEvent kommen weiterhin als Hooks. Was schrumpft, ist der Anteil, den Teams von Hand verdrahten müssen: Memoisierung übernimmt der Compiler, Datenladen übernehmen Server Components oder Datenbibliotheken, Formularzustand übernehmen Actions.
Für Entscheider heißt das: Eine bestehende React-Codebasis ist kein Altlastenproblem, nur weil sie viele Hooks enthält. Problematisch sind verkettete Effekte und unklare Zuständigkeiten, und die lassen sich schrittweise beheben. Überschätzt wird der Druck, sofort auf Server Components umzusteigen. Unterschätzt wird der Gewinn, den schon das Aufräumen von Effekten und die Einführung des Compilers bringen.
Für Entwickler:innen verschiebt sich das gefragte Wissen. Wer erklären kann, wann ein Effekt nötig ist, welche Komponente auf dem Server und welche im Browser laufen sollte und welche Regeln der Compiler voraussetzt, ist besser aufgestellt als jemand, der ausgefeilte Memoisierungstricks beherrscht. Wenn Ihr Team eine bestehende Anwendung auf React 19 und den Compiler umstellen oder Server Components einführen möchte, unterstützen wir mit Beratung, Coaching und Seminaren zu React.
Häufige Fragen zu Hooks, Compiler und Server Components
Werden React Hooks abgeschafft?
Nein. Es gibt keine Ankündigung des React-Teams, Hooks zu entfernen oder abzukündigen. Neue Funktionen wie useActionState, useOptimistic und useEffectEvent sind selbst Hooks. Klassenkomponenten funktionieren übrigens ebenfalls weiterhin.
Lassen sich useMemo und useCallback mit dem React Compiler streichen?
In neuem Code können Sie darauf verzichten. Bestehende Aufrufe lassen sich entfernen, aber das sollte mit Tests geschehen, denn manche Memoisierung sichert auch das Verhalten von Effekten ab, die von einer stabilen Referenz abhängen. Es gibt keinen Zwang, sie zu löschen.
Setzen Server Components Next.js voraus?
Sie brauchen ein Framework oder ein Bundler-Setup, das Server Components unterstützt. Next.js mit dem App Router ist die verbreitetste Lösung, andere Frameworks bieten eigene Ansätze. In einer reinen Single-Page-Anwendung ohne Server gibt es keine Server Components, wohl aber Actions, use und den Compiler.
Lohnen sich Signals in einer React-Anwendung?
Selten. Signals spielen ihre Stärke in Frameworks aus, die darauf aufbauen. In React kämpfen sie gegen das Rendering-Modell der Bibliothek. Wer gezielte Updates in einer React-App braucht, erreicht mit dem Compiler, sauber geschnittenen Komponenten und einem Store mit Selektoren meist dasselbe.
Kategorien
Schlagworte