Formations — 1 037 leçons en français

Accueil › React › Mémoïsation

Mémoïsation — entretien React

5 questions posées en entretien, avec la bonne réponse et son explication.

Que conserve « useCallback » entre deux rendus ?

  1. La même référence de fonction, tant que les dépendances sont inchangées ✓
  2. Le résultat du dernier appel de la fonction
  3. Les arguments du dernier appel
  4. Une version compilée plus rapide de la fonction

Pourquoi : « useCallback(f, deps) » est exactement « useMemo(() => f, deps) » : il mémoïse la fonction, jamais son résultat. L'erreur fréquente est d'y voir un cache d'appels. Et créer une fermeture ne coûte presque rien : on mémoïse une fonction pour son identité, pas pour sa création.

Niveau junior

Quelles sont les deux raisons valables d'écrire un « useMemo » ?

  1. Un calcul mesuré comme coûteux, ou une identité à stabiliser pour un memo ou des dépendances d'effet ✓
  2. Éviter de recréer des variables, et réduire la taille du paquet JavaScript
  3. Rendre le composant pur, et éviter les rendus du parent
  4. Mettre en cache un appel réseau, et retarder un calcul

Pourquoi : Hors de ces deux cas, useMemo n'ajoute que du code et un tableau de dépendances à maintenir. La deuxième raison est la plus souvent ignorée alors qu'elle est la plus fréquente en pratique : on ne mémoïse pas un « filter » sur deux cents éléments pour sa vitesse, mais pour que le memo en aval ait une chance de fonctionner.

Niveau confirme

Que se passe-t-il avec « <Ctx.Provider value={{ utilisateur, deconnecter }}> » ?

  1. Tous les consommateurs du contexte se rendent à chaque rendu du fournisseur, memo compris ✓
  2. Rien de particulier, React compare le contenu de la valeur
  3. Seuls les consommateurs dont la valeur lue a changé se rendent
  4. Le contexte lève un avertissement en mode développement

Pourquoi : L'objet littéral change d'identité à chaque rendu, et un contexte propage la mise à jour à tous ses consommateurs sans comparaison superficielle de ses champs. C'est le cas où l'oubli d'un useMemo coûte le plus cher, parce qu'il traverse memo. L'alternative à la mémoïsation est de scinder le contexte : la valeur qui change souvent d'un côté, le reste de l'autre.

Niveau confirme

Pourquoi ce useMemo ne met-il jamais rien en cache ?

const visibles = clients.filter(f);
const premiers = useMemo(() => visibles.slice(0, 10), [visibles]);
  1. Parce que « visibles » est un tableau neuf à chaque rendu : la dépendance change toujours ✓
  2. Parce que « slice » renvoie une copie
  3. Parce qu'un tableau ne peut pas servir de dépendance
  4. Parce qu'il manque « f » dans les dépendances

Pourquoi : Un useMemo dont une dépendance est recréée à chaque rendu paie la comparaison et le calcul, sans jamais réutiliser quoi que ce soit. La correction consiste à mémoïser en remontant la chaîne, ou à fusionner les deux étapes dans un seul useMemo. C'est la même règle qui explique les effets qui se relancent en boucle.

Niveau senior

Peut-on mettre un compteur ou une requête dans la fonction passée à « useMemo » ?

  1. Non : React peut jeter le cache et refaire le calcul, donc il doit rester pur ✓
  2. Oui, c'est le moyen recommandé de ne lancer la requête qu'une fois
  3. Oui, à condition que le tableau de dépendances soit vide
  4. Non, parce que useMemo s'exécute après le commit

Pourquoi : useMemo est une optimisation, pas une garantie : la documentation invite à écrire son code comme si le calcul pouvait être refait à tout moment, et à vérifier que cela ne change rien. Un tableau de dépendances vide ne protège de rien, et useMemo s'exécute pendant le rendu — un effet de bord y part donc avant même l'affichage.

Niveau senior

S'entraîner sur ces questions, chronométré →