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().
{ id:1, nom:'Fatou' },
{ id:2, nom:'Moussa' },
{ id:3, nom:'Aminata' }
]
Un tableau JS de 3 objets → 3 composants React générés automatiquement
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 ]"}
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.
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"}
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> ); }
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..."}
etudiant => ( <div>...</div> ) — parenthèses pour retourner du JSX multiligneetudiant => { return <div>...</div> } — accolades avec return expliciteLes deux fonctionnent. Les parenthèses sont plus courtes et plus répandues en React.
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.
À 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.
Grâce aux keys, React sait exactement ce qui a changé → mise à jour minimale et correcte
{"// Warning dans la console :"} {"// Each child in a list should"} {"// have a unique 'key' prop."} {etudiants.map((e) => ( <CarteEtudiant nom={e.nom} /> ))}
{"// key sur l'élément racine du .map()"} {etudiants.map((e) => ( <CarteEtudiant key={e.id} nom={e.nom} /> ))}
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.
{"// ❌ 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} />)}
<Carte key={e.id} id={e.id} />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.
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é"}
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)"}
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> ); }
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.
[...tableau] ou .slice() avant de trier.
{"// ❌ Modifie le tableau original !"} {etudiants .sort((a, b) => b.note - a.note) .map((e) => <li key={e.id}>{e.nom}</li>) }
{"// ✓ Spread pour copier, puis trier la copie"} {[...etudiants] .sort((a, b) => b.note - a.note) .map((e) => <li key={e.id}>{e.nom}</li>) }
{"// 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> )) }
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.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.
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" />
| Méthode | Rôle | Retourne | Mute l'original ? |
|---|---|---|---|
.map(fn) | Transformer chaque élément | Nouveau tableau de même taille | Non ✓ |
.filter(fn) | Garder certains éléments | Nouveau tableau (taille ≤) | Non ✓ |
.sort(fn) | Réordonner | Le même tableau réordonné | Oui ✗ — copier d'abord |
Quiz & Travaux pratiques
4 questions pour valider votre compréhension, puis 3 exercices pratiques progressifs.
key est-elle obligatoire sur les éléments d'un .map() ?key ?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).
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.
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.