Semaine 9 · React Fondamentaux

Les effets de bord
avec useEffect

Synchroniser un composant avec le monde extérieur — appels API, timers, abonnements, titre de page. useEffect est le hook qui gère tout ce qui se passe en dehors du rendu.

Concept d'effet
Tableau de dépendances
Fonction de cleanup
Cas d'usage concrets
Pièges & bonnes pratiques
Prérequis : S6 useState · S7 Formulaires contrôlés
01 — Concept

Qu'est-ce qu'un effet de bord ?

Un composant React a un seul rôle : calculer et retourner du JSX. Tout ce qui va au-delà — appeler une API, écrire dans le localStorage, abonner à un événement — c'est un "effet de bord". useEffect est le hook prévu pour ça.

Ce qui est un effet vs ce qui ne l'est pas
Ce qui n'est PAS un effet — le rendu
function MonComposant({ nom }) {
  {"// Pas d'effet — juste du calcul JSX"}
  const message = `Bonjour ${nom}`;
  const etudiants = data.filter(e => e.actif);

  return (
    <div>
      <p>{message}</p>
      {etudiants.map(e => <p key={e.id}>{e.nom}</p>)}
    </div>
  );
}
Ce qui EST un effet — le monde extérieur
{"// Effets → toujours dans useEffect"}

{"// Appel API"}
fetch('/api/etudiants')

{"// Timer"}
setInterval(() => ..., 1000)

{"// Titre du document"}
document.title = `Bonjour ${nom}`

{"// localStorage"}
localStorage.setItem('theme', theme)

{"// Écouter un événement global"}
window.addEventListener('resize', fn)
⚠️
Pourquoi pas directement dans le composant ? Le corps d'un composant peut s'exécuter plusieurs fois par rendu. Un appel fetch ou un setTimeout placé directement dans le composant (pas dans useEffect) se déclencherait à chaque re-render — souvent des dizaines de fois. useEffect contrôle précisément quand l'effet s'exécute.
Montage (mount)
Le composant apparaît dans le DOM pour la première fois → useEffect s'exécute
Mise à jour (update)
Le state ou les props changent → useEffect se ré-exécute si ses dépendances ont changé
Nettoyage (cleanup)
Avant chaque ré-exécution de l'effet → la fonction de cleanup s'exécute en premier
Démontage (unmount)
Le composant disparaît du DOM → la fonction de cleanup s'exécute une dernière fois
02 — Syntaxe

La syntaxe de useEffect

useEffect prend deux paramètres : une fonction d'effet et un tableau de dépendances. La combinaison de ces deux paramètres contrôle précisément quand l'effet s'exécute.

Anatomie complète
anatomie-useEffect.jsxAnatomie
import { useEffect } from 'react'; {"← import obligatoire"}

useEffect(
  () => {                        {"← 1. fonction d'effet"}

    {"// Code qui s'exécute après le rendu"}
    console.log('Effet exécuté');

    return () => {               {"← 2. fonction de cleanup (optionnelle)"}
      {"// Code de nettoyage"}
      console.log('Cleanup');
    };

  },
  [dep1, dep2]                   {"← 3. tableau de dépendances"}
);

{"// Résumé des 3 formes :"}
useEffect(() => { ... });           {"← sans [] → à chaque rendu"}
useEffect(() => { ... }, []);       {"← [] vide → une seule fois (montage)"}
useEffect(() => { ... }, [dep]);    {"← [dep] → quand dep change"}
💡
useEffect s'exécute toujours après le rendu. React peint d'abord l'écran, puis exécute les effets. Ça garantit que l'utilisateur voit quelque chose rapidement, et que les effets (souvent asynchrones) n'bloquent pas l'affichage.
03 — Tableau de dépendances

Contrôler l'exécution avec les dépendances

Le tableau de dépendances est le paramètre le plus important de useEffect. Il dit à React "ré-exécute cet effet seulement quand ces valeurs changent". C'est la clé pour éviter les boucles infinies et les appels inutiles.

