Dans beaucoup d'équipes, Context est devenu le réflexe par défaut dès qu'un état doit traverser plus de deux niveaux de composants. Le problème n'apparaît pas tout de suite : l'application démarre propre, puis au bout de quelques mois un UserProvider englobe toute l'app, un NotificationsProvider reçoit des événements websocket toutes les secondes, et soudain des pans entiers de l'interface se re-rendent sans raison apparente. Ce n'est pas un bug de React, c'est une conséquence directe de la façon dont Context a été conçu.
Ce que Context fait réellement
Context n'est pas un gestionnaire d'état. C'est un mécanisme d'injection de dépendances qui évite le "prop drilling". Sa seule promesse est de rendre une valeur disponible à tous les descendants d'un Provider sans avoir à la faire transiter prop par prop. Il n'a aucune notion de sélection fine : quand la valeur passée au Provider change (nouvelle référence), tous les composants qui consomment ce Context via useContext se re-rendent, qu'ils utilisent réellement la partie modifiée ou non.
const AppStateContext = createContext(null);
function AppProvider({ children }) {
const [user, setUser] = useState(null);
const [notifications, setNotifications] = useState([]);
const [theme, setTheme] = useState("light");
// Un seul objet value : toute mise à jour d'un des trois états
// recrée cette référence et invalide TOUS les consommateurs.
const value = { user, setUser, notifications, setNotifications, theme, setTheme };
return (
<AppStateContext.Provider value={value}>
{children}
</AppStateContext.Provider>
);
}
Un composant <ThemeSwitcher /> qui ne lit que theme va pourtant se re-rendre chaque fois qu'une notification websocket arrive, parce qu'il consomme le même Context que tout le reste.
Pourquoi ça dégrade les performances en pratique
Le re-render en lui-même n'est pas forcément coûteux : React est rapide pour réconcilier un arbre simple. Le problème vient de l'accumulation : des listes longues, des composants avec des calculs dérivés non mémoïsés, des bibliothèques tierces (graphiques, éditeurs riches, cartes) qui recalculent leur layout à chaque passe. Un Context mal découpé agit comme un diffuseur de re-renders à toute l'arborescence, et chaque sous-arbre paie le prix du composant le plus lourd qu'il contient.
Diagnostiquer avant de corriger
Avant de changer quoi que ce soit, il faut mesurer. Le React DevTools Profiler (onglet "Profiler", option "Record why each component rendered") donne la cause exacte : Context apparaît explicitement comme raison de re-render, avec le nom du Provider concerné. C'est la seule façon fiable de confirmer l'hypothèse plutôt que de deviner.
// Alternative en code : repérer les re-renders inattendus
function NotificationBell() {
useEffect(() => {
console.count("NotificationBell render");
});
// ...
}
Si NotificationBell se re-rend à chaque frappe clavier dans un champ de recherche situé ailleurs dans l'app, et que les deux partagent un même Provider racine, le diagnostic est confirmé.
Les correctifs qui suffisent souvent
Découper le Context par domaine et par fréquence de changement
La première réponse, et la moins coûteuse, consiste à ne jamais regrouper dans un seul Context des données qui changent à des fréquences très différentes. Séparer UserContext (change rarement), ThemeContext (change rarement) et NotificationsContext (change souvent) limite déjà la casse : seuls les consommateurs de notifications paient le coût des mises à jour fréquentes.
const UserContext = createContext(null);
const ThemeContext = createContext(null);
const NotificationsContext = createContext(null);
function AppProviders({ children }) {
return (
<UserContext.Provider value={userValue}>
<ThemeContext.Provider value={themeValue}>
<NotificationsContext.Provider value={notifValue}>
{children}
</NotificationsContext.Provider>
</ThemeContext.Provider>
</UserContext.Provider>
);
}
Mémoïser la valeur du Provider
Un piège classique : recréer l'objet value à chaque render du Provider, même si son contenu n'a pas changé (par exemple parce qu'un composant parent s'est re-rendu pour une autre raison). useMemo évite les re-renders fantômes qui ne sont même pas dus à un vrai changement de donnée.
const value = useMemo(
() => ({ notifications, markAsRead }),
[notifications]
);
Isoler le composant qui consomme le Context
Quand seule une petite portion de l'UI a besoin de la valeur, extraire cette portion dans un composant dédié limite le périmètre du re-render. React ne peut pas éviter le re-render du consommateur, mais il peut éviter de re-rendre tout le sous-arbre autour de lui si ce sous-arbre est passé en children et mémoïsé.
Quand Context ne suffit plus
Context devient un mauvais choix architectural, et pas seulement un problème de perf, dans trois cas précis :
- Des mises à jour à haute fréquence consommées par de nombreux composants dispersés (prix qui bougent en temps réel, curseur collaboratif, état de synchronisation réseau). Même bien découpé, Context oblige React à visiter chaque consommateur à chaque update ; il n'existe pas de mécanisme de sélection partielle natif.
- Des besoins de lecture hors du cycle de rendu React : logique métier dans un service, un intercepteur Axios, un gestionnaire d'événements global qui doit lire l'état courant sans être un composant.
- Un besoin de traçabilité ou de debug avancé (time-travel, logs d'actions, tests unitaires du store indépendamment des composants).
Dans ces cas, un store externe comme Zustand, Jotai ou Redux Toolkit règle le problème à la racine grâce à la sélection fine : seuls les composants qui lisent le fragment modifié se re-rendent, via un mécanisme de souscription basé sur useSyncExternalStore plutôt que sur la propagation Context.
import { create } from "zustand";
const useNotificationStore = create((set) => ({
notifications: [],
push: (n) => set((s) => ({ notifications: [...s.notifications, n] })),
}));
// Seul ce composant se re-rend quand `notifications` change,
// peu importe le reste de l'arbre.
function NotificationBell() {
const notifications = useNotificationStore((s) => s.notifications);
return <span>{notifications.length}</span>;
}
Les compromis à assumer
Context reste la bonne option pour de l'état peu volatil et peu consommé : thème, locale, configuration de session, feature flags statiques. Introduire Zustand ou Redux partout "au cas où" ajoute une dépendance, une courbe d'apprentissage et une boîte noire supplémentaire à maintenir, pour un gain nul si l'état concerné change deux fois par session. Le choix doit se faire par domaine d'état, pas pour l'application entière : une même app peut très bien utiliser Context pour l'authentification et Zustand pour l'état temps réel du dashboard.
Quand même le store externe ne suffit pas
Un store applicatif résout la sélection fine côté client, mais pas la cohérence avec le serveur. Si l'état concerné est en réalité une copie locale de données serveur (liste de commandes, profil utilisateur, panier), dupliquer sa gestion dans Zustand recrée les problèmes classiques de cache obsolète et de synchronisation manuelle. Dans ce cas, la bonne couche n'est ni Context ni un store global généraliste, mais une bibliothèque de data-fetching comme React Query ou RTK Query, qui gère le cache, l'invalidation et la revalidation à la place du développeur.
Le React Compiler change la donne, mais pas sur ce point
Le React Compiler (stabilisé avec React 19) automatise une partie du travail de mémoïsation : il insère lui-même l'équivalent de useMemo et React.memo autour des composants et des valeurs dérivées qui ne dépendent pas de props ou d'états modifiés, sans que le développeur ait à écrire ces primitives à la main. C'est une vraie avancée pour éliminer les re-renders dus à des callbacks ou des objets recréés par accident à chaque passe.
Mais le compilateur ne change rien au problème structurel de Context décrit plus haut. Si un Provider expose un objet value qui regroupe plusieurs états changeant à des fréquences différentes, le compilateur ne peut pas deviner qu'il faudrait les séparer : il optimise la mémoïsation locale, pas l'architecture de propagation. Autrement dit, le compilateur rend les correctifs de bas niveau (mémoïsation manuelle, React.memo oublié) moins nécessaires, mais ne remplace jamais la décision de découper un Context par domaine ou de migrer vers un store à sélection fine quand le volume de données haute fréquence le justifie.
// Même avec le React Compiler actif, ce découpage reste nécessaire :
// le compilateur ne sépare pas un Context trop large à votre place.
const NotificationsContext = createContext(null);
const UserContext = createContext(null);
Valider la décision avec un test de charge simple
Avant de migrer un domaine d'état vers un store externe, il est utile de quantifier le gain plutôt que de se fier à une impression. Le Profiler de React DevTools permet d'exporter la durée de commit par interaction ; comparer cette durée avant et après un découpage de Context (sans même introduire de nouvelle dépendance) donne souvent la majorité du gain attendu, et permet de décider si la migration vers Zustand est réellement nécessaire ou si un découpage suffit.
// Mesure manuelle simple autour d'une interaction critique
function handleLike() {
performance.mark("like-start");
setLikes((l) => l + 1);
requestAnimationFrame(() => {
performance.mark("like-end");
performance.measure("like-duration", "like-start", "like-end");
});
}
Cette mesure, consultable dans l'onglet Performance des DevTools du navigateur, confirme objectivement si le correctif a réduit le temps de rendu, plutôt que de se fier à une impression de fluidité.
À retenir : Context est fait pour l'injection de dépendances, pas pour l'état à haute fréquence. Avant d'ajouter une librairie de state management, profilez pour confirmer que le re-render vient bien de Context, découpez et mémoïsez, et ne migrez vers un store externe que pour les domaines d'état qui le justifient réellement.
