Semaine 3 · React Débutants

Rendu conditionnel

Afficher ou masquer du contenu selon une condition : la compétence qui donne vie à vos interfaces. Quatre méthodes, chacune avec son cas d'usage.

4 méthodes
Pièges courants
3 exercices pratiques
Quiz de validation
Prérequis : S1 — JSX & Composants · S2 — Props & déstructuration
01 — Concept

Pourquoi le rendu conditionnel ?

Une interface n'est jamais figée. Elle change selon l'utilisateur, ses actions, les données reçues. Le rendu conditionnel permet d'afficher des éléments différents selon l'état du monde.

Exemples du quotidien
Des conditions partout dans une interface réelle
Connexion
Afficher "Bonjour Fatou" si connecté, "Connexion" sinon
Stock produit
Afficher "Ajouter" si en stock, "Rupture" sinon
Chargement
Afficher "Chargement…" pendant la requête, puis les données
Les 4 méthodes — choisir la bonne selon le contexte
Méthode 1 — if / return
Retourner un composant entièrement différent selon une condition. Le plus lisible pour des cas complexes.
Méthode 2 — ternaire ? :
Choisir entre deux valeurs JSX au sein du return. Idéal quand les deux cas sont courts.
Méthode 3 — opérateur &&
Afficher quelque chose uniquement si la condition est vraie. Rien à afficher dans le cas contraire.
Méthode 4 — variable JSX
Stocker le JSX dans une variable avant le return. Utile quand la logique est plus complexe.
💡
Pas de if dans le JSX directement. JSX n'accepte que des expressions (des choses qui retournent une valeur). Le mot-clé if est une instruction, pas une expression — il ne peut pas être utilisé entre accolades { }. C'est pourquoi on a besoin d'autres syntaxes à l'intérieur du JSX.
02 — Méthode 1

Retour anticipé avec if / return

La méthode la plus lisible. On vérifie la condition avant le return principal et on retourne un JSX différent si besoin. Parfaite pour les cas où les deux rendus sont très différents.

1
if + return anticipé
Retourner directement sans atteindre le return principal
StatutEtudiant.jsxif / return
function StatutEtudiant({ nom, admis, note }) {

  {"// Cas 1 : données manquantes — retour anticipé"}
  if (!nom) {
    return <p>Aucun étudiant sélectionné.</p>;
  }

  {"// Cas 2 : non admis — JSX complètement différent"}
  if (!admis) {
    return (
      <div className="carte-rouge">
        <h3>{nom}</h3>
        <p>Non admis — note : {note}/20</p>
        <p>Passage en rattrapage requis.</p>
      </div>
    );
  }

  {"// Cas 3 : admis — retour principal"}
  return (
    <div className="carte-verte">
      <h3>{nom}</h3>
      <p>Admis — note : {note}/20</p>
      <p>Félicitations !</p>
    </div>
  );
}
Quand l'utiliser : quand les deux cas ont des structures JSX vraiment différentes, ou pour gérer des cas d'erreur / vide avant d'afficher le contenu principal.
✓
Bonne pratique — "Guard clauses". Mettre les cas d'erreur ou les cas vides en premier avec un return anticipé. Le return principal devient ainsi le cas "normal", plus facile à lire. C'est un pattern utilisé dans tout JavaScript professionnel.
Cas d'usage concret — Chargement de données
Pattern très courant : loading → erreur → données
ListeEtudiants.jsxGuard clauses
function ListeEtudiants({ etudiants, chargement, erreur }) {

  {"// Guard 1 — encore en train de charger"}
  if (chargement) {
    return <p>Chargement en cours…</p>;
  }

  {"// Guard 2 — une erreur est survenue"}
  if (erreur) {
    return <p>Erreur : {erreur.message}</p>;
  }

  {"// Guard 3 — liste vide"}
  if (etudiants.length === 0) {
    return <p>Aucun étudiant trouvé.</p>;
  }

  {"// Cas normal — tout va bien, on affiche"}
  return (
    <ul>
      {etudiants.map(e => <li key={e.id}>{e.nom}</li>)}
    </ul>
  );
}
03 — Méthode 2

Choisir entre deux rendus avec le ternaire

L'opérateur ternaire condition ? siVrai : siFaux est une expression JavaScript qui retourne une valeur — donc utilisable directement entre accolades dans le JSX.

