Haeufige React.js Fehler, die Einsteiger vermeiden sollten

Wer mit React beginnt, macht Fehler. Das ist normal, das ist menschlich, und das ist eigentlich ein gutes Zeichen, denn es bedeutet, dass man aktiv baut und ausprobiert, anstatt nur Tutorials zu schauen. Das Problem ist nicht, ob man Fehler macht, sondern ob man dieselben Fehler immer wieder macht, ohne zu verstehen, warum sie auftreten.

React hat eine Reihe von Konzepten, die auf den ersten Blick logisch erscheinen, aber im Verborgenen anders funktionieren als erwartet. Der direkt veraenderte State, der vergessene key-Prop, der useEffect, der sich unendlich oft aufruft: Diese Probleme begegnen praktisch jeder Entwicklerin und jedem Entwickler in den ersten Wochen mit React. Die gute Nachricht ist, dass sie alle erklaerbar und vermeidbar sind, sobald man versteht, was React intern wirklich tut.

In diesem Artikel gehen wir die haeufigsten React-Fehler durch, erklaeren, warum sie entstehen, zeigen konkrete Codebeispiele und beschreiben, wie man es besser macht. Der Artikel richtet sich an Einsteigerinnen und Einsteiger, die bereits erste Schritte mit React gegangen sind und nun ihre Grundlagen festigen wollen.

Fehler 1: State direkt veraendern statt eine Kopie zu erstellen

Das ist mit Abstand der haeufigste Fehler bei React-Anfaengerinnen und -Anfaengern, und gleichzeitig einer der am schwierigsten zu erkennenden, weil er manchmal funktioniert, meistens aber zu unvorhersehbarem Verhalten fuehrt.

Das Problem

React weiss nur dann, dass es eine Komponente neu rendern soll, wenn es erkennt, dass sich der State veraendert hat. Diese Erkennung erfolgt durch einen einfachen Referenzvergleich: React prueft, ob die neue State-Referenz eine andere ist als die alte. Wenn man ein Array oder Objekt direkt veraendert und dann dieselbe Referenz an setState uebergibt, sieht React keinen Unterschied und rendert die Komponente nicht neu.

// Falsch: Das Array wird direkt veraendert
const [aufgaben, setAufgaben] = useState(['Einkaufen', 'Kochen']);

function aufgabeHinzufuegen(text) {
  aufgaben.push(text); // Direktes Veraendern des State-Arrays
  setAufgaben(aufgaben); // Dieselbe Referenz wird uebergeben
}

// Richtig: Ein neues Array wird erstellt
function aufgabeHinzufuegen(text) {
  setAufgaben([...aufgaben, text]); // Neues Array mit Spread-Operator
}

Dasselbe gilt fuer Objekte im State:

// Falsch
const [benutzer, setBenutzer] = useState({ name: 'Anna', alter: 28 });

function alterAendern(neuesAlter) {
  benutzer.alter = neuesAlter; // Direktes Veraendern
  setBenutzer(benutzer); // Dieselbe Referenz
}

// Richtig
function alterAendern(neuesAlter) {
  setBenutzer({ ...benutzer, alter: neuesAlter }); // Neues Objekt
}

Die Regel dahinter

State in React ist unveraenderlich (immutable). Das bedeutet nicht, dass man State-Werte nie aendern darf, sondern dass man immer einen neuen Wert erstellen muss, anstatt den bestehenden zu modifizieren. Arrays und Objekte sind in JavaScript Referenztypen. Wenn man sie "veraendert", zeigt die Variable weiterhin auf dasselbe Objekt im Speicher. React erkennt keine Aenderung und tut nichts.

Also Read: Wie man seine erste React.js App Schritt fuer Schritt erstellt

Fehler 2: Den key-Prop in Listen weglassen oder falsch setzen

Wenn man eine Liste von Komponenten rendert, erwartet React fuer jedes Element einen eindeutigen key-Prop. Viele Anfaengerinnen und Anfaenger ignorieren die Warnung in der Konsole oder verwenden den Index des Arrays als key. Beides fuehrt zu Problemen.

Das Problem mit fehlendem key

// Warnung in der Konsole: "Each child in a list should have a unique key prop"
function Produktliste({ produkte }) {
  return (
    <ul>
      {produkte.map((produkt) => (
        <li>{produkt.name}</li> // Kein key-Prop
      ))}
    </ul>
  );
}

Das Problem mit dem Index als key

// Funktioniert auf den ersten Blick, fuehrt aber zu Fehlern
{produkte.map((produkt, index) => (
  <li key={index}>{produkt.name}</li>
))}

Der Index als key ist problematisch, sobald sich die Reihenfolge der Liste aendern kann, zum Beispiel wenn Elemente geloescht, hinzugefuegt oder sortiert werden. React verwendet den key, um Listenelemente zwischen Renders zuzuordnen. Wenn der key sich durch eine Umordnung aendert, kann React die falschen Elemente miteinander verbinden und zum Beispiel den State eines Eingabefeldes der falschen Listenkarte zuordnen.

Die richtige Loesung

// Stabile, eindeutige IDs aus den Daten verwenden
{produkte.map((produkt) => (
  <li key={produkt.id}>{produkt.name}</li>
))}

