Qu'est-ce que l'état ?
Jusqu'ici nos composants sont statiques : ils affichent ce qu'on leur donne en props, mais ne peuvent rien mémoriser ni changer d'eux-mêmes. L'état (state) est la mémoire d'un composant — une valeur qui peut changer et qui, quand elle change, met à jour l'affichage.
function Compteur() { {"// Variable JS ordinaire"} let compte = 0; function incrementer() { compte = compte + 1; {"// La variable change mais React"} {"// ne le sait pas → pas de rendu !"} } return ( <div> <p>{compte}</p> <button onClick={incrementer}>+</button> </div> ); } {"// L'écran affiche toujours 0 !"}
import { useState } from 'react'; function Compteur() { const [compte, setCompte] = useState(0); function incrementer() { setCompte(compte + 1); {"// React sait qu'il faut re-render"} } return ( <div> <p>{compte}</p> <button onClick={incrementer}>+</button> </div> ); } {"// L'écran se met à jour à chaque clic !"}
Déclarer et utiliser useState
useState est un hook React qui retourne un tableau de deux éléments : la valeur actuelle de l'état et la fonction pour la modifier. On les extrait par déstructuration.
import { useState } from 'react'; {"← import obligatoire"} function MonComposant() { const [valeur, setValeur] = useState(0); {"// ↑ ↑ ↑"} {"// état actuel setter valeur initiale"} {"// valeur → ce qu'on lit et affiche"} {"// setValeur → la seule façon de modifier valeur"} {"// 0 → valeur au premier rendu uniquement"} return ( <div> <p>Valeur : {valeur}</p> <button onClick={() => setValeur(valeur + 1)}>+</button> <button onClick={() => setValeur(0)}>Reset</button> </div> ); }
function ProfilEtudiant() { {"// Chaque useState est indépendant"} const [nom, setNom] = useState(''); const [note, setNote] = useState(0); const [connecte, setConnecte] = useState(false); const [filieres, setFilieres] = useState([]); const [chargement, setChargement] = useState(false); {"// Modifier un état ne touche pas les autres"} return ( <div> <p>{nom || 'Anonyme'} — {note}/20</p> <button onClick={() => setConnecte(!connecte)}> {connecte ? 'Déconnexion' : 'Connexion'} </button> </div> ); }
const [compte, setCompte] = useState(0); {"// Forme 1 — valeur directe (la plus courante)"} setCompte(10); {"// compte vaut 10"} setCompte(compte + 1); {"// compte + 1"} setCompte(0); {"// reset à 0"} {"// Forme 2 — fonction updater (quand on dépend de l'ancienne valeur)"} setCompte((prev) => prev + 1); {"← prev = valeur actuelle garantie"} setCompte((prev) => prev * 2); setCompte((prev) => prev > 10 ? 0 : prev + 1); {"// La forme updater est indispensable dans ces cas :"} function incrementerTroisFois() { {"// ❌ Ne fonctionne pas — compte est figé à sa valeur du rendu"} setCompte(compte + 1); setCompte(compte + 1); setCompte(compte + 1); {"// résultat : +1 seulement !"} {"// ✓ Avec updater — chaque appel reçoit la dernière valeur"} setCompte(prev => prev + 1); setCompte(prev => prev + 1); setCompte(prev => prev + 1); {"// résultat : +3 ✓"} }
useState avec tous les types
useState accepte n'importe quelle valeur JavaScript comme état initial : un nombre, un string, un booléen, un tableau, un objet, ou même null.
{"// Nombre — compteur, score, page courante"} const [page, setPage] = useState(1); const [score, setScore] = useState(0); {"// String — champ texte, filtre, onglet actif"} const [recherche, setRecherche] = useState(''); const [onglet, setOnglet] = useState('profil'); {"// Booléen — modal ouvert/fermé, menu, chargement"} const [modalOuverte, setModalOuverte] = useState(false); const [chargement, setChargement] = useState(false); const [menuOuvert, setMenuOuvert] = useState(false); {"// Null — donnée pas encore chargée, sélection vide"} const [etudiant, setEtudiant] = useState(null); const [selection, setSelection] = useState(null); {"// Tableau — liste d'items, résultats filtrés"} const [panier, setPanier] = useState([]); const [resultats, setResultats] = useState([]); {"// Objet — formulaire, données utilisateur"} const [profil, setProfil] = useState({ nom: '', email: '' });
Connecter useState aux événements
C'est ici que tout s'assemble : les événements de S5 déclenchent des setters de useState, qui provoquent un nouveau rendu, qui affiche la nouvelle valeur. C'est le pattern central de React interactif.
function ToggleBouton() { const [actif, setActif] = useState(false); return ( <button onClick={() => setActif(prev => !prev)} style={{ background: actif ? 'green' : 'gray' }} > {actif ? 'Activé' : 'Désactivé'} </button> ); }
function ChampControle() { const [texte, setTexte] = useState(''); return ( <div> <input type="text" value={texte} {"← lié au state"} onChange={(e) => setTexte(e.target.value)} placeholder="Tapez quelque chose..." /> {"// Affichage en temps réel"} <p>Vous avez tapé : <strong>{texte}</strong></p> <p>{texte.length} / 100 caractères</p> {"// Bouton effacer"} <button onClick={() => setTexte('')}>Effacer</button> </div> ); }
function PageAvecModal() { const [modalOuverte, setModalOuverte] = useState(false); return ( <div> <h1>Ma page</h1> <button onClick={() => setModalOuverte(true)}> Ouvrir la modal </button> {"// La modal n'existe dans le DOM que si modalOuverte = true"} {modalOuverte && ( <div className="overlay"> <div className="modal"> <h2>Contenu de la modal</h2> <button onClick={() => setModalOuverte(false)}> Fermer ✕ </button> </div> </div> )} </div> ); }
const ONGLETS = ['Tous', 'Admis', 'Ajournés']; function OngletsFiltres({ etudiants }) { const [ongletActif, setOngletActif] = useState('Tous'); {"// Filtrer selon l'onglet actif"} const visibles = etudiants.filter(e => { if (ongletActif === 'Admis') return e.note >= 10; if (ongletActif === 'Ajournés') return e.note < 10; return true; }); return ( <div> {"// Barre d'onglets"} <div> {ONGLETS.map(o => ( <button key={o} onClick={() => setOngletActif(o)} className={ongletActif === o ? 'actif' : ''} >{o}</button> ))} </div> {"// Liste filtrée"} {visibles.map(e => <p key={e.id}>{e.nom} — {e.note}/20</p>)} </div> ); }
State avec des objets et tableaux
Quand l'état est un objet ou un tableau, une règle absolue s'applique : ne jamais muter directement. Il faut toujours créer une nouvelle valeur. React ne détecte les changements que par comparaison de référence.
const [profil, setProfil] = useState( { nom: 'Fatou', note: 17 } ); {"// ❌ Mutation de l'objet existant"} profil.nom = 'Moussa'; setProfil(profil); {"// Même référence → pas de re-render !"}
const [profil, setProfil] = useState( { nom: 'Fatou', note: 17 } ); {"// ✓ Nouveau objet avec spread"} setProfil({ ...profil, nom: 'Moussa' }); {"// Nouvelle référence → re-render ✓"}
const [etudiants, setEtudiants] = useState([ { id: 1, nom: 'Fatou', note: 17 }, { id: 2, nom: 'Moussa', note: 13 }, ]); {"// ─── AJOUTER un élément ───"} setEtudiants(prev => [ ...prev, { id: 3, nom: 'Aminata', note: 19 } ]); {"// ─── SUPPRIMER par id ───"} setEtudiants(prev => prev.filter(e => e.id !== 2) ); {"// ─── MODIFIER un élément ───"} setEtudiants(prev => prev.map(e => e.id === 1 ? { ...e, note: 18 } {"← nouvel objet avec note modifiée"} : e {"← les autres inchangés"} ) ); {"// ─── REMPLACER tout le tableau ───"} setEtudiants([ { id: 1, nom: 'Fatou', note: 20 }, ]);
.filter() pour supprimer, .map() pour modifier, spread [...prev, item] pour ajouter. N'utilisez jamais .push(), .splice() ou .sort() directement sur le state.Les règles à ne jamais enfreindre
Les hooks React (useState, useEffect…) ont des règles strictes. Les enfreindre provoque des bugs difficiles à déboguer. React signale ces erreurs en développement.
function MonComposant({ actif }) { if (actif) { {"// ❌ Interdit !"} const [v, setV] = useState(0); } {"// ❌ Dans une boucle aussi"} items.forEach(i => { const [x, setX] = useState(0); }); }
function MonComposant({ actif }) { {"// ✓ Toujours au sommet"} const [v, setV] = useState(0); {"// Le conditionnel vient APRÈS"} if (!actif) return null; return <p>{v}</p>; }
{"// ❌ Fonction ordinaire — interdit"} function calculerQuelqueChose() { const [v, setV] = useState(0); return v; } {"// ❌ Callback ordinaire — interdit"} const fn = () => { const [x, setX] = useState(0); };
{"// ✓ Composant React (PascalCase)"} function MonComposant() { const [v, setV] = useState(0); return <p>{v}</p>; } {"// ✓ Hook personnalisé (commence par 'use')"} function useCompteur() { const [v, setV] = useState(0); return { v, setV }; }
Les erreurs que tout le monde fait
Voici les 4 erreurs les plus fréquentes avec useState, avec leur explication et leur correction.
const [compte, setCompte] = useState(0); function handleClick() { setCompte(compte + 1); {"// ❌ compte vaut encore 0 ici !"} console.log(compte); {"→ affiche 0, pas 1"} {"// Le nouveau state est disponible au PROCHAIN rendu"} {"// Pour utiliser la nouvelle valeur immédiatement :"} const nouvelleValeur = compte + 1; setCompte(nouvelleValeur); console.log(nouvelleValeur); {"→ 1 ✓"} }
const [liste, setListe] = useState([1, 2, 3]); {"// ❌ push mute le tableau — React ne re-rend pas"} liste.push(4); setListe(liste); {"// ✓ Nouveau tableau — React re-rend"} setListe([...liste, 4]); setListe(prev => [...prev, 4]); {"← forme updater recommandée"}
{"// Difficile à mettre à jour"} const [state, setState] = useState({ nom: '', modal: false, page: 1, chargement: false, }); {"// Modifier modal → copier tout l'objet"} setState(prev => ({...prev, modal: true}));
{"// Chaque état évolue indépendamment"} const [nom, setNom] = useState(''); const [modal, setModal] = useState(false); const [page, setPage] = useState(1); const [chargement, setChargement] = useState(false); {"// Modifier modal → simple"} setModal(true);
Exception : regrouper en objet les états qui évoluent toujours ensemble, comme les champs d'un formulaire.
const [etudiants, setEtudiants] = useState([...]); {"// ❌ Inutile — se déduit d'etudiants"} const [nbAdmis, setNbAdmis] = useState(0); const [filtres, setFiltres] = useState([]);
const [etudiants, setEtudiants] = useState([...]); {"// ✓ Calculé au rendu — toujours à jour"} const nbAdmis = etudiants .filter(e => e.note >= 10).length; const filtres = etudiants .filter(e => e.filiere === 'info');
| Règle | Correct | Incorrect |
|---|---|---|
| Modifier le state | setX(nouvelle valeur) | Modifier x directement |
| Objets/tableaux | Créer une copie (spread) | .push(), mutation directe |
| Dépend de l'ancienne valeur | setX(prev => prev + 1) | setX(x + 1) en boucle |
| Emplacement du hook | Au niveau racine du composant | Dans un if, une boucle |
| Lire après setter | Utiliser une variable locale | Lire le state juste après set |
Quiz & Travaux pratiques
4 questions de validation puis 4 exercices progressifs — du compteur basique à la liste interactive complète.
setCompte(prev => prev + 1) plutôt que setCompte(compte + 1) quand on appelle le setter plusieurs fois de suite ?useState à l'intérieur d'un if ?Compteur avec un state compte initialisé à 0. Trois boutons : −, +, Reset. Contraintes : le compteur ne peut pas descendre en dessous de 0 ni dépasser 10. Affichez le compteur en grand. Affichez un message conditionnel "Maximum atteint" si compte = 10, "Minimum atteint" si compte = 0. La couleur du nombre change : vert si > 5, orange si ≤ 5.
recherche (string, initial: ''). Un input contrôlé met à jour ce state. Filtrez et affichez les étudiants dont le nom contient la recherche (insensible à la casse). Affichez "{N} résultat(s) pour '{recherche}'" au-dessus de la liste. Si aucun résultat, affichez un message. Ajoutez un bouton "Effacer" qui vide la recherche.
etudiants initialisé avec 3 étudiants (tableau d'objets avec id, nom, note). Un formulaire simple (2 inputs : nom + note, un bouton "Ajouter") ajoute un étudiant au tableau via un setter. Un bouton "Supprimer" sur chaque carte retire l'étudiant via .filter(). Affichez le nombre total d'étudiants et la moyenne des notes en bas. Les deux se recalculent automatiquement.
etudiants (tableau), onglet (string : "tous" | "admis" | "ajournés"), recherche (string), triDecroissant (booléen). Onglets cliquables qui filtrent. Recherche par nom. Bouton toggle pour trier par note croissante/décroissante. Bouton "Modifier" sur chaque carte qui permet d'éditer la note directement. Affichez les statistiques : total, admis, ajournés, moyenne — toujours calculées depuis le state.