Huit corrections de rendu React qui réduisent les re-renders de 80 % sans avoir à réécrire le code.
Commencez par le profilage, puis utilisez memo, useMemo, useCallback, les transitions, la virtualisation de liste, le splitage du code et des sélecteurs ciblés pour accélérer un grand tableau de bord React.
Sources: How I Optimized a Slow React App Without Rewriting It
Imaginez une démonstration de tableau de bord où chaque clic sur un filtre fige l’écran pendant une seconde entière. Le code est bien structuré et respecte les meilleures pratiques, mais il reste extrêmement lent. La base de code compte 50 000 lignes et personne n’a de budget pour en refaire une version optimisée, donc la seule solution est d’améliorer le rendu sans modifier les fonctionnalités. Les étapes suivantes suivent cette approche, et dans le scénario d’exemple elles réduisent les re-rendus d’environ 80 %.
Mesurer avant de modifier quoi que ce soit
Optimiser à l’aveugle est une perte de temps, c’est pourquoi l’analyse préalable est essentielle. Trois outils permettent d’accomplir la majeure partie du travail :
- Le Profiler des React DevTools, pour enregistrer les interactions et examiner le graphique de performance afin de déterminer quels composants sont re-rendus inutilement.
why-did-you-render, une bibliothèque qui enregistre les re-rendus évitables.- L’onglet Performance des Chrome DevTools, pour obtenir des données précises sur le temps de traitement par frame.
Le schéma typique est facile à repérer. Un parent met à jour son état et tous ses enfants en dessous se rérendent à nouveau, que ce soit en utilisant les données modifiées ou non. Dans une petite application, cela a peu d’importance. Mais dans un tableau de bord contenant des centaines de composants, un seul changement d’état en haut de la hiérarchie peut déclencher une cascade.
Mémoriser les composants avec React.memo
Lorsqu’un composant reçoit les mêmes props, il doit produire le même résultat, et React.memo cache ce résultat. L’approche judicieuse consiste à commencer par les composants purs qui apparaissent le plus souvent dans la liste des rérendus du profileur, plutôt que d’envelopper tout le système.
const ExpensiveComponent = React.memo(({ data, onUpdate }) => {
// Component logic
});
Un bémol : React.memo compare les props de manière superficielle. Une fonction transmise en tant que prop est recréée à chaque rendu, ce qui empêche l’application de la mémoisation. useCallback permet de résoudre ce problème. Une fois la mémoisation appliquée là où c’est utile, les composants qui se rérendaient auparavant à chaque modification d’état ne le font plus que lorsque leurs propres props changent.
Précaution : tous les composants n’en bénéficient pas. Seuls ceux qui se rérendent fréquemment avec des props identiques en tirent profit. Mémoiser tout peut être néfaste, car le stockage des résultats précédents consomme de la mémoire.
useMemo et useCallback
React.memo empêche la rérendu répété des composants. useMemo et useCallback évitent les calculs redondants à l’intérieur d’eux.
Prenez un composant qui calcule des statistiques agrégées à partir d’un grand tableau. Si ce calcul s’exécute à chaque rendu, y compris lors des rendus où les données n’ont pas changé, c’est gaspilleur. En l’enveloppant dans useMemo avec les données en dépendance, il ne sera réexécuté que lorsque les données changent :
const computedStats = useMemo(() => {
return expensiveAggregation(data);
}, [data]);
useCallback résout un problème différent. Les gestionnaires d’événements transmis aux enfants reçoivent une identité nouvelle à chaque rendu, ce qui contrecarre la comparaison superficielle effectuée par React.memo. En enveloppant le gestionnaire, on maintient sa référence stable :
const handleUpdate = useCallback((id) => {
updateItem(id);
}, []);
Cela permet d’éviter que des calculs coûteux ne se répètent, d’empêcher les enfants d’être re-renderis inutilement et de rendre l’interface plus réactive.
Conserver une réactivité en tapant avec useTransition
Un clic doit provoquer une réaction immédiate, mais une mise à jour importante du statut peut figer le navigateur jusqu’à son achèvement. Prenons l’exemple d’une boîte de recherche qui filtre une liste de 10 000 éléments : sans aide, chaque touche bloque l’écran pendant des centaines de millisecondes.
useTransition indique que cette mise à jour a une faible priorité, ce qui permet à React de maintenir l’interface fonctionnelle tandis que le travail lourd s’exécute en arrière-plan :
const [isPending, startTransition] = useTransition();
const handleSearch = (term) => {
startTransition(() => {
setSearchTerm(term);
// Filtering happens in the background
});
};
Le filtrage a toujours lieu, mais sans coûter en temps de saisie. La différence devient évidente dès que quelqu’un utilise la boîte de filtrage.
Valeurs de retard avec useDeferredValue
useDeferredValue ressemble à useTransition, mais s’applique à une valeur plutôt qu’à une mise à jour d’état. Il indique à React que la valeur peut être différée lorsque des événements plus urgents se produisent.
Imaginez un graphique en temps réel qui se rérendu à chaque fois que les données changent. Son rendu est coûteux et bloque d’autres mises à jour. En différant la valeur reçue, React peut d’abord afficher les parties les plus urgentes :
const deferredData = useDeferredValue(data);
// Chart receives deferredData and updates only when React has idle time
Les graphiques et les visualisations cessent alors d’entraver les interactions, permettant à l’application de rester fluide même avec de gros ensembles de données.
Virtualisation des listes longues
Un utilisateur ne voit qu’une petite partie d’une liste à un moment donné, donc afficher l’intégralité de celle-ci gaspille des ressources. Une table comptant 500 lignes, toutes affichées en tant que nœuds DOM à chaque mise à jour, est un bon exemple. En remplaçant un map() brut par react-window, qui n’affiche que les lignes visibles, cela change la situation :
import { FixedSizeList } from 'react-window';
const Row = ({ index, style }) => (
<div style={style}>
{data[index].name}
</div>
);
<FixedSizeList
height={400}
itemCount={data.length}
itemSize={35}
width="100%"
>
{Row}
</FixedSizeList>
Dans l’exemple, le tableau affichait environ 20 lignes au lieu de 500. L’utilisation de la mémoire a diminué, le défilement est devenu plus fluide et la page s’est chargée plus rapidement.
Séparer le bundle par route
Envoyer toute l’application lors du premier chargement est une autre erreur courante. Si les vues du tableau de bord, des analyses, des paramètres et des rapports sont toutes compilées dans un seul fichier JavaScript, le premier chargement est lent. Les fonctions lazy et Suspense de React permettent de séparer le bundle par route, de sorte que chaque vue se charge lorsque l’utilisateur y navigue :
const Dashboard = lazy(() => import('./views/Dashboard'));
const Analytics = lazy(() => import('./views/Analytics'));
function App() {
return (
<Suspense fallback={<Loading />}>
<Routes>
<Route path="/" element={<Dashboard />} />
<Route path="/analytics" element={<Analytics />} />
</Routes>
</Suspense>
);
}
Dans ce scénario, la taille initiale du paquet est passée de 2,5 MB à 800 KB, et la première charge s’est nettement améliorée.
Réduisez le nombre de sélecteurs d’état
Avec Redux ou Zustand, les composants sélectionnent souvent plus d’état qu’ils n’en ont besoin. Si un composant racine récupère l’ensemble du stock via useSelector, toute modification dans le stock provoque un re-rendering de ce composant. La solution consiste à ne sélectionner que les parties d’état utilisées par chaque composant et à mémoriser les données dérivées à l’aide de createSelector de Redux Toolkit :
import { createSelector } from '@reduxjs/toolkit';
const selectFilteredData = createSelector(
(state) => state.items,
(state) => state.filterTerm,
(items, term) => items.filter(item =>
item.name.toLowerCase().includes(term.toLowerCase())
)
);
// In component:
const filteredData = useSelector(selectFilteredData);
Désormais, les composants ne se ré-renderont que lorsque les données qu’ils lisent réellement changent, et la cascade de mises à jour s’arrête.
Auparavant et après
| Métrique | Auparavant | Après |
|---|---|---|
| Moyenne de ré-renderings par interaction | 47 | 9 |
| Délai avant devenir interactif | 2,3 s | 1,1 s |
| Pertes de frames pendant les animations | Fréquentes | Rares |
Cela représente environ 80 % de réductions des ré-renderings, avec la même base de code et les mêmes fonctionnalités.
Ce que cela montre
Accélérer une application React relève principalement de la compréhension plutôt que de la réécriture. Le profileur indique où chercher, de sorte que les efforts ne sont pas consacrés à des composants aléatoires. Chaque modification cible un problème spécifique et a un effet mesurable ; la plupart prennent une demi-heure ou moins. Il s’agit d’améliorations ciblées, et non de rénovations architecturales majeures.
En bref, l’ensemble des outils disponibles inclut React.memo pour les composants purs, useMemo pour les calculs intensifs, useCallback pour des fonctions stables, les deux hooks concurrents pour les tâches pouvant attendre, react-window pour les listes longues, le chargement différé pour les routes, ainsi que des sélecteurs précis pour gérer l’état du store.
En appliquant ces méthodes une par une et de manière cohérente, on peut transformer une application lente en une qui semble répondre instantanément. Commencez par le profileur des outils de développement, identifiez le goulot d’étranglement le plus important et résolvez-le en premier.