2
Ternaire — condition ? A : B
Choisir entre deux JSX à l'intérieur du return
BoutonConnexion.jsxternaire
function BoutonConnexion({ connecte, nom }) {
  return (
    <header>
      <h1>Mon Application</h1>

      {"// Ternaire inline dans le JSX"}
      {connecte
        ? <span>Bonjour, {nom} !</span>
        : <button>Se connecter</button>
      }

    </header>
  );
}
Quand l'utiliser : quand on a exactement deux cas distincts, tous les deux courts. Si un cas retourne null ou rien, préférer &&.
Ternaire sur du texte ou des valeurs
Pas uniquement pour du JSX — aussi pour des valeurs dynamiques
CarteEtudiant.jsxvaleurs dynamiques
function CarteEtudiant({ nom, note, boursier }) {
  return (
    <div className={note >= 10 ? 'carte-verte' : 'carte-rouge'}>

      <h3>{nom}</h3>

      {"// Ternaire pour le texte"}
      <p>Statut : {note >= 10 ? 'Admis' : 'Ajourné'}</p>

      {"// Ternaire pour une classe CSS"}
      <span className={boursier ? 'badge-or' : 'badge-gris'}>
        {boursier ? 'Boursier' : 'Non boursier'}
      </span>

    </div>
  );
}
✗ Ternaires imbriqués — illisible
{"// À éviter absolument !"}
{note >= 16
  ? 'Très bien'
  : note >= 14
    ? 'Bien'
    : note >= 12
      ? 'Assez bien'
      : 'Passable'
}
✓ Fonction externe — lisible
{"// Sortir la logique du JSX"}
function mention(note) {
  if (note >= 16) return 'Très bien';
  if (note >= 14) return 'Bien';
  if (note >= 12) return 'Assez bien';
  return 'Passable';
}

{"// Dans le JSX : propre"}
{mention(note)}
⚠️
Règle d'or : si le ternaire dépasse 2 lignes ou devient difficile à lire, sortez la logique dans une fonction ou utilisez la méthode if / return. Le JSX doit rester déclaratif et lisible.
04 — Méthode 3

Afficher uniquement si avec &&

L'opérateur && permet d'afficher quelque chose uniquement si une condition est vraie. Si la condition est fausse, rien n'est affiché. C'est le cas le plus courant en React.

