Startseite / Artikel

Was passiert tatsächlich nach setState()? React-Rendering

Was passiert nach setState in React: der Auslöser, die Render-Phase, der Vergleich zwischen virtuellem DOM und echtem DOM, die Speicherung sowie der Ablauf von useEffect in dieser Reihenfolge.

Verlag: REACTAPP.TOP16 Min. Lesezeit3635 Wörter

Quellen: What Actually Happens After `setState()`? React Rendering Explained from Virtual DOM to Browser Paint

Nutzen Sie dies als für Operator zugängliche Neuformulierung der Ideen aus „Was passiert tatsächlich nach setState()? Erklärung der React-Berechnung vom Virtual DOM bis zur Darstellung im Browser“: klare Phasen, geordnete Codeabschnitte sowie Wiederherstellungshinweise, die auch bei Übergaben erhalten bleiben. Die Überblicksphase funktioniert am besten, wenn sie als messbarer Rahmen betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein optimales Beispiel, einen Fehlerfall sowie die Notizen zur Rücksetzung. Dokumentieren Sie den erfolgreichen Ablauf sowie den Wiederherstellungsprozess gemeinsam. Wiederholte Versuche, menschliche Kontrollpunkte und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen.

setCount(count + 1);

Das große Ganze

Für die Phase „The Big Picture“ sollten Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Bevorzugen Sie kleine, testbare Einheiten vor umfangreichen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Platzieren Sie den Zustand zusammen mit dem Komponenten, der die Änderung verantwortet. Das Hinzufügen aller Daten in einen globalen Speicher erschwert das Erkennen von Zeitproblemen.

User Click
↓
setState()
↓
React Schedules Update
↓
Render Phase
↓
Virtual DOM
↓
Reconciliation
↓
Commit Phase
↓
Browser Layout
↓
Browser Paint
↓
useEffect()

Schritt 1: Der Benutzer löst eine Zustandsaktualisierung aus

In der Phase „Schritt 1: Benutzer“ sollten vor dem Ändern des Codes die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Platzieren Sie den Zustand zusammen mit dem Komponenten, der für die Änderung verantwortlich ist. Das Hinzufügen aller Daten in einen globalen Speicher erschwert das Erkennen von Zeitproblemen.

function Counter() {
    const [count,setCount]=useState(0);
return (
        <button onClick={()=>setCount(count+1)}>
            {count}
        </button>
    );
}
setCount(count+1);

Schritt 2: React startet die Render-Phase

Zur Phase „Step 2 React Starts“ sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen der Laufzeiten sowie der Kosten für Tokens oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung übergeht. Platzieren Sie den Zustand zusammen mit dem Component, der die Mutation verantwortet. Das Hinzufügen aller Daten in einen globalen Store erschwert es, Timing-Probleme zu erkennen. Zur Phase „Step 2 React Starts“ sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholungsversuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

function Counter(){
console.log("Rendering...");
    const [count,setCount]=useState(0);
    return <button>{count}</button>;
}

Was bedeutet „Rendering“ eigentlich?

Wenn Sie die Phase „Was bedeutet Rendering eigentlich?“ durchgehen, notieren Sie zunächst den Vertrag: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufverfahren. Betrachten Sie Effekte als Synchronisierung mit der Außenwelt – nicht als Ersatz für berechnete Werte während des Renderings.

Schritt 3: React erstellt einen virtuellen DOM

Beim Arbeiten an der Phase „Step 3 React Creates“ sollten Sie zunächst einen Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab. Betrachten Sie Effekte als Synchronisierung mit der Außenwelt – nicht als Ersatz für berechnete Werte während des Renderns.

return (
    <button>{count}</button>
);
{
    type:"button",
    children:["0"]
}

Schritt 4: Abgleich (Diffing)

Beim Bearbeiten der Phase „Reconciliation Diffing“ in Schritt 4 sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo-Umgebung in gemeinsam genutzte Umgebungen übergeht. Betrachten Sie die Auswirkungen als Synchronisierung mit der Außenwelt – nicht als Ersatz für berechnete Werte während der Darstellung. Beim Bearbeiten der Phase „Reconciliation Diffing“ in Schritt 4 sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgssignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholungsversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

Previous Virtual DOM
↓
New Virtual DOM
0
↓
1

Warum React schnell ist

