"L'app est lente" est un symptôme, pas un diagnostic. Avant de saupoudrer React.memo et useCallback partout en espérant que ça règle le problème, il faut d'abord savoir précisément quel composant re-render, à quelle fréquence, et surtout pourquoi React a décidé de le re-render. Le Profiler de React DevTools donne cette réponse ; deviner ne la donne pas.
Ce qu'un re-render coûte réellement
Un re-render n'est pas forcément un problème : React fait très bien la différence entre "recalculer le JSX d'un composant" (peu coûteux) et "toucher le DOM réel" (coûteux), grâce au diffing du Virtual DOM. Le vrai problème apparaît quand un composant qui fait un calcul lourd dans son corps (tri d'une grosse liste, transformation de données), ou qui a une arborescence d'enfants profonde, re-render pour une raison qui n'a rien à voir avec les données qu'il affiche réellement.
Localiser le coupable avec le Profiler
L'onglet Profiler de React DevTools enregistre un commit à chaque fois que React applique des changements au DOM, et affiche un flamegraph : chaque barre est un composant, sa largeur est le temps de rendu, sa couleur indique le coût relatif. Cocher "Record why each component rendered" (disponible en mode développement) affiche, pour chaque composant sélectionné, la raison exacte : props changées, state changé, parent re-rendu, ou hook context changé.
// instrumentation manuelle avec le composant <Profiler>,
// utile pour logger en continu sans ouvrir les DevTools
import { Profiler, type ProfilerOnRenderCallback } from "react";
const onRenderCallback: ProfilerOnRenderCallback = (
id, phase, actualDuration, baseDuration
) => {
if (actualDuration > 16) {
console.warn(`[${id}] ${phase} a pris ${actualDuration.toFixed(1)}ms`);
}
};
export function Dashboard() {
return (
<Profiler id="Dashboard" onRender={onRenderCallback}>
<OrdersTable />
</Profiler>
);
}
Le seuil de 16ms n'est pas arbitraire : c'est le budget disponible pour tenir 60 images par seconde. Un composant qui dépasse régulièrement ce seuil dans la phase update est un candidat sérieux pour une optimisation, un composant qui reste sous ce seuil ne vaut probablement pas l'effort, même s'il re-render "inutilement" au sens strict.
Le piège numéro un : le context qui re-render tout le monde
Un Context.Provider dont la value est recréée à chaque rendu du parent (un objet littéral inline, par exemple) déclenche un re-render de tous les consommateurs du contexte, même ceux qui ne lisent qu'un champ qui n'a pas changé. C'est la cause la plus fréquente de re-renders en cascade sur une arborescence entière.
// problème : { user, theme } est un nouvel objet à chaque rendu de AppProvider
function AppProvider({ children }) {
const [user, setUser] = useState(null);
const [theme, setTheme] = useState("light");
return (
<AppContext.Provider value={{ user, theme, setUser, setTheme }}>
{children}
</AppContext.Provider>
);
}
// correction : mémoïser la value, et envisager de scinder le contexte
// en deux (UserContext / ThemeContext) si leurs fréquences de mise à jour diffèrent
function AppProvider({ children }) {
const [user, setUser] = useState(null);
const [theme, setTheme] = useState("light");
const value = useMemo(
() => ({ user, theme, setUser, setTheme }),
[user, theme]
);
return (
<AppContext.Provider value={value}>{children}</AppContext.Provider>
);
}
Scinder le contexte est souvent la meilleure correction, pas seulement la mémoïsation : si theme change dix fois plus souvent que user, les regrouper dans un seul contexte force les consommateurs de user à re-render à chaque changement de thème, mémoïsé ou pas, puisque la value reconstruite change dès que n'importe quel champ change.
Le piège numéro deux : les props inline qui cassent la mémoïsation
React.memo compare les props par référence (Object.is par défaut). Un objet, un tableau ou une fonction recréés à chaque rendu du parent ont une référence différente même si leur contenu est identique, ce qui rend React.memo totalement inopérant.
// le memo ne sert à rien : onSelect est une nouvelle fonction à chaque rendu
function ProductList({ products }) {
return products.map((p) => (
<ProductRow
key={p.id}
product={p}
onSelect={() => handleSelect(p.id)}
/>
));
}
const ProductRow = React.memo(function ProductRow({ product, onSelect }) {
// re-render à chaque rendu de ProductList malgré le memo
return <div onClick={onSelect}>{product.name}</div>;
});
// correction : stabiliser la référence avec useCallback,
// ou passer l'id plutôt qu'une closure
const ProductRow = React.memo(function ProductRow({ product, onSelect }) {
return <div onClick={() => onSelect(product.id)}>{product.name}</div>;
});
function ProductList({ products, onSelect }) {
// onSelect vient du parent, stable si lui-même mémoïsé avec useCallback
return products.map((p) => (
<ProductRow key={p.id} product={p} onSelect={onSelect} />
));
}
useCallback et useMemo ne sont pas gratuits : ils ajoutent leur propre coût de comparaison de dépendances. Les poser systématiquement "au cas où" sur des composants qui ne sont jamais mémoïsés par un React.memo en aval n'apporte rien, puisque rien ne profite de la stabilité de référence obtenue.
Le piège numéro trois : une key instable qui démonte au lieu de re-render
React utilise la prop key pour décider si un élément d'une liste correspond au même nœud logique d'un rendu à l'autre, ou s'il s'agit d'un nœud différent à monter/démonter. Utiliser l'index du tableau comme key sur une liste dont l'ordre peut changer (tri, filtre, insertion en tête) trompe React : il associe les anciens éléments aux nouveaux par position plutôt que par identité, ce qui démonte et remonte des composants qui auraient simplement dû se re-render avec de nouvelles props, perdant au passage leur état local (un champ de formulaire en cours de saisie, une animation en transition).
// problème : trier products change l'ordre, l'index 0 ne désigne
// plus le même produit, React démonte/remonte au lieu de re-render
{products.map((p, index) => (
<ProductRow key={index} product={p} />
))}
// correction : une clé stable liée à l'identité réelle de la donnée
{products.map((p) => (
<ProductRow key={p.id} product={p} />
))}
Dans le Profiler, ce piège se reconnaît à un signal particulier : le composant n'apparaît pas comme "re-rendu" dans le flamegraph classique, il apparaît comme démonté puis entièrement remonté (un nouveau nœud dans l'arbre des commits), ce qui coûte largement plus cher qu'un simple re-render puisque React réexécute tous les effets de montage (useEffect sans dépendances, animations d'entrée) au lieu de se contenter de réconcilier les props.
Mémoïser un calcul, pas seulement un composant
useMemo a un usage distinct de React.memo : il ne sert pas à éviter qu'un composant se re-render, mais à éviter de refaire un calcul coûteux lors d'un rendu qui aurait lieu de toute façon, pour une autre raison (changement d'un state non lié au calcul, par exemple).
function OrdersTable({ orders, sortKey }) {
// sans useMemo, ce tri recalcule à chaque rendu de OrdersTable,
// y compris quand seul un state local d'UI change (ouverture d'un tooltip)
const sorted = useMemo(
() => [...orders].sort((a, b) => a[sortKey] - b[sortKey]),
[orders, sortKey]
);
return <Table rows={sorted} />;
}
Le piège inverse existe aussi : mémoïser un calcul trivial (useMemo(() => a + b, [a, b])) coûte plus cher que de le laisser s'exécuter, parce que la comparaison des dépendances a elle-même un coût non nul. useMemo ne vaut l'effort que si le calcul mémoïsé est mesurablement plus coûteux que cette comparaison, ce qui redevient une question à trancher avec le Profiler plutôt qu'à l'intuition.
Diagnostiquer avant de corriger
La séquence qui évite de deviner : ouvrir le Profiler, reproduire l'interaction lente, repérer dans le flamegraph quel composant a le actualDuration le plus élevé en proportion de son sous-arbre, puis regarder la raison du re-render affichée pour ce composant précis. Si la raison est "props changed" sur une prop qui, à l'œil, n'a pas de raison métier de changer, c'est le signal d'une prop recréée inutilement (objet/fonction inline) plutôt que d'un vrai changement de donnée.
Quand la mémoïsation manuelle ne suffit pas
Sur une liste de plusieurs milliers d'éléments, même avec un memoizing parfait, le problème change de nature : ce n'est plus un re-render évitable, c'est un rendu initial ou un scroll qui doit afficher trop de DOM réel d'un coup. À ce stade, useMemo/React.memo n'apportent rien et la bonne réponse est la virtualisation (n'afficher que les lignes visibles dans le viewport, avec une librairie comme react-virtual ou react-window), qui réduit le nombre de nœuds DOM réellement montés plutôt que d'optimiser le re-calcul du Virtual DOM.
Il faut aussi noter que le React Compiler (disponible depuis React 19) automatise une partie de cette mémoïsation au moment du build en analysant le code source, ce qui réduit le besoin de useMemo/useCallback manuels dans les cas qu'il couvre, mais ne remplace pas le diagnostic initial : il faut toujours identifier quel composant pose problème avant de savoir si l'automatisation du compilateur, une correction manuelle, ou une solution structurelle comme la virtualisation est la bonne réponse.
Le Profiler ne remplace pas la compréhension du mécanisme de rendu de React, mais il transforme "je pense que ça re-render trop" en une mesure précise et une cause nommée. Optimiser sans cette étape revient à distribuer de la mémoïsation au hasard, avec le risque réel de rendre le code plus complexe sans le rendre plus rapide.