Die ID sollte aus den Daten selbst kommen, etwa die Datenbankid, eine UUID oder ein anderer stabiler, eindeutiger Bezeichner. Falls keine ID vorhanden ist, kann man beim Erstellen der Daten eine generieren, zum Beispiel mit crypto.randomUUID() oder einer entsprechenden Bibliothek wie uuid.

Fehler 3: useEffect falsch oder ohne Abhaengigkeiten verwenden

useEffect ist einer der maechtigsten, aber auch am haeufigsten falsch verwendeten Hooks in React. Die Fehler dabei sind vielschichtig.

Endlosschleife durch fehlende oder falsche Abhaengigkeiten

// Gefaehrlich: Dieser Effect laeuft nach jedem einzelnen Render
useEffect(() => {
  fetch('/api/daten')
    .then((res) => res.json())
    .then((daten) => setDaten(daten));
}); // Kein Abhaengigkeits-Array!

Ohne das zweite Argument (das Abhaengigkeits-Array) wird useEffect nach jedem Render ausgefuehrt. Da setDaten einen neuen Render ausloest, entsteht eine Endlosschleife: Effect laeuft, State aendert sich, Komponente rendert neu, Effect laeuft wieder, und so weiter, unendlich.

// Richtig: Leeres Array bedeutet "nur einmal beim ersten Render"
useEffect(() => {
  fetch('/api/daten')
    .then((res) => res.json())
    .then((daten) => setDaten(daten));
}, []); // Leeres Array als zweites Argument

Veraltete Werte durch fehlende Abhaengigkeiten

// Fehler: zaehler wird im Effect verwendet, fehlt aber im Abhaengigkeits-Array
const [zaehler, setZaehler] = useState(0);

useEffect(() => {
  const interval = setInterval(() => {
    console.log(zaehler); // Gibt immer 0 aus, nie den aktuellen Wert
  }, 1000);
  return () => clearInterval(interval);
}, []); // zaehler fehlt hier

// Richtig
useEffect(() => {
  const interval = setInterval(() => {
    console.log(zaehler);
  }, 1000);
  return () => clearInterval(interval);
}, [zaehler]); // zaehler als Abhaengigkeit angeben

Wenn eine Variable im Effect-Callback verwendet wird, aber nicht im Abhaengigkeits-Array steht, hat der Effect immer den Wert der Variable zum Zeitpunkt seiner Erstellung. Das nennt sich Closure-Problem oder "stale closure". ESLint mit dem Plugin eslint-plugin-react-hooks warnt automatisch davor und ist deshalb fuer jedes React-Projekt unbedingt empfehlenswert.

Vergessene Aufraeumfunktion

// Problem: Event-Listener wird nicht entfernt
useEffect(() => {
  window.addEventListener('resize', handleResize);
  // Kein return!
}, []);

// Richtig: Aufraeumfunktion zurueckgeben
useEffect(() => {
  window.addEventListener('resize', handleResize);
  return () => {
    window.removeEventListener('resize', handleResize);
  };
}, []);

Wenn ein Effect Abonnements erstellt, Event-Listener hinzufuegt oder Timers startet, muss er auch eine Aufraeumfunktion zurueckgeben. Andernfalls haeufen sich diese Ressourcen ueber mehrere Renders hinweg an und fuehren zu Speicherlecks.

Also Read: Was ist React.js und warum ist es 2026 so beliebt?

Fehler 4: State-Updates als synchron behandeln

Ein Missverstaendnis, das viele Anfaengerinnen und Anfaenger haben: State-Updates in React sind asynchron. Das heisst, nach dem Aufruf von setState hat die State-Variable nicht sofort den neuen Wert.

const [zaehler, setZaehler] = useState(0);

function dreimalErhoehen() {
  setZaehler(zaehler + 1); // zaehler ist noch 0
  setZaehler(zaehler + 1); // zaehler ist immer noch 0
  setZaehler(zaehler + 1); // zaehler ist immer noch 0
  // Ergebnis: zaehler wird auf 1 gesetzt, nicht auf 3
}

React batched mehrere State-Updates, die im selben Event-Handler aufgerufen werden. Alle drei setZaehler-Aufrufe basieren auf demselben alten Wert von zaehler, naemlich 0. Das Ergebnis ist 1, nicht 3.

Die Loesung: Die Updater-Funktion verwenden

function dreimalErhoehen() {
  setZaehler((aktuell) => aktuell + 1);
  setZaehler((aktuell) => aktuell + 1);
  setZaehler((aktuell) => aktuell + 1);
  // Ergebnis: zaehler wird auf 3 gesetzt
}

Die Updater-Funktion erhaelt immer den aktuellsten State-Wert als Argument, auch wenn mehrere Updates im selben Rendering-Zyklus gestapelt werden. Wenn ein neuer State-Wert vom vorherigen State abhaengt, sollte man immer diese Form verwenden.

Fehler 5: Komponenten zu gross werden lassen

Viele Anfaengerinnen und Anfaenger beginnen mit einer einzelnen grossen Komponente und fuegen immer mehr Logik hinzu, bis die Datei 500 Zeilen oder mehr lang ist. Das macht den Code schwer lesbar, schwer testbar und schwer wartbar.

Das Zeichen, dass eine Komponente aufgeteilt werden sollte

