Semaine 4 · React Débutants

Listes & clés

Afficher des données dynamiques avec .map(), comprendre la prop key et pourquoi elle est indispensable, filtrer et trier des tableaux dans React.

map, filter, sort
La prop key
Tableaux d'objets
3 exercices pratiques
Prérequis : S1 JSX · S2 Props · S3 Rendu conditionnel
01 — Concept

Afficher des données dynamiques

En React, on n'écrit jamais de composants en dur pour chaque élément d'une liste. On part d'un tableau de données JavaScript et on le transforme en tableau de composants JSX — avec la méthode .map().

Le principe fondamental — données → JSX
[
  { id:1, nom:'Fatou' },
  { id:2, nom:'Moussa' },
  { id:3, nom:'Aminata' }
]
→
<CarteEtudiant nom="Fatou" />
<CarteEtudiant nom="Moussa" />
<CarteEtudiant nom="Aminata" />

Un tableau JS de 3 objets → 3 composants React générés automatiquement

Rappel JavaScript — la méthode .map()
.map() transforme chaque élément d'un tableau
rappel.jsJavaScript pur
const nombres = [1, 2, 3];

{"// .map() retourne un NOUVEAU tableau transformé"}
const doubles = nombres.map((n) => n * 2);
{"// doubles → [2, 4, 6]"}