Die Phase „Warum React schnell ist“ funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie eine gelungene Ausführungsbeispiel, einen Fehlerfall sowie die Notizen zum Rollback, bevor Sie den Umfang erweitern. Ziehen Sie kleine, testbare Einheiten vor umfangreichen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortungsbereich verweisen und nicht auf ein verworrenes Ablaufverfahren. Halten Sie die Render-Arbeit kostengünstig und verschieben Sie aufwändige Berechnungen erst nach Messung hinter die Memoisierung. Frühzeitige Memoisierung kann Fehler durch veraltete Props verbergen.

Old UI
↓
Compare
↓
Find Differences
↓
Update Only Those Differences

Schritt 5: Commit-Phase

Die Phase „Schritt 5: Commit“ funktioniert am besten, wenn sie als messbarer Prozess betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs eine optimale Ausgabe, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Behandeln Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Halten Sie die Renderarbeiten kostengünstig und verschieben Sie aufwändige Berechnungen erst nach Messung hinter die Memoisierung – eine vorzeitige Memoisierung kann fehlerhafte Eigenschaften verbergen.

0
↓
1

Was geschieht im Browser?

The What Happens Inside the Stage funktioniert am besten, wenn er als messbare Größe betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo in gemeinsam genutzte Umgebungen übergeht. Halten Sie die Renderarbeiten kostengünstig und verschieben Sie aufwändige Berechnungen erst nach Messung hinter die Memoisierung – eine vorzeitige Memoisierung kann fehlerhafte Eigenschaften verbergen. The What Happens Inside the Stage funktioniert am besten, wenn er als messbare Größe betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Dokumentieren Sie den erfolgreichen Ablauf sowie den Wiederherstellungsprozess gemeinsam. Wiederholversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

DOM Updated
↓
Style Calculation
↓
Layout
↓
Paint
↓
Composite
↓
Screen Updated

Stilberechnung

Zur Phase der Stilberechnung sollten die Eingabedaten, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden, bevor der Code geändert wird. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Bevorzugen Sie kleine, testbare Einheiten vor umfangreichen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Platzieren Sie den Zustand zusammen mit dem Komponenten, der die Änderung verantwortet. Das Hochladen aller Daten in einen globalen Speicher erschwert das Erkennen von Zeitproblemen.

Layout (Umfüllung)

Zur Phase des Layout-Reflow sollte man vor dem Ändern des Codes die Eingaben, den Verantwortlichen für diesen Schritt sowie die Abbruchkriterien definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Platzieren Sie den Zustand zusammen mit dem Komponenten, der die Mutation verantwortet. Das Hervorheben aller Daten in einem globalen Speicher erschwert das Erkennen von Zeitproblemen.

Paint

Zur Paint-Phase sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen der Laufzeiten sowie der Kosten für Tokens oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung übergeht. Platzieren Sie den Zustand zusammen mit dem Komponenten, der für die Änderung verantwortlich ist. Das Hinzufügen aller Daten zu einem globalen Speicher erschwert es, Laufzeitprobleme zu erkennen. Zur Paint-Phase sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallplan. Wiederholungsversuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

Komposit

Beim Arbeiten in der Composite-Phase sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Betrachten Sie Effekte als Synchronisierung mit der Außenwelt – nicht als Ersatz für berechnete Werte während der Darstellung.

Bislangiger Zeitverlauf

Während der Phase „Timeline So Far“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab. Betrachten Sie Auswirkungen als Synchronisierung mit der Außenwelt – nicht als Ersatz für berechnete Werte während der Darstellung.

User Click
↓
setState()
↓
React Schedules Update
↓
Render Phase
↓
Virtual DOM
↓
Reconciliation
↓
Commit Phase
↓
Browser Layout
↓
Browser Paint
↓
Updated UI

Warum React useEffect benötigt

Wenn Sie den Abschnitt „Warum braucht React useEffect“ durchgehen, notieren Sie zunächst den Vertrag: erforderliche Eingaben, Erfolgsignal sowie was bei einem teilweisen Versagen passiert. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie außerdem die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Weg von einer Demo in gemeinsame Umgebungen wechselt. Betrachten Sie Effects als Synchronisierung mit der Außenwelt – nicht als Ersatz für berechnete Werte während des Renderns. Wenn Sie den Abschnitt „Warum braucht React useEffect“ durchgehen, notieren Sie zunächst den Vertrag: erforderliche Eingaben, Erfolgssignal sowie was bei einem teilweisen Versagen passiert. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholte Versuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen.

function Users() {
fetch("/api/users");
    return <div>Loading...</div>;
}

Einführung in useEffect

Die Phase des Enter useEffect funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie ein gelungenes Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf. Halten Sie die Render-Arbeit kostengünstig und verschieben Sie aufwändige Berechnungen erst nach Messung hinter die Memoisierung – eine vorzeitige Memoisierung kann Fehler mit veralteten Props verbergen.