• Die Komponente hat mehr als 200 bis 300 Zeilen Code.
• Die JSX-Struktur ist tief verschachtelt und schwer zu lesen.
• Teile der Komponente koennten an anderer Stelle wiederverwendet werden.
• Die Komponente hat mehrere klar voneinander getrennte Verantwortlichkeiten.
• Das Verfolgen, welcher State welchen Teil des Renderings beeinflusst, faellt schwer.

Wie man aufteilt

// Vorher: Alles in einer Komponente
function ProduktSeite() {
  // Navigations-Logik
  // Produkt-Filter-Logik
  // Warenkorb-Logik
  // 400 Zeilen JSX...
}

// Nachher: Aufgeteilt in fokussierte Komponenten
function ProduktSeite() {
  return (
    <div>
      <Navigation />
      <ProduktFilter />
      <ProduktListe />
      <Warenkorb />
    </div>
  );
}

Jede Komponente sollte eine klare, einzelne Verantwortlichkeit haben. Das Single-Responsibility-Prinzip gilt in React genau so stark wie in jedem anderen Bereich der Softwareentwicklung.

Fehler 6: Prop-Drilling ignorieren statt Context oder State-Management zu verwenden

Prop-Drilling bezeichnet das Weiterreichen von Props durch mehrere Komponentenebenen hindurch, auch durch Komponenten, die diese Props selbst gar nicht benoetigen, nur um sie an eine tiefer liegende Komponente zu uebergeben.

// Prop-Drilling: benutzer wird durch alle Ebenen durchgereicht
function App() {
  const [benutzer, setBenutzer] = useState({ name: 'Anna' });
  return <Seite benutzer={benutzer} />;
}

function Seite({ benutzer }) {
  return <Inhalt benutzer={benutzer} />; // Seite braucht benutzer nicht selbst
}

function Inhalt({ benutzer }) {
  return <Header benutzer={benutzer} />; // Inhalt braucht benutzer auch nicht
}

function Header({ benutzer }) {
  return <h1>Hallo, {benutzer.name}</h1>; // Erst hier wird es benutzt
}

Das wird schnell unhandlich und fehleranfaellig, vor allem wenn Props umbenannt oder entfernt werden sollen.

Die Loesung: React Context

const BenutzerContext = React.createContext(null);

function App() {
  const [benutzer] = useState({ name: 'Anna' });
  return (
    <BenutzerContext.Provider value={benutzer}>
      <Seite />
    </BenutzerContext.Provider>
  );
}

function Header() {
  const benutzer = useContext(BenutzerContext);
  return <h1>Hallo, {benutzer.name}</h1>;
}

Context ist ideal fuer Daten, die viele Komponenten in einem Teilbaum benoetigen, wie Benutzerinformationen, Theme oder Spracheinstellungen. Fuer komplexere State-Anforderungen koennen Zustand, Jotai oder Redux die bessere Wahl sein.

Fehler 7: Zu viele Re-Renders nicht erkennen oder ignorieren

Jedes Mal, wenn der State oder Props einer Komponente sich aendern, rendert React die Komponente neu. Das ist das gewollte Verhalten. Aber manchmal werden Komponenten oefters neu gerendert als noetig, was die Performance der Anwendung beeinflusst.

Neue Objekte und Funktionen in JSX erstellen

// Problem: Jedes Render erstellt ein neues style-Objekt
function KomponenteMitProblem() {
  return (
    <KindKomponente style={{ color: 'red', fontWeight: 'bold' }} />
    // Dieses Objekt ist bei jedem Render neu - neue Referenz!
  );
}

// Besser: Stil ausserhalb der Render-Funktion definieren
const textStil = { color: 'red', fontWeight: 'bold' };

function KomponenteOhneProblem() {
  return <KindKomponente style={textStil} />;
}

Dasselbe gilt fuer Funktionen, die in JSX inline definiert werden. Mit useCallback koennen Funktionen zwischen Renders stabil gehalten werden, und mit useMemo koennen teure Berechnungen gecacht werden.

React DevTools fuer Performance-Analyse nutzen

Die React Developer Tools, eine Browser-Erweiterung fuer Chrome und Firefox, enthalten einen Profiler, der genau zeigt, welche Komponenten wann und warum neu gerendert werden. Das ist das wichtigste Werkzeug zur Diagnose von Rendering-Problemen.

Fehler 8: useEffect fuer Dinge verwenden, die keinen Effect benoetigen

useEffect ist fuer Seiteneffekte gedacht: Dinge, die ausserhalb des React-Render-Zyklus passieren, wie API-Aufrufe, Event-Listener, Timer oder direkte DOM-Manipulation. Viele Anfaengerinnen und Anfaenger verwenden useEffect jedoch auch fuer Berechnungen, die direkt von vorhandenem State oder Props abhaengen, was unnoetig ist.

// Unnoetig: useEffect fuer abgeleiteten State
const [vorname, setVorname] = useState('');
const [nachname, setNachname] = useState('');
const [vollname, setVollname] = useState('');

useEffect(() => {
  setVollname(`${vorname} ${nachname}`);
}, [vorname, nachname]);

// Besser: Direkt aus bestehendem State ableiten
const vollname = `${vorname} ${nachname}`;

Wenn ein Wert direkt aus anderen State-Variablen oder Props berechnet werden kann, braucht er keinen eigenen State und keinen useEffect. Er sollte einfach waehrend des Renderings berechnet werden. Das macht den Code kueerzer, einfacher zu verstehen und vermeidet einen zusaetzlichen Rendering-Zyklus.

