Semaine 2 · React Débutants

Props & Composants réutilisables

Comment faire communiquer les composants entre eux, passer des données, les déstructurer proprement, et composer une vraie interface modulaire.

5 chapitres
3 exercices pratiques
Quiz de validation
MR Kane — React S2
01 — Les props

Passer des données entre composants

Les props (abréviation de "properties") sont le mécanisme principal de communication en React. Un composant parent envoie des données à ses composants enfants via des attributs, exactement comme en HTML.

Flux de données parent → enfant
App (parent)
nom="Fatou" age={22} ville="Dakar"
CarteProfil (enfant)

Les données ne circulent que dans un sens : parent → enfant. C'est ce qu'on appelle le flux unidirectionnel.

Côté parent — App.jsx
Passer des props comme des attributs HTML
App.jsxParent
function App() {
  return (
    <div>
      {"// On passe les props comme des attributs"}
      <CarteProfil
        nom="Fatou Diallo"
        age={22}
        ville="Dakar"
        actif={true}
      />

      {"// On peut réutiliser le même composant avec d'autres données"}
      <CarteProfil
        nom="Moussa Sow"
        age={28}
        ville="Saint-Louis"
        actif={false}
      />
    </div>
  );
}
Côté enfant — CarteProfil.jsx
Recevoir et utiliser les props

L'enfant reçoit toutes les props dans un seul objet, par convention nommé props. On y accède avec la notation pointée.

CarteProfil.jsxEnfant
function CarteProfil(props) {
  {"// props est un objet qui contient tout ce que le parent a envoyé"}
  {"// props = { nom: 'Fatou Diallo', age: 22, ville: 'Dakar', actif: true }"}

  return (
    <div className="carte">
      <h2>{props.nom}</h2>
      <p>Âge : {props.age} ans</p>
      <p>Ville : {props.ville}</p>
      <p>Statut : {props.actif ? 'Actif' : 'Inactif'}</p>
    </div>
  );
}

export default CarteProfil;
💡
Types de valeurs qu'on peut passer en props :
Texte : nom="Fatou" — Nombre : age={22} — Booléen : actif={true} — Tableau : hobbies={['sport','musique']} — Objet : profil={{nom:'Fatou'}} — Fonction : onClick={handleClick}
⚠️
Les props sont en lecture seule. Un composant enfant ne doit jamais modifier ses props directement. Si vous avez besoin de modifier une valeur, c'est le rôle de useState que vous verrez en S3.

Exemple complet — Liste de cartes
Réutiliser un composant plusieurs fois

C'est là tout l'intérêt des props : écrire le composant une seule fois et l'utiliser avec des données différentes.

App.jsxComplet
const etudiants = [
  { id: 1, nom: 'Fatou', note: 17, ville: 'Dakar' },
  { id: 2, nom: 'Moussa', note: 14, ville: 'Thiès' },
  { id: 3, nom: 'Aminata', note: 19, ville: 'Ziguinchor' },
];

function App() {
  return (
    <div>
      {"// .map() pour créer un composant par étudiant"}
      {etudiants.map((etudiant) => (
        <CarteEtudiant
          key={etudiant.id}
          nom={etudiant.nom}
          note={etudiant.note}
          ville={etudiant.ville}
        />
      ))}
    </div>
  );
}
02 — Déstructuration

Simplifier les props avec la déstructuration

Maintenant qu'on sait ce que sont les props, on peut simplifier le code avec la déstructuration JavaScript. Au lieu d'écrire props.nom, props.age... on extrait directement les valeurs.

❌ Avant (sans déstructuration)
function CarteProfil(props) {
  return (
    <div>
      <h2>{props.nom}</h2>
      <p>{props.age} ans</p>
      <p>{props.ville}</p>
    </div>
  );
}
✓ Après (avec déstructuration)
function CarteProfil({ nom, age, ville }) {
  return (
    <div>
      <h2>{nom}</h2>
      <p>{age} ans</p>
      <p>{ville}</p>
    </div>
  );
}
💡
Ce qui se passe en coulisses : la syntaxe { nom, age, ville } dans les paramètres est du JavaScript pur. React passe un objet props, et on le déstructure directement. C'est équivalent à écrire :
const { nom, age, ville } = props; — mais en plus compact.
Étape par étape — comprendre la déstructuration JS
La déstructuration vient de JavaScript, pas de React
exemple.jsJavaScript pur
{"// Un objet ordinaire"}
const personne = { nom: 'Fatou', age: 22, ville: 'Dakar' };

{"// Méthode classique"}
const nom   = personne.nom;
const age   = personne.age;
const ville = personne.ville;

{"// Déstructuration — même résultat, une seule ligne"}
const { nom, age, ville } = personne;