useEffect(() => {
fetch("/api/users");
}, []);

Wann läuft useEffect ab?

Die Phase „Wann läuft useEffect ab?“ funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie ein gelungenes Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Halten Sie die Render-Arbeit kostengünstig und verschieben Sie aufwändige Berechnungen erst nach Messung hinter die Memoisierung – eine vorzeitige Memoisierung kann fehlerhafte Props verbergen.

Render
↓
useEffect
↓
Paint
Render
↓
Commit
↓
Browser Paint 🎨
↓
useEffect()

Verständnis der Abhängigkeitsarray

Die Phase „Verständnis der Abhängigkeitsmatrix“ funktioniert am besten, wenn sie als messbare Größe betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo in gemeinsame Umgebungen übergeht. Halten Sie die Renderarbeiten kostengünstig und verschieben Sie aufwändige Berechnungen erst nach Messung hinter die Memoisierung – eine vorzeitige Memoisierung kann fehlerhafte Eigenschaften verbergen. Die Phase „Verständnis der Abhängigkeitsmatrix“ funktioniert am besten, wenn sie als messbare Größe betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

Keine Abhängigkeitsmatrix

In der Phase „Kein Abhängigkeitsarray“ sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Bevorzugen Sie kleine, testbare Einheiten vor umfangreichen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Pipeline-System. Platzieren Sie den Zustand zusammen mit dem Komponenten, der die Mutation verantwortet. Das Hochladen aller Daten in einen globalen Speicher erschwert das Erkennen von Zeitungsfehlern.

useEffect(() => {
console.log("Runs");
});

Leeres Abhängigkeitsarray

In der Phase des leeren Abhängigkeitsarrays sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Platzieren Sie den Zustand zusammen mit dem Komponenten, der die Mutation verantwortet. Das Hinzufügen aller Daten in einen globalen Speicher erschwert das Erkennen von Zeitproblemen.

useEffect(() => {
fetch("/users");
}, []);

Abhängigkeiten

In der Phase der Abhängigkeiten sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen der Laufzeiten sowie der Kosten für Token oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung übergeht. Platzieren Sie den Zustand zusammen mit dem Komponenten, der für die Änderung verantwortlich ist. Das Hinzufügen aller Daten in einen globalen Speicher erschwert es, Zeitprobleme zu erkennen.

useEffect(() => {
console.log(count);
}, [count]);

In der Phase der Abhängigkeiten sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholungsversuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

Reinigungsfunktionen

Während der Phase der Reinigungsfunktionen sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Betrachten Sie Effekte als Synchronisierung mit der Außenwelt – nicht als Ersatz für berechnete Werte während der Darstellung.

useEffect(() => {
window.addEventListener("resize", handleResize);
    return () => {
        window.removeEventListener("resize", handleResize);
    };
}, []);

Häufiger Fehler: Endlose Schleifen

Wenn Sie die Phase „Häufige Fehler: Endlose Schleifen“ durchgehen, notieren Sie zunächst den Vertrag: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab. Betrachten Sie Auswirkungen als Synchronisierung mit der Außenwelt – nicht als Ersatz für berechnete Werte während der Darstellung.

useEffect(() => {
setCount(count + 1);
});
Render
↓
Effect
↓
setState()
↓
Render
↓
Effect
↓
setState()
↓
...

useLayoutEffect

Beim Arbeiten mit dem useLayoutEffect-Schritt sollte man zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie was bei einem teilweisen Versagen geschieht. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie außerdem die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Weg von einer Demo in gemeinsame Umgebungen wechselt. Betrachten Sie Effekte als Synchronisierung mit der Außenwelt – nicht als Ersatz für berechnete Werte während des Renderns. Beim Arbeiten mit dem useLayoutEffect-Schritt sollte man zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgssignal sowie was bei einem teilweisen Versagen geschieht. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche, menschliche Kontrollen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen.

useLayoutEffect(() => {
}, []);

useEffect gegen useLayoutEffect

Der Vergleich zwischen useEffect und useLayoutEffect funktioniert am besten, wenn er als messbarer Bereich betrachtet wird. Erfassen Sie ein gelungenes Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Ziehen Sie kleine, testbare Einheiten vor umfangreichen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Halten Sie die Render-Arbeit kostengünstig und verschieben Sie aufwändige Berechnungen erst nach Messung hinter die Memoisierung. Frühzeitige Memoisierung kann Fehler durch veraltete Props verbergen.

useEffect

