0Pricing
React Academy · Leçon

Bonnes pratiques pour les clés et les refs

Utiliser des clés stables, éviter les problèmes liés à l’utilisation de l’index comme clé et travailler avec des refs de rappel.

Bonnes pratiques pour les clés et les refs est une leçon React Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage React Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours React Academy comprend 4 leçons au total.

Bienvenue

Dans cette leçon, vous apprendrez à utiliser correctement les clés de liste, pourquoi l'utilisation de l'index du tableau comme clé provoque des erreurs et comment travailler avec des références de rappel et des références transmises.

Pourquoi les clés sont importantes

React utilise les propriétés `key` pour suivre les éléments d'une liste qui ont changé, ont été ajoutés ou ont été supprimés entre les rendus. Une clé correcte permet à React de réutiliser les nœuds DOM existants ; une clé incorrecte provoque des démontages et des remontages inutiles.

Clés stables et uniques

La meilleure clé est un ID stable et unique provenant de vos données, comme un ID de ligne de base de données ou un UUID. Cette clé doit être unique uniquement parmi les éléments frères, et non dans toute la page.
users.map(user => (
  <UserCard key={user.id} user={user} />
))

Pourquoi l'index comme clé pose problème

Utiliser l'index du tableau comme clé fonctionne bien pour les listes statiques, mais provoque des erreurs dans les listes classées ou filtrées. Lorsque les éléments changent d'ordre, React associe les composants selon leur index et réutilise les mauvais nœuds DOM, ce qui altère les valeurs des entrées et l'état des animations.
// Risky when list can reorder or filter
items.map((item, i) => <Row key={i} {...item} />)

Quand l'index comme clé est acceptable

L'index comme clé est acceptable uniquement lorsque : (1) la liste ne change jamais d'ordre et n'est jamais filtrée, (2) les éléments n'ont pas d'ID stable et (3) les éléments n'ont pas d'état local (par exemple, des valeurs d'entrée). Les listes d'affichage statiques conviennent.

Générer des ID stables

Si vos données n'ont pas d'ID, générez-en un au moment où vous créez l'élément (et non lors du rendu). Vous pouvez utiliser `crypto.randomUUID()` ou la bibliothèque `nanoid`.
const newItem = { id: crypto.randomUUID(), text: 'Buy milk' };

Principes de base de useRef

`useRef` renvoie un objet modifiable dont la valeur `.current` persiste entre les rendus sans provoquer de nouveaux rendus. Il sert à conserver des références au DOM et des valeurs modifiables comme des ID de minuteurs.
const inputRef = useRef(null);
<input ref={inputRef} />
// Access DOM node: inputRef.current.focus();

Références de rappel

Au lieu de transmettre un objet de référence, vous pouvez transmettre une **référence de rappel** — une fonction que React appelle avec le nœud DOM lors de son montage et avec `null` lors de son démontage. Cela vous permet de configurer une logique exactement au moment où le nœud devient disponible.
function Input() {
  return (
    <input
      ref={node => {
        if (node) node.focus();
      }}
    />
  );
}

forwardRef pour les références de composants

Les composants fonctionnels n'acceptent pas `ref` comme propriété ordinaire. Encapsulez le composant dans `React.forwardRef` pour permettre aux composants parents d'attacher une référence à un nœud DOM interne.
const FancyInput = React.forwardRef((props, ref) => (
  <input ref={ref} className="fancy" {...props} />
));

// Parent
const inputRef = useRef(null);
<FancyInput ref={inputRef} />

useImperativeHandle

Lorsqu'un composant parent détient une référence vers un composant enfant, vous pouvez contrôler précisément ce qu'elle expose à l'aide de `useImperativeHandle`. Cela préserve la confidentialité du DOM interne de l'enfant tout en fournissant une interface impérative claire.
const Child = forwardRef((_, ref) => {
  const innerRef = useRef();
  useImperativeHandle(ref, () => ({
    focus: () => innerRef.current.focus(),
  }));
  return <input ref={innerRef} />;
});

Vérification rapide

Pourquoi devez-vous éviter d'utiliser l'index du tableau comme clé dans une liste susceptible d'être réordonnée ?

Récapitulatif

Utilisez les ID stables des données comme clés, évitez les clés basées sur l'index dans les listes dynamiques, utilisez useRef pour accéder au DOM et conserver des valeurs modifiables, utilisez les références de rappel pour la logique de montage et de démontage et utilisez forwardRef pour exposer les références des composants enfants.

À suivre

Prochaine leçon : **Structure des dossiers et conventions de nommage** — vous organiserez un projet React avec des dossiers basés sur les fonctionnalités et des noms de fichiers cohérents.

Questions Fréquemment Posées

La leçon « Bonnes pratiques pour les clés et les refs » est-elle gratuite ?

Oui — le texte complet de « Bonnes pratiques pour les clés et les refs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours React Academy, passe à CoddyKit PRO. Le cours React Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Bonnes pratiques pour les clés et les refs » ?

Utiliser des clés stables, éviter les problèmes liés à l’utilisation de l’index comme clé et travailler avec des refs de rappel. Tu pratiques React Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer React Academy ?

Aucune expérience préalable n'est requise. React Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Bonnes pratiques pour les clés et les refs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon React Academy ?

Oui. Chaque leçon React Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Rôle de StrictMode
  2. Composants purs et prévention des effets secondaires lors du rendu
  3. Bonnes pratiques pour les clés et les refs
  4. Structure des dossiers et conventions de nommage
← Retour à React Academy