Que se passe-t-il réellement après setState() ? Rendu de React
Ce qui se passe après l’appel de setState dans React : le déclencheur, la phase de rendu, la comparaison entre le DOM virtuel et le DOM réel, l’enregistrement des modifications et le moment où useEffect s’exécute dans cet ordre.
Utilisez ceci comme une version révisée destinée aux opérateurs des idées présentées dans « Que se passe-t-il réellement après setState()? Explication du rendu React du DOM virtuel à l’affichage dans le navigateur » : étapes claires, emplacements de code ordonnés et notes de récupération qui survivent au transfert.
L’étape « Aperçu » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre.
Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie du produit, et non d’une finition ultérieure.
setCount(count + 1);
Le tableau d’ensemble
Pour l’étape « The Big Picture », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Placez l’état au même endroit que le composant qui gère la mutation. Mettre tout dans un stockage global rend les erreurs de synchronisation plus difficiles à détecter.
User Click
↓
setState()
↓
React Schedules Update
↓
Render Phase
↓
Virtual DOM
↓
Reconciliation
↓
Commit Phase
↓
Browser Layout
↓
Browser Paint
↓
useEffect()
Étape 1 : L’utilisateur déclenche une mise à jour d’état
Pour l’étape 1 « L’Utilisateur », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses. Placez l’état avec le composant qui gère la mutation. Mettre tout dans un stockage global rend les erreurs de synchronisation plus difficiles à détecter.
function Counter() {
const [count,setCount]=useState(0);
return (
<button onClick={()=>setCount(count+1)}>
{count}
</button>
);
}
setCount(count+1);
Étape 2 : React lance la phase de rendu
Pour l’étape Step 2 React Starts, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce du coût permet d’éviter des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Placez l’état au même endroit que le composant qui gère la mutation. Mettre tout dans un stockage global rend plus difficiles à détecter les erreurs liées aux temps d’exécution. Pour l’étape Step 2 React Starts, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et les scénarios de récupération. Les tentatives de réessai, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations ultérieures.
function Counter(){
console.log("Rendering...");
const [count,setCount]=useState(0);
return <button>{count}</button>;
}
Que signifie réellement le « rendering » ?
Lors de l’étape « Que signifie réellement le rendering ? », notez d’abord les éléments essentiels : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables à des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus embrouillé. Considérez les effets comme une synchronisation avec le monde extérieur, et non comme un substitut aux valeurs dérivées pendant le rendu.
Étape 3 : React crée un DOM virtuel
Lorsque vous travaillez sur l’étape 3 « React Creates », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès et refusez les terminations partielles silencieuses. Traitez les effets comme une synchronisation avec le monde extérieur, et non comme un substitut aux valeurs dérivées lors du rendu.
return (
<button>{count}</button>
);
{
type:"button",
children:["0"]
}
Étape 4 : Réconciliation (Diff)
Lors de l’étape 4 de conciliation et de différenciation, notez d’abord les conditions du contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Considérez les effets comme une synchronisation avec le monde extérieur, et non comme un substitut aux valeurs dérivées lors du rendu. Lors de l’étape 4 de conciliation et de différenciation, notez d’abord les conditions du contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Documentez à la fois le parcours normal et les scénarios de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations apportées ultérieurement.
Previous Virtual DOM
↓
New Virtual DOM
0
↓
1
Pourquoi React est rapide
La phase « Pourquoi React est rapide » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple exemplaire, un cas d’échec et la note de rollback avant d’élargir le périmètre. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’erreur doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Maintenez les opérations de rendu peu coûteuses et reportez les calculs coûteux à la mise en mémoire uniquement après avoir effectué des mesures. Une mise en mémoire prématurée peut cacher des bugs liés à des props obsolètes.
Old UI
↓
Compare
↓
Find Differences
↓
Update Only Those Differences
Étape 5 : Phase de commit
La phase d’approbation du pas 5 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Considérez cette phase comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définites des vérifications de succès et refusez toute mise en œuvre partielle silencieuse. Maintenez les coûts de rendu faibles et reportez les calculs coûteux à la mise en mémoire uniquement après avoir effectué des mesures. Une mise en mémoire prématurée peut cacher des bugs liés à des données obsolètes.
0
↓
1
Que se passe-t-il dans le navigateur ?
Le module « What Happens Inside the stage » fonctionne le mieux lorsqu’il est considéré comme une surface mesurable. Capturez un exemple idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés. Maintenez les coûts de rendu faibles et reportez les calculs coûteux à la mise en mémoire uniquement après avoir effectué des mesures. Une mise en mémoire prématurée peut cacher des bugs liés à des données obsolètes. Le module « What Happens Inside the stage » fonctionne le mieux lorsqu’il est considéré comme une surface mesurable. Capturez un exemple idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours réussi et le parcours de récupération. Les tentatives de réessai, les contrôles humains et le traitement des messages non livrés font partie intégrante du produit, et non d’une étape de finition ultérieure.
DOM Updated
↓
Style Calculation
↓
Layout
↓
Paint
↓
Composite
↓
Screen Updated
Calcul du style
Pour l’étape de calcul du style, définissez les entrées, le responsable de cette étape ainsi que les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables à des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Placez l’état au même endroit que le composant qui gère la mutation. Mettre tout dans un stockage global rend les erreurs de synchronisation plus difficiles à détecter.
Mise en page (Reflow)
Pour l’étape de réorganisation du layout, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès et refusez toute complétion partielle silencieuse. Placez l’état au même endroit que le composant responsable de la mutation. Mettre tout en stock global rend les erreurs liées aux délais plus difficiles à détecter.
Peinture
Pour l’étape Paint, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le parcours passe d’un environnement de démonstration à des environnements partagés. Colocalisez l’état avec le composant qui gère la mutation. Mettre tout dans un stockage global rend les erreurs de timing plus difficiles à détecter. Pour l’étape Paint, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours idéal et le parcours de récupération. Les tentatives de réessai, les contrôles humains et la gestion des messages non livrés font partie du produit, et non d’une mise en forme ultérieure.
Composite
Lors du travail sur l’étape Composite, notez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables à des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Considérez les effets comme une synchronisation avec le monde extérieur, et non comme un substitut aux valeurs dérivées lors du rendu.
Cahier des charges jusqu’à présent
Lors de la phase « Timeline So Far », notez d’abord les conditions du contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Considérez cette phase comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès, et refusez les terminations partielles silencieuses. Traitez les effets comme une synchronisation avec le monde extérieur, et non comme un substitut aux valeurs dérivées lors du rendu.
User Click
↓
setState()
↓
React Schedules Update
↓
Render Phase
↓
Virtual DOM
↓
Reconciliation
↓
Commit Phase
↓
Browser Layout
↓
Browser Paint
↓
Updated UI
Pourquoi React a besoin de useEffect
Lors de l’étude de la question « Pourquoi React a-t-il besoin de useEffect ? », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce du coût évite des factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés. Considérez les effets comme une synchronisation avec le monde extérieur, et non comme un substitut aux valeurs dérivées pendant le rendu. Lors de l’étude de la question « Pourquoi React a-t-il besoin de useEffect ? », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez à la fois le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure.
function Users() {
fetch("/api/users");
return <div>Loading...</div>;
}
Introduire useEffect
La phase d’exécution de useEffect fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple réussi, un cas d’échec et la note de réversion avant d’élargir le périmètre. Préférez des unités petites et testables à des scripts complexes. Lorsqu’une étape échoue, l’erreur doit pointer vers une seule responsabilité plutôt qu’un processus embrouillé. Maintenez les opérations de rendu peu coûteuses et reportez les calculs onéreux à la mise en mémoire uniquement après avoir effectué des mesures. Une mise en mémoire prématurée peut cacher des bugs liés à des props obsolètes.
useEffect(() => {
fetch("/api/users");
}, []);
Quand useEffect s’exécute-t-il ?
La phase « Quand useEffect s’exécute ? » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple réussi, un cas d’échec ainsi que la note de réversion avant d’élargir le périmètre. Traitez cette phase comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès et refusez les complétions partielles silencieuses. Maintenez le coût de la rendu faible et reportez les calculs coûteux à l’après-mémorisation, uniquement après avoir effectué des mesures. Une mémorisation prématurée peut cacher des bugs liés à des props obsolètes.
Render
↓
useEffect
↓
Paint
Render
↓
Commit
↓
Browser Paint 🎨
↓
useEffect()
Comprendre l’array de dépendances
La phase de compréhension du tableau de dépendances fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de l’environnement de démonstration aux environnements partagés. Maintenez les opérations de rendu à un coût faible et reportez les calculs coûteux à la mise en mémoire uniquement après avoir effectué des mesures. Une mise en mémoire prématurée peut cacher des bugs liés à des données obsolètes. La phase de compréhension du tableau de dépendances fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives de réessai, les contrôles humains et le traitement des messages non livrés font partie intégrante du produit, et non d’une étape de finition ultérieure.
Aucun tableau de dépendances
Pour l’étape « No Dependency Array », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un pipeline embrouillé. Placez l’état au même endroit que le composant qui gère la mutation. Mettre tout dans un stockage global rend les erreurs de synchronisation plus difficiles à détecter.
useEffect(() => {
console.log("Runs");
});
Array de dépendances vide
Pour l’étape du tableau de dépendances vide, définitz les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définites des vérifications de succès et refusez toute exécution partielle silencieuse. Placez l’état au même endroit que le composant responsable de la mutation. Mettre tout en stockage global rend les erreurs liées aux délais plus difficiles à détecter.
useEffect(() => {
fetch("/users");
}, []);
Dépendances
Pendant l’étape des Dépendances, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés. Placez l’état au même endroit que le composant responsable de la mutation. Mettre tout dans un stockage global rend les erreurs liées aux temps d’exécution plus difficiles à détecter.
useEffect(() => {
console.log(count);
}, [count]);
Pendant l’étape des Dépendances, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez en même temps le parcours normal et les scénarios de récupération. Les tentatives de réexécution, les contrôles manuels et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations ultérieures.
Fonctions de nettoyage
Lors de la phase des fonctions de nettoyage, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables à des scripts volumineux. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus complexe et embrouillé. Considérez les effets comme une synchronisation avec le monde extérieur, et non comme un substitut aux valeurs dérivées lors du rendu.
useEffect(() => {
window.addEventListener("resize", handleResize);
return () => {
window.removeEventListener("resize", handleResize);
};
}, []);
Erreur courante : boucles infinies
Lorsque vous travaillez sur l’étape des boucles infinies dues à des erreurs courantes, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux éléments générés, définez des vérifications de succès et refusez les terminations partielles silencieuses. Traitez les effets comme une synchronisation avec le monde extérieur, et non comme un substitut aux valeurs dérivées lors du rendu.
useEffect(() => {
setCount(count + 1);
});
Render
↓
Effect
↓
setState()
↓
Render
↓
Effect
↓
setState()
↓
...
useLayoutEffect
Lors du travail sur l’étape useLayoutEffect, écrivez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés. Traitez les effets comme une synchronisation avec le monde extérieur, et non comme un substitut aux valeurs dérivées lors du rendu. Lors du travail sur l’étape useLayoutEffect, écrivez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’une mise en forme ultérieure.
useLayoutEffect(() => {
}, []);
useEffect vs useLayoutEffect
L’étape useEffect vs useLayoutEffect fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple réussi, un cas d’échec et des notes de réversion avant d’élargir le périmètre. Préférez des unités petites et testables à des scripts complexes. Lorsqu’une étape échoue, l’erreur doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Gardez les opérations de rendu peu coûteuses et reportez les calculs coûteux à la mise en mémoire uniquement après avoir effectué des mesures. Une mise en mémoire prématurée peut cacher des bugs liés à des props obsolètes.
useEffect
L’étape useEffect fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple réussi, un cas d’échec ainsi que la note de réversion avant d’élargir le champ d’application. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les complétions partielles silencieuses. Maintenez le coût de la rendu faible et reportez les calculs coûteux à l’après-mémorisation, uniquement après avoir effectué des mesures. Une mémorisation prématurée peut cacher des bugs liés à des props obsolètes.
Render
↓
Commit
↓
Browser Paint 🎨
↓
useEffect()
useLayoutEffect
L’étape useLayoutEffect fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple parfait, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le parcours passe de la démo aux environnements partagés. Maintenez les opérations de rendu peu coûteuses et reportez les calculs onéreux à l’après-mémorisation, uniquement après avoir effectué des mesures. Une mémorisation prématurée peut cacher des bugs liés à des props obsolètes.
Render
↓
Commit
↓
useLayoutEffect()
↓
Browser Paint 🎨
L’étape useLayoutEffect fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple parfait, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours réussi et le parcours de récupération. Les tentatives de répétition, les contrôles humains et le traitement des messages non livrés font partie intégrante du produit, et non d’une étape de finition ultérieure.
Pourquoi est-ce important ?
Pour l’étape « Pourquoi est-ce important ? », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Placez l’état au même endroit que le composant qui gère la mutation. Mettre tout dans un stockage global rend les erreurs de synchronisation plus difficiles à détecter.
Paint
↓
Measure
↓
Move Tooltip
↓
Paint Again
Utilisation de useLayoutEffect
Pour l’étape Using useLayoutEffect, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès et refusez toute complétion partielle silencieuse. Placez l’état avec le composant qui gère la mutation. Mettre tout en stockage global rend les erreurs de synchronisation plus difficiles à détecter.
useLayoutEffect(() => {
const height = ref.current.offsetHeight;
}, []);
Render
↓
Commit
↓
Measure DOM
↓
Update Position
↓
Paint Once
Un autre exemple concret
Pour l’étape « Another Real Example », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le parcours passe de l’environnement de démonstration à des environnements partagés. Placez l’état au même endroit que le composant responsable de la mutation ; placer tout dans un stockage global rend les erreurs liées aux temps d’exécution plus difficiles à détecter.
const inputRef = useRef();
useLayoutEffect(() => {
inputRef.current.focus();
}, []);
Quand utiliser chaque hook ?
Chronologie de rendu jusqu’à présent
User Click
↓
setState()
↓
Render Phase
↓
Virtual DOM
↓
Reconciliation
↓
Commit Phase
↓
Browser Layout
↓
useLayoutEffect()
↓
Browser Paint
↓
useEffect()
React Fiber : la raison pour laquelle React moderne semble rapide
Large Render
↓
Small Tasks
↓
Pause
↓
Resume
↓
Finish
Le planificateur de React
User Typing
↓High Priority
Background List Rendering
↓Lower Priority
Groupement automatique (React 18)
setCount(count + 1);
setName("John");
setLoading(false);
Render
↓
Render
↓
Render
Three Updates
↓
One Render
Le calendrier complet de rendu
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 contre le navigateur
Idées reçues courantes
Questions d’entretien
1. Que se passe-t-il après avoir appelé setState() ?
2. Quelle est la différence entre la phase de rendu et la phase d’application ?
3>Qu’est-ce que le DOM virtuel ?
4. Qu’est-ce que la réconciliation ?
5. useEffect contre useLayoutEffect
6. Pourquoi le DOM est-il considéré comme coûteux ?
7. Pourquoi React a-t-il introduit Fiber ?
Modèle mental final
User Click
↓
setState()
↓
React Scheduler
↓
Render Phase
(Component Executes Again)
↓
Virtual DOM
↓
Reconciliation
↓
Commit Phase
↓
Real DOM Updated
↓
Browser Layout
↓
useLayoutEffect()
↓
Browser Paint
↓
useEffect()