Die useEffect-Ebene funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie ein gelungenes Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Betrachten Sie diese Ebene als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Halten Sie die Render-Arbeit kostengünstig und verschieben Sie aufwändige Berechnungen erst nach Messung hinter die Memoisierung – eine vorzeitige Memoisierung kann fehlerhafte Props verbergen.

Render
↓
Commit
↓
Browser Paint 🎨
↓
useEffect()

useLayoutEffect

Die Phase useLayoutEffect funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes“ Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen zusammen mit den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn sich der Weg von einer Demo in gemeinsame Umgebungen verschiebt. Halten Sie die Render-Arbeit kostengünstig und verschieben Sie aufwändige Berechnungen erst nach Messung hinter die Memoisierung – eine vorzeitige Memoisierung kann fehlerhafte Props verbergen.

Render
↓
Commit
↓
useLayoutEffect()
↓
Browser Paint 🎨

Die Phase useLayoutEffect funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes“ Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche, menschliche Kontrollen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen.

Warum ist das wichtig?

In der Phase „Warum ist das wichtig?“ sollten die Eingabedaten, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden, bevor der Code geändert wird. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Zur Vorzugsbehandlung sollten kleine, testbare Einheiten vor umfangreichen Skripten stehen. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Der Zustand sollte zusammen mit dem Komponenten gespeichert werden, der die Änderung veranlasst. Das Hinzufügen aller Daten in einen globalen Speicher erschwert das Erkennen von Zeitproblemen.

Paint
↓
Measure
↓
Move Tooltip
↓
Paint Again

Verwendung von useLayoutEffect

Zur Phase „Using useLayoutEffect“ sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab. Platzieren Sie den Zustand zusammen mit dem Komponenten, der die Mutation verantwortet. Das Hinaufbringen aller Daten in einen globalen Speicher erschwert das Erkennen von Zeitproblemen.

useLayoutEffect(() => {
const height = ref.current.offsetHeight;
}, []);
Render
↓
Commit
↓
Measure DOM
↓
Update Position
↓
Paint Once

Noch ein reales Beispiel

Zur Phase „Another Real Example“ sollten Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien definieren, bevor Sie Code ändern. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Erfassen Sie die Laufzeiten sowie die Kosten für Tokens oder Abfragen zusammen mit den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Weg von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt. Legen Sie den Zustand zusammen mit dem Komponenten ab, der die Mutation verantwortet. Das Hinzufügen aller Daten in einen globalen Speicher erschwert es, Laufzeitfehler zu erkennen.

const inputRef = useRef();
useLayoutEffect(() => {
    inputRef.current.focus();
}, []);

Wann sollten Sie jeden Hook verwenden?

Bislangiger Renderingszeitplan

User Click
↓
setState()
↓
Render Phase
↓
Virtual DOM
↓
Reconciliation
↓
Commit Phase
↓
Browser Layout
↓
useLayoutEffect()
↓
Browser Paint
↓
useEffect()

React Fiber: Der Grund, warum modernes React schnell wirkt

Large Render
↓
Small Tasks
↓
Pause
↓
Resume
↓
Finish

Der React Scheduler

User Typing
↓High Priority
Background List Rendering
↓Lower Priority

Automatisches Batching (React 18)

setCount(count + 1);
setName("John");
setLoading(false);
Render
↓
Render
↓
Render
Three Updates
↓
One Render

Die vollständige Render-Zeitlinie

User Interaction
↓
setState()
↓
React Scheduler
↓
Render Phase
↓
Component Executes
↓
Virtual DOM Created
↓
Reconciliation
↓
Commit Phase
↓
Real DOM Updated
↓
Browser Style Calculation
↓
Browser Layout (Reflow)
↓
useLayoutEffect()
↓
Browser Paint
↓
Composite
↓
Screen Updated
↓
useEffect()

React gegen Browser

Häufige Missverständnisse

Interviewfragen

1. Was passiert nach dem Aufruf von setState()?

2. Was ist der Unterschied zwischen Phase der Darstellung und Phase der Bestätigung?

3. Was ist das Virtuelle DOM?

4. Was ist Abgleichung?

5. useEffect gegen useLayoutEffect

6. Warum gilt der DOM als aufwändig?

7. Warum führte React Fiber ein?

Endgültiges mentales Modell

User Click
↓
setState()
↓
React Scheduler
↓
Render Phase
(Component Executes Again)
↓
Virtual DOM
↓
Reconciliation
↓
Commit Phase
↓
Real DOM Updated
↓
Browser Layout
↓
useLayoutEffect()
↓
Browser Paint
↓
useEffect()

Fazit

Operative Kontrollliste