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.
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> ); }
{"// 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)
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.
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"}
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.
...
}); // pas de []
...
}, []); // [] vide
...
}, [id, filtre]); // avec deps
id ou filtre changent. Le plus courant.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>; }
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 ✓"}
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.
useEffect(() => { {"// ❌ Listener jamais supprimé"} {"// S'accumule à chaque rendu"} window.addEventListener( 'keydown', handleKey ); }, []);
useEffect(() => { window.addEventListener( 'keydown', handleKey ); {"// ✓ Supprimé au démontage"} return () => { window.removeEventListener( 'keydown', handleKey ); }; }, []);
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>; }
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]);
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.
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>; }
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> ); }
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> ); }
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.
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> ); }
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(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.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.
{"// ❌ Ne jamais faire ça"} useEffect(async () => { const data = await fetch('...'); {"// React reçoit une Promise"} {"// à la place du cleanup"} }, []);
{"// ✓ Fonction async définie dedans"} useEffect(() => { async function charger() { const data = await fetch('...'); {"// ..."} } charger(); }, []);
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"}
{"// ❌ 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]);
| Besoin | Dépendances | Cleanup ? |
|---|---|---|
| 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 |
Quiz & Travaux pratiques
4 questions de validation puis 3 exercices progressifs.
useEffect(() => {}, []) et useEffect(() => {}) (sans tableau) ?useEffect(async () => { ... }) ?useEffect et les dépendances [userId]. Que se passe-t-il quand userId change ?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.
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).
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.