Fehler 9: Komponenten innerhalb anderer Komponenten definieren

Ein Fehler, den man seltener in Tutorials sieht, der aber in der Praxis vorkommt: neue Komponenten innerhalb des Funktionsrumpfs einer anderen Komponente zu definieren.

// Falsch: InnerKomponente wird bei jedem Render neu erstellt
function AussereKomponente() {
  const [wert, setWert] = useState('');

  // Diese Komponente ist bei jedem Render eine komplett neue Funktion
  function InnerKomponente() {
    return <p>Hallo</p>;
  }

  return <InnerKomponente />;
}

// Richtig: Auf oberster Ebene definieren
function InnerKomponente() {
  return <p>Hallo</p>;
}

function AussereKomponente() {
  const [wert, setWert] = useState('');
  return <InnerKomponente />;
}

Wenn eine Komponente innerhalb einer anderen definiert wird, erstellt React bei jedem Render eine neue Version dieser inneren Komponente. React sieht sie als komplett neue Komponente und kann nichts optimieren oder wiederverwenden. Das fuehrt zu unnoetigem Unmounting und Remounting des DOM-Elements und kann auch State-Verlust in der inneren Komponente verursachen.

Fehler 10: Fehlende Fehlerbehandlung bei asynchronen Operationen

API-Aufrufe und andere asynchrone Operationen koennen fehlschlagen. Viele Anfaengerinnen und Anfaenger vergessen, Fehlerfaelle zu behandeln, was dazu fuehrt, dass die Anwendung bei einem Netzwerkfehler einfach nichts anzeigt oder in einem Ladezustand haengen bleibt.

// Unvollstaendig: Kein Fehlerhandling
function DatenKomponente() {
  const [daten, setDaten] = useState(null);
  const [laedt, setLaedt] = useState(true);

  useEffect(() => {
    fetch('/api/daten')
      .then((res) => res.json())
      .then((daten) => {
        setDaten(daten);
        setLaedt(false);
      });
      // Was passiert, wenn fetch fehlschlaegt?
  }, []);

  if (laedt) return <p>Laedt...</p>;
  return <p>{daten.titel}</p>;
}

// Vollstaendig: Mit Fehlerbehandlung
function DatenKomponente() {
  const [daten, setDaten] = useState(null);
  const [laedt, setLaedt] = useState(true);
  const [fehler, setFehler] = useState(null);

  useEffect(() => {
    fetch('/api/daten')
      .then((res) => {
        if (!res.ok) throw new Error('Serverantwort fehlerhaft');
        return res.json();
      })
      .then((daten) => {
        setDaten(daten);
        setLaedt(false);
      })
      .catch((err) => {
        setFehler(err.message);
        setLaedt(false);
      });
  }, []);

  if (laedt) return <p>Laedt...</p>;
  if (fehler) return <p>Fehler: {fehler}</p>;
  return <p>{daten.titel}</p>;
}

Fehler 11: Keine Nutzung von TypeScript

Viele Anfaengerinnen und Anfaenger beginnen mit reinem JavaScript, weil es weniger Schreibaufwand zu erfordern scheint. Auf kurze Sicht mag das stimmen. Auf mittlere und lange Sicht ist das Fehlen von TypeScript einer der haeufigsten Gruende fuer schwer zu findende Bugs in React-Anwendungen.

TypeScript hilft dabei:

• Falsch uebergebene Props sofort zu erkennen, bevor die Anwendung ueberhaupt ausgefuehrt wird.
• Tippfehler in Prop-Namen und Funktionsaufrufen aufzudecken.
• Bessere IDE-Unterstuetzung mit Autovervollstaendigung und Inline-Dokumentation zu erhalten.
• Refactoring deutlich sicherer zu machen, da TypeScript auf alle betroffenen Stellen hinweist.

// Ohne TypeScript: Kein Hinweis, wenn ein falscher Prop-Typ uebergeben wird
function Benutzercard({ name, alter }) {
  return <p>{name} ist {alter} Jahre alt</p>;
}

// Irgendwo im Code:
<Benutzercard name="Anna" alter="achtundzwanzig" /> // String statt Zahl - kein Fehler

// Mit TypeScript: Sofortiger Fehler
interface BenutzercardProps {
  name: string;
  alter: number;
}

function Benutzercard({ name, alter }: BenutzercardProps) {
  return <p>{name} ist {alter} Jahre alt</p>;
}

// Compilerfehler: "achtundzwanzig" ist kein number
<Benutzercard name="Anna" alter="achtundzwanzig" />

Fehler 12: Zugriff auf Werte eines kontrollierten Eingabefelds ohne onChange

In React gibt es zwei Arten von Eingabefeldern: unkontrollierte (der Browser verwaltet den Wert) und kontrollierte (React verwaltet den Wert ueber State). Wenn man ein Eingabefeld mit einem value-Prop versieht, aber keinen onChange-Handler angibt, bekommt man eine Warnung und ein Eingabefeld, das sich nicht tippen laesst.

// Falsch: value ohne onChange macht das Feld schreibgeschuetzt
function EingabeFormular() {
  const [text, setText] = useState('');
  return <input value={text} />; // Nicht tippbar, Warnung in der Konsole
}

// Richtig: value mit onChange
function EingabeFormular() {
  const [text, setText] = useState('');
  return (
    <input
      value={text}
      onChange={(e) => setText(e.target.value)}
    />
  );
}