{"// Dans une fonction — même principe"}
function afficher({ nom, age }) {
  console.log(`${nom} a ${age} ans`);
}
afficher(personne); // "Fatou a 22 ans"
Déstructuration avancée — renommer une prop
On peut renommer au moment de déstructurer
CarteProfil.jsxRenommage
{"// Si la prop s'appelle 'nomComplet' mais qu'on veut l'appeler 'nom' localement"}
function CarteProfil({ nomComplet: nom, age }) {
  return <h2>{nom}</h2>; {"// on utilise 'nom'"}
}

{"// Le parent passe toujours nomComplet"}
<CarteProfil nomComplet="Fatou Diallo" age={22} />
✓
Bonne pratique : utilisez toujours la déstructuration dans vos composants. Le code est plus lisible, plus court, et on voit immédiatement quelles données le composant utilise.
03 — Valeurs par défaut

Gérer les props optionnelles

Toutes les props ne sont pas toujours fournies. Les valeurs par défaut permettent de définir ce qu'affiche le composant quand une prop est absente, évitant les erreurs et les affichages vides.

Syntaxe — valeur par défaut dans la déstructuration
On assigne la valeur par défaut avec = directement
BoutonAction.jsxValeurs par défaut
function BoutonAction({
  texte     = 'Cliquez ici',   {"// valeur par défaut si texte absent"}
  couleur   = 'bleu',           {"// valeur par défaut si couleur absente"}
  desactive = false,           {"// valeur par défaut si desactive absent"}
  onClick               {"// pas de défaut : sera undefined si absent"}
}) {
  return (
    <button
      className={`btn btn-${couleur}`}
      disabled={desactive}
      onClick={onClick}
    >
      {texte}
    </button>
  );
}
Utilisation sans toutes les props
{"// Aucune prop → tout par défaut"}
<BoutonAction />
{"// Affiche : 'Cliquez ici', bleu, actif"}

{"// Seulement le texte"}
<BoutonAction texte="Valider" />
{"// couleur='bleu', desactive=false"}
Surcharger les valeurs par défaut
{"// On peut toujours écraser le défaut"}
<BoutonAction
  texte="Supprimer"
  couleur="rouge"
  desactive={true}