3
Opérateur && — afficher ou rien
Cas où le siFaux est vide (pas d'alternative)
ProfilUtilisateur.jsx&&
function ProfilUtilisateur({ nom, boursier, messages, admin }) {
  return (
    <div>
      <h2>{nom}</h2>

      {"// Afficher le badge seulement si boursier est true"}
      {boursier && <span className="badge">Boursier</span>}

      {"// Afficher la section messages seulement s'il y en a"}
      {messages.length > 0 && (
        <p>Vous avez {messages.length} message(s) non lu(s)</p>
      )}

      {"// Afficher le panneau admin seulement si admin est true"}
      {admin && <PanneauAdmin />}

    </div>
  );
}
Quand l'utiliser : quand il n'y a qu'un seul cas à afficher et rien dans l'autre cas. Équivalent d'un ternaire avec null à la fin.
🚨
Piège classique avec && et les nombres !
Si la condition est le chiffre 0, React affiche 0 à l'écran au lieu de rien.

piège.jsxAttention !
{"// ❌ PIÈGE — si panier.length vaut 0, React affiche '0' !"}
{panier.length && <p>{panier.length} article(s)</p>}

{"// ✓ CORRECT — convertir en booléen avec > 0 ou Boolean()"}
{panier.length > 0 && <p>{panier.length} article(s)</p>}
{!!panier.length && <p>{panier.length} article(s)</p>}
Méthode 4 — Variable JSX
Stocker du JSX dans une variable avant le return

Quand la logique est trop complexe pour un ternaire mais qu'on ne veut pas un return anticipé, on peut stocker le JSX dans une variable let et l'utiliser dans le return.

Notification.jsxvariable JSX
function Notification({ type, message }) {
  {"// On prépare le JSX dans une variable"}
  let icone;

  if (type === 'succes')  icone = <span>✓</span>;
  if (type === 'erreur')  icone = <span>✗</span>;
  if (type === 'info')    icone = <span>ℹ</span>;
  if (type === 'alerte')  icone = <span>⚠</span>;

  return (
    <div className={`notif notif-${type}`}>
      {icone}  {"← variable JSX utilisée ici"}
      <p>{message}</p>
    </div>
  );
}
05 — Pièges & bonnes pratiques

Les erreurs à ne pas commettre

Le rendu conditionnel est simple en théorie mais présente quelques pièges classiques que tous les débutants rencontrent. Les connaître à l'avance vous évitera des heures de débogage.

Piège 1 — if directement dans le JSX
Le mot-clé if est une instruction, pas une expression
✗ Ne fonctionne pas
return (
  <div>
    {"// ❌ ERREUR DE SYNTAXE"}
    {if (connecte) {
      <p>Bonjour</p>
    }}
  </div>
);
✓ Correct
return (
  <div>
    {"// ✓ ternaire ou &&"}
    {connecte && <p>Bonjour</p>}

    {"// ✓ ou ternaire"}
    {connecte ? <p>Bonjour</p> : null}
  </div>
);
Piège 2 — Le 0 avec &&
Les valeurs "falsy" numériques s'affichent
piège-zero.jsxAttention
{"// ❌ Si nbMessages vaut 0 → affiche '0' dans la page !"}
{nbMessages && <span>{nbMessages} messages</span>}

{"// Explication : 0 est falsy, React arrête le && et retourne 0"}
{"// Or 0 est un nombre valide que React affiche !"}

{"// ✓ Solution 1 : comparaison explicite"}
{nbMessages > 0 && <span>{nbMessages} messages</span>}

{"// ✓ Solution 2 : double négation (force en booléen)"}
{!!nbMessages && <span>{nbMessages} messages</span>}
Piège 3 — null et undefined en props
Vérifier qu'une prop existe avant d'y accéder
✗ Crash si etudiant est undefined
function Carte({ etudiant }) {
  return (
    {"// ❌ TypeError si etudiant est undefined"}
    <h3>{etudiant.nom}</h3>
  );
}
✓ Guard clause protège
function Carte({ etudiant }) {
  {"// ✓ Guard avant d'accéder aux champs"}
  if (!etudiant) {
    return <p>Aucune donnée.</p>;
  }
  return <h3>{etudiant.nom}</h3>;
}

Récapitulatif — quelle méthode choisir ?
MéthodeSyntaxeQuand l'utiliser
if / returnif (condition) return <A />Deux cas très différents, guard clauses, cas d'erreur
Ternairecondition ? <A /> : <B />Deux cas courts et clairs, dans le JSX
&&condition && <A />Un seul cas à afficher, rien dans l'autre
Variable JSXlet x; if... return <div>{x}</div>Logique complexe, plusieurs cas, switch
06 — Validation

Quiz & Travaux pratiques

4 questions pour valider votre compréhension du rendu conditionnel, puis 3 exercices pour mettre en pratique.

1. Pourquoi ne peut-on pas écrire { if(x) <p>...</p> } directement dans le JSX ?
2. Que va afficher {0 && <p>Bonjour</p>} dans la page ?
3. Quelle syntaxe utiliser pour afficher un badge "Admin" uniquement si estAdmin est vrai, et rien sinon ?
4. Parmi ces quatre, laquelle est la meilleure méthode pour gérer les cas "chargement → erreur → données vides → données" ?

S3 — Travaux Pratiques · 3 exercices
Appliquez le rendu conditionnel
1
Carte étudiant avec statut conditionnel
Créez un composant CarteResultat recevant nom, note, boursier (défaut : false). Utilisez un ternaire pour afficher "Admis" en vert ou "Ajourné" en rouge selon si note >= 10. Utilisez && pour afficher un badge "Boursier" uniquement si boursier est vrai. Appliquez une classe CSS différente à la carte selon le statut.
2
Composant de chargement avec guard clauses
Créez un composant ListeNotes recevant notes (tableau), chargement (booléen), erreur (string ou null). Gérez 4 cas avec des if + return dans l'ordre : chargement en cours → erreur → tableau vide → affichage normal. Le cas normal affiche la liste des notes avec .map(). Testez votre composant avec différentes combinaisons de props depuis App.
3
Système de notification — variable JSX
Créez un composant Alerte recevant type ("succes", "erreur", "info", "alerte") et message. Utilisez une variable JSX (let icone) et une série de if pour choisir l'icône selon le type. Utilisez un ternaire pour le texte du bouton de fermeture : "Fermer" si type erreur, "OK" sinon. Rendez 4 alertes différentes dans App pour valider.