Wenn man den Wert eines Eingabefelds nicht ueber State verwalten moechte, sollte man defaultValue statt value verwenden. Dann ist das Feld unkontrolliert und der Browser verwaltet den Wert selbst.

Fehler 13: Fehlende Ladezeiten und Skeleton-States

Eine Anwendung, die waehrend eines API-Aufrufs einfach nichts anzeigt, wirkt kaputt. Nutzerinnen und Nutzer wissen nicht, ob etwas passiert oder ob ein Fehler vorliegt. Das Anzeigen eines Ladezustands ist kein optionales Extra, sondern ein wesentlicher Teil einer guten Nutzungserfahrung.

function ProduktListe() {
  const [produkte, setProdukte] = useState([]);
  const [laedt, setLaedt] = useState(true);

  // ... Datenladen in useEffect

  if (laedt) {
    return <p>Produkte werden geladen...</p>;
    // Noch besser: Skeleton-UI anzeigen
  }

  return (
    <ul>
      {produkte.map((p) => <li key={p.id}>{p.name}</li>)}
    </ul>
  );
}

Fuer professionelle Anwendungen empfiehlt sich eine sogenannte Skeleton-UI: Platzhalterelemente in der Form des eigentlichen Inhalts, die den Bereich ausfuellen, waehrend die Daten laden. Das verbessert die wahrgenommene Ladegeschwindigkeit erheblich und gibt Nutzerinnen und Nutzern ein Gefuehl von Stabilitaet.

Fehler 14: Keine Verwendung von React DevTools

React Developer Tools ist eine Browser-Erweiterung fuer Chrome und Firefox, die die Entwicklung mit React erheblich einfacher macht. Viele Anfaengerinnen und Anfaenger debuggen React-Anwendungen ausschliesslich mit console.log, was zeitaufwaendig und oft unbefriedigend ist.

React DevTools ermoeglicht:

• Den aktuellen State und die Props jeder Komponente im Komponentenbaum einzusehen.
• State-Werte direkt in den DevTools zu veraendern, ohne Code zu aendern.
• Den Profiler zu verwenden, um herauszufinden, welche Komponenten wann und warum neu gerendert werden.
• Den Komponentenbaum zu durchsuchen und einzelne Komponenten zu inspizieren.

Die Erweiterung ist kostenlos und sollte auf jedem Rechner installiert sein, auf dem React-Entwicklung stattfindet.

Fehler 15: Hooks ausserhalb von Komponenten oder in Schleifen verwenden

React hat eine klare Regel fuer Hooks: Sie duerfen nur auf der obersten Ebene einer Komponente aufgerufen werden, niemals in Schleifen, Bedingungen oder verschachtelten Funktionen. Diese Regel existiert, weil React die Reihenfolge der Hook-Aufrufe verwendet, um sie zwischen Renders zuzuordnen.

// Falsch: Hook in einer Bedingung
function MeineKomponente({ zeigeDaten }) {
  if (zeigeDaten) {
    const [daten, setDaten] = useState([]); // Hook in if-Block - verboten!
  }
}

// Falsch: Hook in einer Schleife
function MeineKomponente({ eintraege }) {
  for (const eintrag of eintraege) {
    const [wert, setWert] = useState(eintrag.wert); // Hook in Schleife - verboten!
  }
}

// Richtig: Hooks immer auf oberster Ebene
function MeineKomponente({ zeigeDaten, eintraege }) {
  const [daten, setDaten] = useState([]);
  const [werte, setWerte] = useState(eintraege.map((e) => e.wert));
  // ...
}

Fehler 16: Formular-Handling verkomplizieren

Formulare sind in React ein Bereich, in dem Anfaengerinnen und Anfaenger oft unnoetig viel State und viel Code produzieren. Fuer jedes Eingabefeld eine eigene useState-Variable anlegen wird schnell unhandlich.

// Umstaendlich fuer groessere Formulare
const [vorname, setVorname] = useState('');
const [nachname, setNachname] = useState('');
const [email, setEmail] = useState('');
const [telefon, setTelefon] = useState('');

// Besser: Ein State-Objekt fuer alle Felder
const [formular, setFormular] = useState({
  vorname: '',
  nachname: '',
  email: '',
  telefon: '',
});

function feldAendern(e) {
  const { name, value } = e.target;
  setFormular((aktuell) => ({ ...aktuell, [name]: value }));
}

// Im JSX:
<input name="vorname" value={formular.vorname} onChange={feldAendern} />
<input name="nachname" value={formular.nachname} onChange={feldAendern} />

Fuer komplexere Formulare mit Validierung lohnt sich der Einsatz einer Bibliothek wie React Hook Form. Diese Bibliothek reduziert die Menge an Code fuer Formular-Handling drastisch und bietet gleichzeitig hervorragende Unterstuetzung fuer Validierung und Fehleranzeige.

Fehler 17: Vergessen, dass Rendering seiteneffektfrei sein sollte

Die Render-Funktion einer React-Komponente sollte eine reine Funktion sein: Fuer dieselben Props und denselben State sollte sie immer dasselbe Ergebnis liefern und keine Seiteneffekte haben. Das bedeutet: kein Veraendern externer Variablen, kein Aufrufen von APIs, kein Schreiben in localStorage waehrend des Renderings.