/>
{"// Affiche : 'Supprimer', rouge, inactif"}
⚠️
Attention : si la prop vaut null, la valeur par défaut ne s'applique pas. Elle ne s'applique que si la prop est undefined (c'est-à-dire absente). Faites attention à cette nuance dans vos composants.
Exemple réel — CarteEtudiant
Combinaison de props requises et optionnelles
CarteEtudiant.jsxExemple
function CarteEtudiant({
  nom,                      {"// REQUISE — pas de défaut"}
  filiere,                  {"// REQUISE — pas de défaut"}
  note       = 0,           {"// optionnelle, défaut : 0"}
  promotion  = '2024-2025', {"// optionnelle, défaut : année courante"}
  boursier   = false,       {"// optionnelle, défaut : non boursier"}
}) {
  return (
    <div className="carte-etudiant">
      <h3>{nom}</h3>
      <p>{filiere} — Promo {promotion}</p>
      <p>Note : {note}/20</p>
      {boursier && <span className="badge-bourse">Boursier</span>}
    </div>
  );
}
04 — La prop children

Imbriquer du contenu avec children

children est une prop spéciale fournie automatiquement par React. Elle contient tout ce qu'on place entre les balises ouvrante et fermante d'un composant. C'est ce qui permet de créer des composants "conteneurs".

Analogie — comme les balises HTML
En HTML, on imbrique naturellement le contenu
analogie.htmlHTML classique
<!-- div est un "conteneur", son contenu c'est le "children" -->
<div class="carte">
  <h2>Titre</h2>
  <p>Description...</p>
</div>

<!-- En React, children joue ce même rôle pour vos propres composants -->
Composant Encadre — définition
function Encadre({ titre, children }) {
  return (
    <div className="encadre">
      <h3 className="encadre-titre">
        {titre}
      </h3>
      <div className="encadre-corps">
        {children} {"← contenu imbriqué"}
      </div>
    </div>
  );
}
Utilisation du composant Encadre
{"// Tout ce qui est entre les balises"}
{"// devient automatiquement 'children'"}
<Encadre titre="Mes notes">
  <p>Maths : 16/20</p>
  <p>React : 18/20</p>
  <p>JS : 17/20</p>
</Encadre>
💡
children peut être n'importe quoi : du texte simple, des balises HTML, d'autres composants React, un tableau de composants… React gère tout ça. C'est ce qui rend les composants conteneurs très flexibles.
Cas d'usage concrets
Exemples réels de composants avec children
App.jsxExemples
{"// 1. Modal — le contenu varie selon l'usage"}
<Modal titre="Confirmation">
  <p>Voulez-vous vraiment supprimer cet élément ?</p>
  <BoutonAction texte="Confirmer" couleur="rouge" />
</Modal>

{"// 2. Carte de mise en page réutilisable"}
<Carte>
  <CarteEtudiant nom="Fatou" filiere="Informatique" />
</Carte>

{"// 3. Avec du texte simple"}
<Alerte type="info">
  Votre profil a bien été mis à jour.
</Alerte>
05 — Composition

Assembler une interface par composition

La composition consiste à assembler des petits composants simples pour construire des interfaces complexes. C'est le cœur de la philosophie React : chaque composant fait une seule chose, bien.

Architecture — exemple d'une page Étudiants
Découper une interface en composants
structure.jsxArchitecture
{"/*"}
{"  App"}
{"  ├── Entete"}
{"  │     └── Logo + Navigation"}
{"  ├── SectionEtudiants"}
{"  │     ├── TitreSection (titre='Nos étudiants')"}
{"  │     └── GrilleEtudiants"}
{"  │           ├── CarteEtudiant (nom='Fatou' ...)"}
{"  │           ├── CarteEtudiant (nom='Moussa' ...)"}
{"  │           └── CarteEtudiant (nom='Aminata' ...)"}
{"  └── PiedPage"}
{"*/"}

function App() {
  return (
    <div>
      <Entete />
      <SectionEtudiants />
      <PiedPage />
    </div>
  );
}
Implémentation complète de SectionEtudiants
Tout s'assemble : props, map, children, valeurs par défaut
SectionEtudiants.jsxComplet
const donnees = [
  { id: 1, nom: 'Fatou Diallo',   filiere: 'Informatique', note: 17, boursier: true  },
  { id: 2, nom: 'Moussa Sow',     filiere: 'Réseaux',       note: 14, boursier: false },
  { id: 3, nom: 'Aminata Dieng', filiere: 'Cybersécurité', note: 19, boursier: true  },
];

function TitreSection({ texte = 'Section', sous = '' }) {
  return (
    <div>
      <h2>{texte}</h2>
      {sous && <p>{sous}</p>}
    </div>
  );
}

function CarteEtudiant({ nom, filiere, note = 0, boursier = false }) {
  return (
    <div className="carte">
      <h3>{nom}</h3>
      <p>{filiere}</p>
      <p>{note}/20</p>
      {boursier && <span>🎓 Boursier</span>}
    </div>
  );
}

function SectionEtudiants() {
  return (
    <section>
      <TitreSection
        texte="Nos étudiants"
        sous="Promotion 2024-2025"
      />

      <div className="grille">
        {donnees.map((e) => (
          <CarteEtudiant
            key={e.id}
            nom={e.nom}
            filiere={e.filiere}
            note={e.note}
            boursier={e.boursier}
          />
        ))}
      </div>
    </section>
  );
}

Récapitulatif S2 — tout ce qu'on a vu
ConceptSyntaxeRôle
Props (de base)function C(props) { props.nom }Recevoir les données du parent
Déstructurationfunction C({ nom, age })Accéder aux props directement
Valeur par défaut{ couleur = 'bleu' }Gérer les props optionnelles
children{ children } + {children} dans le JSXImbriquer du contenu libre
CompositionAssembler plusieurs composantsConstruire des interfaces modulaires
06 — Validation

Quiz & Travaux pratiques

3 questions pour valider votre compréhension, suivies de 3 exercices pratiques pour mettre tout ça en œuvre.

1. Que contient l'objet props reçu par un composant ?
2. Quelle est la bonne syntaxe pour déstructurer les props nom et age avec une valeur par défaut pour age ?
3. Comment accéder à children dans un composant ?

S2 — Travaux Pratiques · 3 exercices
Mettez en pratique !
1
Composant CarteProduit réutilisable avec props
Créez un composant CarteProduit qui reçoit : nom, prix, stock (défaut : 0), promo (défaut : false). Affichez le prix barré si promo est vrai. Affichez "Rupture de stock" si stock vaut 0. Dans App, utilisez ce composant 4 fois avec des données différentes via .map() sur un tableau.
2
Composant Encadre avec la prop children
Créez un composant Encadre qui accepte titre et couleur (défaut : 'bleu') et affiche children à l'intérieur. Utilisez ce composant pour encadrer : une liste de produits, un message d'alerte, et un formulaire. Le même composant doit fonctionner pour les 3 cas.
3
Mini page composée — Catalogue
Composez une page complète avec : Entete (titre + sous-titre en props), FiltreBarre (texte de recherche en props), GrilleProduits (liste de produits → affiche plusieurs CarteProduit), et PiedPage (texte en children). Toutes les données viennent du composant App via props. Pas de useState pour l'instant.