Les 3 formes du tableau de dépendances
useEffect(() => {
  ...
}); // pas de []
S'exécute après chaque rendu du composant. Rarement ce qu'on veut — à éviter sauf cas très spécifiques.
→ À chaque re-render
useEffect(() => {
  ...
}, []); // [] vide
S'exécute une seule fois au montage du composant. Idéal pour charger des données initiales.
→ Au montage seulement
useEffect(() => {
  ...
}, [id, filtre]); // avec deps
S'exécute au montage, puis à chaque fois que id ou filtre changent. Le plus courant.
→ Au montage + quand une dep change
→
Exemples concrets des 3 formes
Chaque cas d'usage correspond à une forme
deps-exemples.jsxDépendances
function PageEtudiants({ etudiantId }) {
  const [etudiant,  setEtudiant]  = useState(null);
  const [dimension, setDimension] = useState(window.innerWidth);
  const [compteur,  setCompteur]  = useState(0);

  {"// Forme 1 : [] — au montage seulement"}
  {"// Écouter le resize une fois au montage"}
  useEffect(() => {
    function handleResize() {
      setDimension(window.innerWidth);
    }
    window.addEventListener('resize', handleResize);
    return () => window.removeEventListener('resize', handleResize);
  }, []); {"← une fois"}

  {"// Forme 2 : [etudiantId] — quand l'id change"}
  {"// Recharger l'étudiant à chaque changement d'id"}
  useEffect(() => {
    fetch(`/api/etudiants/${etudiantId}`)
      .then(res => res.json())
      .then(data => setEtudiant(data));
  }, [etudiantId]); {"← re-fetch quand l'id change"}

  {"// Forme 3 : pas de [] — à chaque rendu"}
  {"// Mettre à jour le titre à chaque fois"}
  useEffect(() => {
    document.title = `Compteur : ${compteur}`;
  }); {"← à chaque rendu — ok ici car léger"}

  return <div>...</div>;
}
Mettez dans le tableau de dépendances toutes les valeurs réactives (state, props) utilisées dans l'effet. Si vous oubliez une dépendance, l'effet travaillera avec une valeur périmée.
🚨
La boucle infinie — l'erreur la plus fréquente avec useEffect.
boucle-infinie.jsx
const [data, setData] = useState([]);

{"// ❌ BOUCLE INFINIE :"}
{"// 1. fetch → setData → re-render → effet → fetch → setData → ..."}
useEffect(() => {
  fetch('/api/data').then(r => r.json()).then(setData);
}); {"← sans [] → s'exécute à chaque rendu !"}

{"// ✓ CORRECT : [] pour n'exécuter qu'une seule fois"}
useEffect(() => {
  fetch('/api/data').then(r => r.json()).then(setData);
}, []); {"← une seule fois au montage ✓"}
04 — Cleanup

Nettoyer les effets avec la fonction de cleanup

Certains effets créent des ressources qui doivent être libérées : abonnements, timers, listeners. La fonction de cleanup (retournée par useEffect) s'exécute avant chaque ré-exécution et au démontage.