// Falsch: Seiteneffekt direkt im Render
function Zaehler({ wert }) {
  localStorage.setItem('zaehler', wert); // Seiteneffekt im Render!
  return <p>{wert}</p>;
}

// Richtig: Seiteneffekt in useEffect
function Zaehler({ wert }) {
  useEffect(() => {
    localStorage.setItem('zaehler', wert);
  }, [wert]);
  return <p>{wert}</p>;
}

In React 18 und im Strict Mode fuehrt React Komponenten im Entwicklungsmodus absichtlich zweimal aus, um genau solche Seiteneffekte im Render aufzudecken. Wenn man seltsame doppelte API-Aufrufe oder doppelte Log-Ausgaben sieht, ist das oft der Grund.

Eine Uebersicht aller Fehler und ihrer Loesung

Fehler	Ursache	Loesung
State direkt veraendern	JavaScript Referenztypen missvestanden	Immer neue Kopie erstellen (Spread, map, filter)
Fehlender oder falscher key	key-Prop ignoriert oder Index verwendet	Stabile eindeutige ID aus Daten verwenden
useEffect Endlosschleife	Abhaengigkeits-Array fehlt	Korrektes Abhaengigkeits-Array angeben
Veraltete Werte in useEffect	Stale Closure durch fehlende Abhaengigkeit	Alle verwendeten Variablen ins Abhaengigkeits-Array
State-Updates als synchron	Asynchrones Batching nicht bekannt	Updater-Funktion verwenden
Zu grosse Komponenten	Kein Refactoring durchgefuehrt	In kleinere, fokussierte Komponenten aufteilen
Prop-Drilling	Context nicht genutzt	React Context oder State-Management-Bibliothek
Hooks in Schleifen oder if	Hooks-Regeln nicht bekannt	Hooks immer auf oberster Komponentenebene
Keine Fehlerbehandlung bei Fetch	Nur Erfolgsfall beachtet	catch-Block und Fehlerzustand hinzufuegen
Komponente in Komponente definiert	Struktur unklar	Immer auf Modulebene definieren

Haeufig gestellte Fragen zu React.js Fehlern

Warum rendert meine Komponente, obwohl sich der State nicht geaendert hat?

Das passiert haeufig, wenn Props Objekte oder Arrays sind, die bei jedem Render neu erstellt werden. Obwohl der Inhalt derselbe ist, ist die Referenz eine neue. React vergleicht nur die Referenzen, nicht die Inhalte. Loesung: Objekte und Arrays ausserhalb des Renderings definieren oder useMemo verwenden, um sie zu stabilen Referenzen zu machen.

Warum laeuft mein useEffect zweimal beim Start?

Im React-Strict-Mode, der in Entwicklung standardmaessig aktiv ist, fuehrt React Komponenten absichtlich zweimal aus, um versteckte Seiteneffekte im Render aufzudecken. Im Produktionsmodus passiert das nicht. Wenn der doppelte Aufruf tatsaechlich ein Problem verursacht, sollte man pruefen, ob der Effect eine korrekte Aufraeumfunktion hat.

Wann sollte ich useState und wann useReducer verwenden?

useState ist ideal fuer einfache, unabhaengige Zustandswerte. useReducer eignet sich, wenn der naechste State-Wert vom vorherigen abhaengt, wenn mehrere State-Werte zusammengehoeren und gemeinsam aktualisiert werden, oder wenn die Zustandslogik komplex genug ist, um sie separat zu testen. Als Faustregel: Wenn man sich bei useState durch viele verschachtelte Aenderungen kaempft, ist useReducer wahrscheinlich die bessere Wahl.

Warum sehe ich in meiner Konsole "Warning: Cannot update a component from inside the function body of a different component"?

Diese Warnung erscheint, wenn man versucht, den State einer Elternkomponente waehrend des Renderings einer Kindkomponente zu aktualisieren. State-Updates sollten immer in Event-Handlern oder useEffect stattfinden, nicht direkt im Render-Rumpf einer Komponente.

Ist es schlimm, console.log in React-Komponenten zu verwenden?

Im Entwicklungsprozess ist console.log ein nuetzliches Werkzeug. Im Produktionscode sollten log-Ausgaben jedoch entfernt werden, da sie die Browser-Konsole der Nutzerin oder des Nutzers zumuelln. Fuer systematischeres Debugging empfiehlt sich die Nutzung der React DevTools statt console.log.

Was ist der Unterschied zwischen null und undefined als State-Anfangswert?

Beide bedeuten "kein Wert", aber es gibt einen feinen Unterschied im Kontext von React: null ist ein expliziter, beabsichtigter leerer Wert. undefined taucht haeufig als unbeabsichtigter Zustand auf, zum Beispiel wenn ein Prop nicht uebergeben wurde. Es empfiehlt sich, null als bewussten Anfangszustand zu verwenden und undefined fuer fehlende Werte zu reservieren. Wichtig: Ein kontrollierstates Eingabefeld sollte nie undefined als Wert haben, da es dann als unkontrolliert gilt.

Wie finde ich heraus, welche Komponente zu vielen Re-Renders verursacht?

Oeffne die React DevTools im Browser und wechsle in den Profiler-Tab. Starte eine Aufzeichnung, fuehre die Aktion aus, die das Problem verursacht, und stoppe die Aufzeichnung. Der Profiler zeigt genau, welche Komponenten wie oft und wie lange neu gerendert wurden und aus welchem Grund.