{"// En React : même principe, mais on retourne du JSX"}
const elements = nombres.map((n) => <li>{n}</li>);
{"// elements → [
  • 1
  • ,
  • 2
  • ,
  • 3
  • ]"}
    💡
    .map() ne modifie pas le tableau d'origine. Il retourne toujours un nouveau tableau. C'est un principe fondamental en React : on ne mute jamais les données directement, on crée toujours de nouvelles valeurs.
    02 — .map()

    Rendre des listes avec .map()

    .map() est la méthode principale pour transformer un tableau de données en tableau de composants JSX. Elle s'utilise directement dans le return, entre accolades.

    1
    Tableau simple — liste de strings
    Le cas le plus basique pour commencer
    ListeSimple.jsxbasique
    const filieres = ['Informatique', 'Réseaux', 'Cybersécurité', 'Cloud'];
    
    function ListeFilieres() {
      return (
        <ul>
          {filieres.map((filiere) => (
            <li key={filiere}>{filiere}</li>
          ))}
        </ul>
      );
    }
    {"// Affiche : Informatique / Réseaux / Cybersécurité / Cloud"}
    Pour les strings uniques et stables, on peut utiliser la string elle-même comme key. Avec des objets, on préférera toujours un id.
    2
    Tableau d'objets — le cas le plus courant
    Passer chaque objet comme props à un composant
    ListeEtudiants.jsxobjets
    const etudiants = [
      { id: 1, nom: 'Fatou Diallo',   filiere: 'Informatique', note: 17 },
      { id: 2, nom: 'Moussa Sow',     filiere: 'Réseaux',       note: 13 },
      { id: 3, nom: 'Aminata Dieng', filiere: 'Cybersécurité', note: 19 },
    ];
    
    function CarteEtudiant({ nom, filiere, note }) {
      return (
        <div className="carte">
          <h3>{nom}</h3>
          <p>{filiere} — {note}/20</p>
        </div>
      );
    }
    
    function ListeEtudiants() {
      return (
        <div className="grille">
          {etudiants.map((etudiant) => (
            <CarteEtudiant
              key={etudiant.id}
              nom={etudiant.nom}
              filiere={etudiant.filiere}
              note={etudiant.note}
            />
          ))}
        </div>
      );
    }
    On passe chaque propriété de l'objet comme une prop distincte. On peut aussi utiliser le spread operator : ...etudiant — mais attention, ça passe toutes les propriétés d'un coup, moins explicite.
    3
    Utiliser l'index comme deuxième paramètre
    .map() fournit aussi la position dans le tableau
    Classement.jsxindex
    function Classement({ etudiants }) {
      return (
        <ol>
          {etudiants.map((etudiant, index) => (
            <li key={etudiant.id}>
              <span>#{index + 1}</span> — {etudiant.nom} ({etudiant.note}/20)
            </li>
          ))}
        </ol>
      );
    }
    {"// index vaut 0, 1, 2... — on ajoute +1 pour afficher 1, 2, 3..."}
    L'index est utile pour afficher un numéro de position. En revanche, ne jamais l'utiliser comme key — on explique pourquoi dans le chapitre suivant.
    ⚠️
    Parenthèses vs accolades dans le .map() :
    etudiant => ( <div>...</div> ) — parenthèses pour retourner du JSX multiligne
    etudiant => { return <div>...</div> } — accolades avec return explicite
    Les deux fonctionnent. Les parenthèses sont plus courtes et plus répandues en React.
    03 — La prop key

    Pourquoi key est obligatoire

    key est une prop spéciale que React utilise en interne pour identifier chaque élément d'une liste. Sans elle, React ne peut pas savoir quel élément a changé, été ajouté ou supprimé — ce qui provoque des bugs.

    Ce que React fait avec key — sous le capot
    React compare les listes avant et après chaque mise à jour

    À chaque mise à jour, React compare l'ancienne liste avec la nouvelle. La key lui permet de faire correspondre chaque ancien élément avec son nouvel équivalent, au lieu de tout recréer depuis zéro.

    AVANT (liste initiale)
    key=1 → Fatou
    key=2 → Moussa
    key=3 → Aminata
    APRÈS (Moussa supprimé)
    key=1 → Fatou ✓ identique
    key=2 → disparu ✗ supprimé
    key=3 → Aminata ✓ identique

    Grâce aux keys, React sait exactement ce qui a changé → mise à jour minimale et correcte

    ✗ Sans key — avertissement React
    {"// Warning dans la console :"}
    {"// Each child in a list should"}
    {"// have a unique 'key' prop."}
    {etudiants.map((e) => (
      <CarteEtudiant
        nom={e.nom}
      />
    ))}
    ✓ Avec key — correct
    {"// key sur l'élément racine du .map()"}
    {etudiants.map((e) => (
      <CarteEtudiant
        key={e.id}
        nom={e.nom}
      />
    ))}
    🚨
    N'utilisez jamais l'index comme key si la liste peut changer.
    Si on supprime ou réordonne des éléments, les index changent — React confond les éléments et produit des bugs visuels ou de comportement imprévisibles.
    key-index.jsxà éviter
    {"// ❌ Dangereux si la liste change d'ordre ou si on supprime"}
    {etudiants.map((e, index) => <Carte key={index} />)}
    
    {"// ✓ Toujours utiliser un identifiant stable et unique"}
    {etudiants.map((e) => <Carte key={e.id} />)}
    {articles.map((a) => <Article key={a.slug} />)}
    {villes.map((v) => <Ville key={v.codePostal} />)}
    💡
    key ne se passe pas en prop. La key est consommée par React lui-même et n'est pas accessible dans le composant enfant via props. Si vous avez besoin de l'id dans le composant, passez-le aussi en prop normale : <Carte key={e.id} id={e.id} />
    04 — .filter()

    Afficher une partie de la liste avec .filter()

    .filter() permet de ne garder que les éléments qui satisfont une condition. On l'enchaîne souvent avec .map() pour filtrer d'abord, puis transformer.

    Rappel JavaScript — .filter()
    .filter() retourne un nouveau tableau avec seulement les éléments correspondants
    rappel-filter.jsJavaScript pur
    const notes = [17, 8, 13, 5, 19, 9];
    
    {"// Garder seulement les notes >= 10"}
    const admis = notes.filter((note) => note >= 10);
    {"// admis → [17, 13, 19]"}
    
    {"// .filter() retourne true (garder) ou false (supprimer)"}
    {"// Le tableau d'origine n'est jamais modifié"}
    →
    Chaîner .filter() et .map() en React
    Filtrer d'abord, puis transformer en JSX
    EtudiantsAdmis.jsxfilter + map
    const etudiants = [
      { id: 1, nom: 'Fatou',   note: 17, filiere: 'Info' },
      { id: 2, nom: 'Moussa',   note: 8,  filiere: 'Réseaux' },
      { id: 3, nom: 'Aminata', note: 19, filiere: 'Info' },
      { id: 4, nom: 'Omar',    note: 7,  filiere: 'Info' },
    ];
    
    function EtudiantsAdmis() {
      return (
        <div>
          <h2>Étudiants admis</h2>
    
          {etudiants
            .filter((e) => e.note >= 10)         {"← garder note >= 10"}
            .map((e) => (                              {"← transformer en JSX"}
              <p key={e.id}>{e.nom} — {e.note}/20</p>
            ))
          }
    
        </div>
      );
    }
    {"// Affiche uniquement : Fatou (17) et Aminata (19)"}
    L'ordre compte : toujours .filter() avant .map(). Filtrer d'abord réduit le nombre d'éléments à transformer — c'est plus efficace.
    Filtres multiples et combinés
    Plusieurs .filter() enchaînés ou une condition combinée
    FiltresMultiples.jsxconditions
    function EtudiantsInfoAdmis() {
      return (
        <ul>
          {etudiants
            {"// Méthode 1 : deux .filter() enchaînés (lisible)"}
            .filter((e) => e.filiere === 'Info')
            .filter((e) => e.note >= 10)
    
            {"// Méthode 2 : une condition combinée (plus compact)"}
            {"// .filter((e) => e.filiere === 'Info' && e.note >= 10)"}
    
            .map((e) => <li key={e.id}>{e.nom}</li>)
          }
        </ul>
      );
    }
    ✓
    Pensez à gérer le cas liste vide après filter. Si le filtre ne garde aucun élément, .map() retourne un tableau vide et rien ne s'affiche. Combinez avec le rendu conditionnel de S3 pour afficher un message "Aucun résultat".
    05 — .sort()

    Trier les listes avec .sort()

    .sort() permet de réordonner les éléments d'un tableau. Attention : contrairement à .map() et .filter(), .sort() modifie le tableau d'origine — il faut donc en faire une copie d'abord en React.

    🚨
    Règle absolue : ne jamais muter les données en React. .sort() modifie le tableau directement. Toujours créer une copie avec [...tableau] ou .slice() avant de trier.
    ✗ Mutation directe — dangereux
    {"// ❌ Modifie le tableau original !"}
    {etudiants
      .sort((a, b) => b.note - a.note)
      .map((e) => <li key={e.id}>{e.nom}</li>)
    }
    ✓ Copie d'abord — correct
    {"// ✓ Spread pour copier, puis trier la copie"}
    {[...etudiants]
      .sort((a, b) => b.note - a.note)
      .map((e) => <li key={e.id}>{e.nom}</li>)
    }
    Les patterns de tri les plus courants
    Trier par nombre, par texte, dans les deux sens
    tris.jsxpatterns
    {"// Trier par note — croissant (du plus bas au plus haut)"}
    [...etudiants].sort((a, b) => a.note - b.note)
    
    {"// Trier par note — décroissant (meilleur en premier)"}
    [...etudiants].sort((a, b) => b.note - a.note)
    
    {"// Trier par nom — alphabétique"}
    [...etudiants].sort((a, b) => a.nom.localeCompare(b.nom))
    
    {"// Trier par nom — ordre inverse (Z → A)"}
    [...etudiants].sort((a, b) => b.nom.localeCompare(a.nom))
    
    {"// Enchaîner avec .map() — classement du meilleur"}
    {[...etudiants]
      .sort((a, b) => b.note - a.note)
      .map((e, i) => (
        <p key={e.id}>#{i+1} {e.nom} — {e.note}/20</p>
      ))
    }
    💡
    localeCompare pour les textes. Ne jamais utiliser a.nom - b.nom pour trier des chaînes (retourne NaN). Utiliser a.nom.localeCompare(b.nom) qui gère correctement les accents et la casse selon la langue.
    06 — Tout combiner

    Filter + Sort + Map + Conditionnel

    En pratique, on combine toutes ces méthodes. Voici comment construire une liste complète avec filtre, tri, affichage conditionnel du vide — le pattern qu'on retrouve dans toute vraie application.

    Exemple complet — Catalogue d'étudiants filtré et trié
    Préparer les données avant le return, puis afficher
    CatalogueEtudiants.jsxComplet
    const etudiants = [
      { id: 1, nom: 'Fatou',   note: 17, filiere: 'Info',    boursier: true  },
      { id: 2, nom: 'Moussa',  note: 8,  filiere: 'Réseaux', boursier: false },
      { id: 3, nom: 'Aminata',note: 19, filiere: 'Info',    boursier: true  },
      { id: 4, nom: 'Omar',   note: 14, filiere: 'Info',    boursier: false },
      { id: 5, nom: 'Aïssatou',note: 7, filiere: 'Réseaux', boursier: true  },
    ];
    
    function CatalogueEtudiants({ filiere = 'Info', noteMin = 10 }) {
    
      {"// 1. Préparer les données AVANT le return (plus lisible)"}
      const resultat = [...etudiants]
        .filter((e) => e.filiere === filiere)
        .filter((e) => e.note >= noteMin)
        .sort((a, b) => b.note - a.note);
    
      {"// 2. Guard — liste vide"}
      if (resultat.length === 0) {
        return <p>Aucun étudiant pour ces critères.</p>;
      }
    
      {"// 3. Affichage normal"}
      return (
        <div>
          <h2>{filiere} — {resultat.length} étudiant(s) admis</h2>
    
          {resultat.map((e, i) => (
            <div key={e.id} className="carte">
              <span>#{i + 1}</span>
              <strong>{e.nom}</strong>
              <span>{e.note}/20</span>
              {e.boursier && <span>🎓</span>}
            </div>
          ))}
        </div>
      );
    }
    
    {"// Utilisations depuis App :"}
    <CatalogueEtudiants filiere="Info" noteMin={12} />
    <CatalogueEtudiants filiere="Réseaux" />

    Récapitulatif — les trois méthodes
    MéthodeRôleRetourneMute l'original ?
    .map(fn)Transformer chaque élémentNouveau tableau de même tailleNon ✓
    .filter(fn)Garder certains élémentsNouveau tableau (taille ≤)Non ✓
    .sort(fn)RéordonnerLe même tableau réordonnéOui ✗ — copier d'abord
    07 — Validation

    Quiz & Travaux pratiques

    4 questions pour valider votre compréhension, puis 3 exercices pratiques progressifs.

    1. Pourquoi la prop key est-elle obligatoire sur les éléments d'un .map() ?
    2. Quelle valeur choisir comme key ?
    3. Comment trier un tableau d'étudiants par note décroissante sans muter l'original ?
    4. Dans quel ordre enchaîner les méthodes pour filtrer les admis (note >= 10), les trier par note et les afficher ?

    S4 — Travaux Pratiques · 3 exercices
    Données dynamiques en action
    1
    Liste de produits avec .map()
    Créez un tableau produits de 5 objets avec id, nom, prix, stock. Créez un composant ProduitItem qui reçoit ces props. Créez ListeProduits qui utilise .map() pour afficher tous les produits avec la key correcte. Pour chaque produit, affichez "Disponible" ou "Rupture" selon stock (rendu conditionnel S3).
    2
    Tableau de notes avec filtre et tri
    Partez d'un tableau de 8 étudiants avec id, nom, note, filiere. Créez trois composants séparés : TousLesEtudiants (tous, triés alphabétiquement), EtudiantsAdmis (note >= 10, triés par note décroissante), EtudiantsParFiliere (reçoit une prop filiere et filtre en conséquence). Gérez le cas "aucun résultat" dans chaque composant.
    3
    Classement complet avec médailles
    Reprenez le tableau d'étudiants. Créez Classement qui trie par note décroissante et affiche le rang (1, 2, 3…). Utilisez && pour afficher 🥇 devant le 1er, 🥈 devant le 2e, 🥉 devant le 3e. Affichez la mention avec une fonction externe : Très bien (>= 16), Bien (>= 14), Assez bien (>= 12), Passable (>= 10), Insuffisant (< 10). Affichez le total des étudiants admis sous le classement.