1
Pourquoi le cleanup est indispensable
Sans cleanup → fuites mémoire et comportements imprévisibles
✗ Sans cleanup — fuite mémoire
useEffect(() => {
  {"// ❌ Listener jamais supprimé"}
  {"// S'accumule à chaque rendu"}
  window.addEventListener(
    'keydown', handleKey
  );
}, []);
✓ Avec cleanup — propre
useEffect(() => {
  window.addEventListener(
    'keydown', handleKey
  );
  {"// ✓ Supprimé au démontage"}
  return () => {
    window.removeEventListener(
      'keydown', handleKey
    );
  };
}, []);
2
Cleanup d'un timer
setInterval doit toujours être clearInterval dans le cleanup
Minuteur.jsxCleanup timer
function Minuteur() {
  const [secondes, setSecondes] = useState(0);

  useEffect(() => {
    {"// Démarrer le timer au montage"}
    const intervalle = setInterval(() => {
      setSecondes(prev => prev + 1);
    }, 1000);

    {"// Arrêter le timer au démontage"}
    return () => clearInterval(intervalle);

  }, []); {"← démarrer une seule fois"}

  return <p>Temps : {secondes}s</p>;
}
Sans clearInterval dans le cleanup, le timer continuerait de tourner même après la suppression du composant, et setSecondes s'appellerait sur un composant démonté — une erreur React.
3
Cleanup d'une requête fetch — AbortController
Annuler une requête en cours si le composant se démonte
FetchAvecCleanup.jsxAbortController
useEffect(() => {
  {"// AbortController pour annuler le fetch si nécessaire"}
  const controller = new AbortController();

  fetch(`/api/etudiants/${id}`, {
    signal: controller.signal
  })
    .then(res => res.json())
    .then(data => setEtudiant(data))
    .catch(err => {
      {"// Ignorer l'erreur d'abandon — c'est normal"}
      if (err.name === 'AbortError') return;
      setErreur(err.message);
    });

  {"// Si l'id change ou le composant se démonte"}
  {"// → annuler la requête en cours"}
  return () => controller.abort();

}, [id]);
Sans AbortController, si l'utilisateur navigue rapidement entre deux profils, les deux requêtes se terminent dans un ordre imprévisible — la seconde peut afficher les données de la première. AbortController annule la requête obsolète.
05 — Cas d'usage

Les patterns les plus courants

useEffect couvre une grande variété de besoins. Voici les patterns qu'on retrouve dans pratiquement tous les projets React.

1
Titre de la page dynamique
document.title selon le contenu affiché
TitreDynamique.jsxdocument.title
function PageEtudiant({ nom }) {
  useEffect(() => {
    {"// Met à jour le titre de l'onglet"}
    document.title = nom ? `Profil de ${nom}` : 'Étudiants';

    {"// Restaurer le titre par défaut au démontage"}
    return () => { document.title = 'Mon Application'; };
  }, [nom]);

  return <div>...</div>;
}
2
Synchronisation avec localStorage
Persister des données entre les sessions
ThemePersiste.jsxlocalStorage
function App() {
  {"// Lire depuis localStorage pour la valeur initiale"}
  const [theme, setTheme] = useState(
    () => localStorage.getItem('theme') ?? 'clair'
  );

  {"// Sauvegarder à chaque changement de theme"}
  useEffect(() => {
    localStorage.setItem('theme', theme);
  }, [theme]);

  return (
    <div data-theme={theme}>
      <button onClick={() => setTheme(t => t === 'clair' ? 'sombre' : 'clair')}>
        Thème : {theme}
      </button>
    </div>
  );
}
3
Détecter un clic en dehors d'un élément
Pour fermer un menu ou une modal au clic extérieur
MenuDeroulant.jsxclick outside
import { useEffect, useRef, useState } from 'react';

function MenuDeroulant() {
  const [ouvert, setOuvert] = useState(false);
  const ref = useRef(null);

  useEffect(() => {
    function handleClickExterieur(e) {
      {"// Si le clic est en dehors du menu → fermer"}
      if (ref.current && !ref.current.contains(e.target)) {
        setOuvert(false);
      }
    }
    {"// Écouter seulement si le menu est ouvert"}
    if (ouvert) {
      document.addEventListener('mousedown', handleClickExterieur);
    }
    return () => document.removeEventListener('mousedown', handleClickExterieur);
  }, [ouvert]);

  return (
    <div ref={ref}>
      <button onClick={() => setOuvert(prev => !prev)}>Menu</button>
      {ouvert && <ul><li>Option 1</li><li>Option 2</li></ul>}
    </div>
  );
}
06 — Fetch & API

Charger des données depuis une API

Le cas d'usage le plus courant de useEffect : récupérer des données au montage du composant. C'est la fondation de S11 — connexion API complète.