Fazit: Aus Fehlern lernen beschleunigt das Wachstum

Die gute Nachricht ist: Alle Fehler, die in diesem Artikel beschrieben werden, sind lernbar und vermeidbar. Sie sind keine Zeichen mangelnder Begabung, sondern normale Stufen auf dem Weg zur Beherrschung von React. Wer diese Muster kennt und versteht, warum sie problematisch sind, wird sie im eigenen Code schnell erkennen und vermeiden.

Der wirksamste Weg, diese Fehler zu vermeiden, ist eine Kombination aus aktivem Bauen, dem Lesen der offiziellen React-Dokumentation unter react.dev und dem Einrichten von ESLint mit den React-spezifischen Regeln von eslint-plugin-react-hooks. Letzteres nimmt einem einen Grossteil der Arbeit ab, indem es die haeufigsten Fehler, besonders bei useEffect und den Hooks-Regeln, automatisch im Code-Editor anzeigt.

React ist ein Werkzeug, das mit der Zeit immer natuerlicher wird. Die Konzepte, die anfangs fremd erscheinen, werden mit jedem Projekt vertrauter. Und die Fehler, die man heute noch macht, werden morgen zu den Mustern gehoeren, die man anderen Anfaengerinnen und Anfaengern gerne erklaert.

---

Ergaenzung: Haeufige Planungsfehler bei der Renovierung mit PVC-Badezimmerwandpaneelen

So wie in der React-Entwicklung viele Fehler auf mangelndes Grundverstaendnis und fehlende Planung zurueckzufuehren sind, entstehen auch bei der Renovierung mit PVC-Badezimmerwandpaneelen die meisten Probleme nicht waehrend der Montage selbst, sondern vorher. Wer die haeufigsten Planungs- und Montagefehler kennt, spart Zeit, Geld und Nerven.

Fehler 1 bei PVC-Paneelen: Falsche Menge bestellen

Der Klassiker unter den Anfaengerfehlern bei der Materialbeschaffung: Man misst die Wandflaeche aus, berechnet die benoenigten Quadratmeter und bestellt genau diese Menge. Das Ergebnis ist fast immer, dass man zu wenig hat.

Warum? Weil bei jedem Zuschnitt Verschnitt entsteht. Ecken, Armaturen und andere Hindernisse erfordern Schraegschnitte und Ausschnitte, von denen man nicht immer den Rest wiederverwenden kann. Als Faustregel gilt: immer 10 bis 15 Prozent mehr bestellen als die reine Flaeche. Bei Schachbrettmustern oder diagonal verlegten Paneelen kann der Mehraufwand noch groesser sein.

Fehler 2 bei PVC-Paneelen: Untergrund nicht ausreichend vorbereiten

PVC-Paneele koennen kleine Unebenheiten ausgleichen, aber keine strukturellen Probleme verbergen. Wenn der Untergrund feucht ist, lockere Stellen hat oder starke Risse aufweist, werden diese Probleme fruher oder spaeter durch die Paneele durchscheinen oder die Haftung beeintraechtigen.

Vor der Montage sollte jede Wandflaeche sorgfaeltig auf Feuchtigkeitsschaeden, losen Putz und Risse untersucht werden. Feuchtigkeit muss vollstaendig behandelt und trocknen gelassen werden, bevor die Paneele angebracht werden. Ein feuchter Untergrund hinter PVC-Paneelen ist ein sicheres Rezept fuer Schimmelprobleme nach wenigen Jahren.

Fehler 3 bei PVC-Paneelen: Falsches Klebe- oder Befestigungsmaterial verwenden

Nicht jeder Kleber ist fuer PVC geeignet, und nicht jeder "Universalkleber" haelt auf jedem Untergrund. Im Nassbereich muss der Kleber dauerhaft wasserfest sein und darf von Feuchtigkeit nicht angegriffen werden. Loesungsmittelhaltige Kleber koennen ausserdem PVC anlosen und die Oberflaeche beschaedigen.

Hochwertige Hersteller von PVC-Paneelen geben in der Regel an, welche Kleber und Befestigungssysteme fuer ihre Produkte geeignet sind. Diese Empfehlungen sollten ernst genommen werden, da die Garantie des Herstellers haeufig von der Verwendung geeigneter Materialien abhaengt.

Fehler 4 bei PVC-Paneelen: Silikonfugen mit ungeeignetem Material

Die Silikonfugen sind die schwachsten Stellen jeder PVC-Paneel-Installation. Viele Heimwerkerinnen und Heimwerker greifen zum guenstigsten Silikon aus dem Baumarkt, ohne auf die Eigenschaften zu achten. Im Nassbereich ist das ein Fehler.

Fuer Badezimmer und Duschen wird ausschliesslich schimmelresistentes Sanitaersilikon empfohlen. Dieses enthaelt antimikrobielle Zusaetze, die das Wachstum von Schimmel in den Fugen erheblich verlangsamen. Normale Bau- oder Fenstersilikone sind fuer diese Anforderungen nicht ausgelegt und werden oft innerhalb von ein bis zwei Jahren schimmelig.

Fehler 5 bei PVC-Paneelen: Dehnungsfugen vergessen