→
Le pattern complet — loading / erreur / données
3 états à gérer pour chaque appel API
ListeEtudiants.jsxFetch pattern
function ListeEtudiants() {
  const [etudiants,  setEtudiants]  = useState([]);
  const [chargement, setChargement] = useState(true);
  const [erreur,     setErreur]     = useState(null);

  useEffect(() => {
    const controller = new AbortController();

    async function chargerEtudiants() {
      try {
        setChargement(true);
        setErreur(null);

        const reponse = await fetch('/api/etudiants', {
          signal: controller.signal
        });

        if (!reponse.ok) {
          throw new Error(`Erreur ${reponse.status}`);
        }

        const data = await reponse.json();
        setEtudiants(data);

      } catch (err) {
        if (err.name === 'AbortError') return;
        setErreur(err.message);
      } finally {
        setChargement(false);
      }
    }

    chargerEtudiants();

    return () => controller.abort();
  }, []); {"← une fois au montage"}

  {"// Guard clauses — S3 !"}
  if (chargement) return <p>Chargement...</p>;
  if (erreur)     return <p>Erreur : {erreur}</p>;
  if (etudiants.length === 0) return <p>Aucun étudiant.</p>;

  return (
    <ul>
      {etudiants.map(e => (
        <li key={e.id}>{e.nom} — {e.note}/20</li>
      ))}
    </ul>
  );
}
Toujours définir une fonction async à l'intérieur de useEffect et l'appeler — useEffect lui-même ne peut pas être async (il retournerait une Promise au lieu d'une fonction de cleanup).
→
Refetch quand un paramètre change
Recharger les données à chaque changement de filtre ou d'id
EtudiantParFiliere.jsxRefetch
function EtudiantParFiliere() {
  const [filiere,    setFiliere]    = useState('info');
  const [etudiants,  setEtudiants]  = useState([]);
  const [chargement, setChargement] = useState(true);

  {"// Se relance chaque fois que filiere change"}
  useEffect(() => {
    const controller = new AbortController();

    async function charger() {
      setChargement(true);
      const res = await fetch(
        `/api/etudiants?filiere=${filiere}`,
        { signal: controller.signal }
      );
      const data = await res.json();
      setEtudiants(data);
      setChargement(false);
    }

    charger();
    return () => controller.abort(); {"← annule la requête précédente"}
  }, [filiere]); {"← re-fetch quand filiere change"}

  return (
    <div>
      <select value={filiere} onChange={e => setFiliere(e.target.value)}>
        <option value="info">Informatique</option>
        <option value="reseaux">Réseaux</option>
      </select>
      {chargement ? <p>Chargement...</p> : (
        etudiants.map(e => <p key={e.id}>{e.nom}</p>)
      )}
    </div>
  );
}
⚠️
useEffect ne peut pas être async. Ne faites jamais useEffect(async () => ...). Déclarez une fonction async à l'intérieur et appelez-la immédiatement. Sinon useEffect retourne une Promise là où React attend une fonction de cleanup ou undefined.
07 — Pièges & bonnes pratiques

Les erreurs classiques

useEffect concentre certains des pièges les plus difficiles à déboguer en React. Les connaître à l'avance vous fera gagner des heures.

Piège 1 — useEffect async
✗ Interdit — useEffect async
{"// ❌ Ne jamais faire ça"}
useEffect(async () => {
  const data = await fetch('...');
  {"// React reçoit une Promise"}
  {"// à la place du cleanup"}
}, []);
✓ Fonction async interne
{"// ✓ Fonction async définie dedans"}
useEffect(() => {
  async function charger() {
    const data = await fetch('...');
    {"// ..."}
  }
  charger();
}, []);
Piège 2 — Dépendances manquantes
Oublier une dépendance → valeur périmée (stale closure)
deps-manquantes.jsx
const [userId, setUserId] = useState(1);

{"// ❌ userId utilisé mais absent des deps"}
useEffect(() => {
  fetch(`/api/users/${userId}`); {"← userId est capturé à sa valeur initiale (1)"}
}, []); {"← ne se relancera jamais même si userId change"}

{"// ✓ userId dans les deps → se relance quand userId change"}
useEffect(() => {
  fetch(`/api/users/${userId}`);
}, [userId]); {"← ✓"}

{"// Astuce : installer ESLint plugin 'eslint-plugin-react-hooks'"}
{"// → vous avertit des dépendances manquantes automatiquement"}
Piège 3 — Objet ou fonction comme dépendance
Les objets sont recréés à chaque rendu → boucle infinie
objet-dep.jsx
{"// ❌ options est recréé à chaque rendu → boucle infinie"}
const options = { filiere: 'info' }; {"← nouvelle référence à chaque rendu"}
useEffect(() => {
  fetch('/api/etudiants', options);
}, [options]); {"← toujours différent → boucle"}

{"// ✓ Solution 1 — utiliser les primitives directement"}
const [filiere, setFiliere] = useState('info');
useEffect(() => {
  fetch(`/api/etudiants?filiere=${filiere}`);
}, [filiere]); {"← string stable ✓"}

{"// ✓ Solution 2 — déplacer l'objet à l'intérieur de l'effet"}
useEffect(() => {
  const options = { filiere }; {"← créé dans l'effet, pas en dep"}
  fetch('/api/etudiants', options);
}, [filiere]);

Récapitulatif — useEffect en un coup d'œil
BesoinDépendancesCleanup ?
Charger données au montage[]Oui — AbortController
Recharger quand un param change[param]Oui — AbortController
Titre de page dynamique[valeur]Optionnel — restaurer le titre
localStorage — synchroniser[valeur]Non
setInterval — timer[]Oui — clearInterval
addEventListener global[]Oui — removeEventListener
Clic extérieur[ouvert]Oui — removeEventListener
08 — Validation

Quiz & Travaux pratiques

4 questions de validation puis 3 exercices progressifs.

1. Quelle est la différence entre useEffect(() => {}, []) et useEffect(() => {}) (sans tableau) ?
2. Pourquoi ne peut-on pas écrire useEffect(async () => { ... }) ?
3. Quel est le rôle de la fonction retournée par useEffect (le cleanup) ?
4. Un composant fait un fetch avec useEffect et les dépendances [userId]. Que se passe-t-il quand userId change ?

S9 — Travaux Pratiques · 3 exercices
Effets de bord en action
1
Minuteur avec pause et reset
Créez un composant Minuteur avec 3 states : secondes, actif (boolean), meilleurTemps. Un useEffect avec setInterval démarre quand actif est true, s'arrête sinon (dépendance : [actif]) — nettoyez le timer dans le cleanup. Boutons : "Démarrer/Pauser" (toggle actif), "Reset" (remet à 0 et arrête), "Sauvegarder" (enregistre dans meilleurTemps si inférieur). Synchronisez meilleurTemps dans localStorage avec un second useEffect. Affichez le titre du document avec le temps en cours.
2
Fetch avec filtre dynamique
Utilisez l'API publique https://jsonplaceholder.typicode.com/users. States : users, chargement, erreur, recherche (string). Un useEffect avec [] charge tous les utilisateurs au montage — gérez loading/erreur. Filtrez localement les utilisateurs selon recherche (nom ou email, insensible à la casse) — c'est un calcul au rendu, pas un autre useEffect. Affichez le nombre de résultats. Ajoutez un bouton "Réessayer" visible en cas d'erreur qui relance le fetch (indice : utilisez un state tentative comme dépendance).
3
Profil utilisateur avec refetch sur changement d'id
Listez 10 boutons numérotés (1 à 10) représentant des utilisateurs. Au clic sur un bouton, fetchez https://jsonplaceholder.typicode.com/users/{id} et affichez le profil (nom, email, téléphone, site web, entreprise). States : userId (number), profil, chargement, erreur. L'useEffect dépend de [userId] et utilise AbortController pour le cleanup. Marquez le bouton actif visuellement. Gérez les états loading (skeleton ou spinner) et erreur séparément de l'affichage du profil.