PVC dehnt sich bei Waerme aus und zieht sich bei Kaelte zusammen. Besonders in Duschen, wo wechselnde Temperaturen auftreten, ist diese thermische Ausdehnung nicht zu vernachlaessigen. Wenn Paneele zu eng verlegt werden, koennen sie sich mit der Zeit werfen oder loesen.

Viele PVC-Paneelsysteme haben ein integriertes Nut-Feder-System, das eine gewisse Bewegung erlaubt. Zusaetzlich sollte an allen festen Anschluessen, also an Boden, Decke und Seitewaenden, eine kleine Dehnungsfuge eingerechnet und mit Silikon gefuellt werden, anstatt die Paneele stramm heranzumontieren.

Fehler 6 bei PVC-Paneelen: Deckenpaneele ohne Unterstuetzung verlegen

PVC-Paneele koennen auch an der Decke montiert werden, zum Beispiel in Duschen oder feuchten Kellerraeumen. Dabei unterschaetzen viele Heimwerkerinnen und Heimwerker, wie schwer auch duenne Paneele ueber Kopf werden koennen, und wie wichtig eine korrekte Unterkonstruktion ist.

Fuer die Deckenmontage wird in den meisten Faellen eine Lattenkonstruktion empfohlen, an der die Paneele befestigt werden. Diese muss sorgfaeltig ausgerichtet und fest verankert sein. Bei der Wahl der Deckenhoehe sollte auch die Aufbauhoehe der Unterkonstruktion einkalkuliert werden.

Fehler 7 bei PVC-Paneelen: Qualitaet fuer den Preis opfern

Der Preisunterschied zwischen guenstigen Einstiegspaneelen und hochwertigen Mittelklasseprodukten ist erheblich. Viele Heimwerkerinnen und Heimwerker entscheiden sich fuer die guenstigste Option, um Kosten zu sparen. Das kann auf kurze Sicht sinnvoll erscheinen, fuehrt aber haeufig dazu, dass die Paneele fruehzeitig vergilben, sich verbiegen oder an Glanz verlieren.

In feuchten Raeumen, in denen die Paneele tagtaeglich mit Wasser, Reinigungsmitteln und Temperaturschwankungen in Beruehrung kommen, zahlt sich eine hoehere Eingangsqualitaet fast immer aus. Als Faustregel gilt: Lieber weniger Flaeche mit guter Qualitaet verkleiden als die gesamte Badezimmerflaeche mit Einstiegsmaterial, das nach fuenf Jahren erneuert werden muss.

Kaufberatung: Worauf man beim Kauf von PVC-Badezimmerpaneelen achten sollte

• Staerke: Mindestens 5 mm fuer Nassbereiche, idealerweise 8 bis 10 mm fuer Duschen.
• UV-Stabilitaet: Wichtig, wenn die Paneele in Bereichen mit Lichteinfall verwendet werden, um Vergilbung zu verhindern.
• Oberflaeche: Matte Oberflaechen kaschieren Fingerabdruecke und Wasserspuren besser als hochglaenzende Varianten.
• Abriebfestigkeit: Besonders relevant in stark genutzten Bereichen. Der Hersteller gibt haeufig eine Klassifizierung an.
• Komplettes System: Achte darauf, dass der Hersteller passende Profile, Eckverbinder und Abdichtungsloesungen fuer sein Paneel-System anbietet. Das erleichtert die Montage erheblich.
• Garantie: Seriose Hersteller bieten mindestens 10 Jahre Garantie auf ihre Produkte. Das ist ein gutes Zeichen fuer die Materialqualitaet.
• Brandschutz: In Deutschland sollten Innenwandmaterialien mindestens der Baustoffklasse B2 entsprechen.

PVC-Badezimmerwandpaneele: Schritt-fuer-Schritt Fehler-Checkliste

Fehler	Haeufigkeit	Praeventionsmassnahme
Zu wenig Material bestellt	Sehr haeufig	10 bis 15 Prozent Aufschlag einkalkulieren
Untergrund nicht geprueeft	Haeufig	Auf Feuchtigkeit, Risse und losen Putz pruefen
Falscher Kleber	Haeufig	Herstellerempfehlung fuer Kleber befolgen
Normales statt Sanitaersilikon	Sehr haeufig	Schimmelresistentes Sanitaersilikon verwenden
Dehnungsfugen vergessen	Mittel	Kleinen Spielraum an festen Anschluessen lassen
Guenstigstes Material gewaehlt	Haeufig	Mindeststaerke 8 mm, Garantie pruefen

Abschluss: Fehler vermeiden zahlt sich aus

Ob bei React.js oder bei der Badezimmerrenovierung: Die Fehler, die Anfaengerinnen und Anfaenger am haeufigsten machen, sind in der Regel die gleichen. Sie entstehen nicht aus Unachtsamkeit, sondern aus mangelndem Verstaendnis der Grundprinzipien. Wer weiss, warum eine bestimmte Vorgehensweise empfohlen wird, hat keine Muehe, sie auch einzuhalten.

Die wichtigste Lektion bleibt: Plane sorgfaeltig, verstehe das Werkzeug, das du einsetzt, und scheue dich nicht, bei Unsicherheiten die Empfehlungen der Hersteller und der Community zu lesen. Sowohl in der Softwareentwicklung als auch im Heimwerkern gilt: Ein gut vorbereiteter Anfang ist mehr wert als jede nachtgraegliche Korrektur.