Semaine 6 · React Fondamentaux

L'état local
avec useState

Le hook le plus important de React. Il permet à un composant de mémoriser une valeur entre les rendus et de mettre à jour l'interface automatiquement quand cette valeur change.

Le concept d'état
Syntaxe et règles
Tous les types de state
Pièges classiques
4 exercices pratiques
Prérequis : S1–S4 JSX, Props, Conditionnel, Listes · S5 Événements
01 — Concept

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.

La différence fondamentale — variable vs state
✗ Variable ordinaire — ne réaffiche pas
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 !"}
✓ useState — React re-affiche
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 !"}
1. Rendu initial
React affiche le composant avec la valeur initiale
→
2. Événement
L'utilisateur clique, tape… le setter est appelé
→
3. Nouveau rendu
React re-exécute le composant avec la nouvelle valeur
→
4. DOM mis à jour
Seules les parties qui ont changé sont modifiées
💡
React est réactif. Appeler le setter d'un state déclenche automatiquement un nouveau rendu du composant. C'est le mécanisme central de React — tout le reste (formulaires, listes dynamiques, UI interactive) repose sur ce principe.
02 — Syntaxe

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.

1
La syntaxe de base — décortiquer ligne par ligne
Chaque partie a un rôle précis
anatomie-useState.jsxAnatomie
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>
  );
}
Convention de nommage : l'état s'appelle quelque chose, le setter s'appelle setSomething. C'est une convention non obligatoire mais universelle en React.
2
Plusieurs useState dans un même composant
Chaque état est indépendant
multi-state.jsxPlusieurs états
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>
  );
}
Il n'y a pas de limite au nombre de useState dans un composant. Chaque état a sa propre valeur et son propre setter — ils ne s'influencent pas mutuellement.
3
Le setter — deux façons de l'appeler
Valeur directe ou fonction de mise à jour
setter-formes.jsxSetter
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 ✓"}
}
Règle simple : si la nouvelle valeur dépend de l'ancienne (compte + 1, !actif, [...liste, nouvelElement]), utilisez toujours la forme updater (prev) => .... Sinon, la valeur directe suffit.
03 — Types de state

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.

number
useState(0)
string
useState('')
boolean
useState(false)
null
useState(null)
array
useState([])
object
useState({})
undefined
useState()
function
useState(() => ...)
Exemples concrets par type
types-exemples.jsxTous les types
{"// 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: '' });
04 — State & Événements

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.

1
onClick + useState — bouton toggle
Le pattern le plus simple et le plus courant
ToggleBouton.jsxonClick + state
function ToggleBouton() {
  const [actif, setActif] = useState(false);

  return (
    <button
      onClick={() => setActif(prev => !prev)}
      style={{ background: actif ? 'green' : 'gray' }}
    >
      {actif ? 'Activé' : 'Désactivé'}
    </button>
  );
}
!prev inverse le booléen actuel. C'est la forme updater idéale pour les toggles.
2
onChange + useState — champ texte contrôlé
La valeur du champ est toujours synchronisée avec le state
ChampControle.jsxonChange + state
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>
  );
}
value={texte} + onChange={setTexte} = champ contrôlé. Le state est la source unique de vérité. React est le seul maître de la valeur affichée dans l'input.
3
État + rendu conditionnel — modal
Combiner S3 (conditionnel) et useState
Modal.jsxstate + conditionnel
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>
  );
}
C'est l'un des patterns les plus courants en React. Un booléen contrôle la visibilité d'un élément — modal, menu, tooltip, panneau latéral…
4
État + liste — onglets et filtres
Un string comme état actif
Onglets.jsxstate + liste
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>
  );
}
05 — Objets & Tableaux

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.

🚨
La règle d'immuabilité. React compare l'ancienne et la nouvelle valeur par référence. Si vous modifiez un objet ou tableau directement (mutation), la référence ne change pas → React pense que rien n'a changé → pas de re-render. Toujours créer une nouvelle valeur.
State objet — modifier un champ
✗ Mutation directe — ne fonctionne pas
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 !"}
✓ Nouvel objet avec spread
const [profil, setProfil] = useState(
  { nom: 'Fatou', note: 17 }
);

{"// ✓ Nouveau objet avec spread"}
setProfil({ ...profil, nom: 'Moussa' });
{"// Nouvelle référence → re-render ✓"}
State tableau — les 4 opérations
Ajouter, modifier, supprimer, remplacer
tableau-operations.jsxTableau state
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 },
]);
💡
Mémo rapide : pour les tableaux, utilisez les méthodes qui retournent un nouveau tableau : .filter() pour supprimer, .map() pour modifier, spread [...prev, item] pour ajouter. N'utilisez jamais .push(), .splice() ou .sort() directement sur le state.
06 — Règles des hooks

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.

R1
Seulement au niveau supérieur du composant
Jamais dans un if, une boucle ou une fonction imbriquée
✗ Hook dans un if — interdit
function MonComposant({ actif }) {
  if (actif) {
    {"// ❌ Interdit !"}
    const [v, setV] = useState(0);
  }
  {"// ❌ Dans une boucle aussi"}
  items.forEach(i => {
    const [x, setX] = useState(0);
  });
}
✓ Toujours au niveau racine
function MonComposant({ actif }) {
  {"// ✓ Toujours au sommet"}
  const [v, setV] = useState(0);

  {"// Le conditionnel vient APRÈS"}
  if (!actif) return null;

  return <p>{v}</p>;
}
React identifie les hooks par leur ordre d'appel à chaque rendu. Si cet ordre change (à cause d'un if), React confond les valeurs — d'où l'erreur.
R2
Seulement dans des composants React ou des hooks personnalisés
Jamais dans une fonction JavaScript ordinaire
✗ Dans une fonction JS ordinaire
{"// ❌ Fonction ordinaire — interdit"}
function calculerQuelqueChose() {
  const [v, setV] = useState(0);
  return v;
}

{"// ❌ Callback ordinaire — interdit"}
const fn = () => {
  const [x, setX] = useState(0);
};
✓ Composant ou hook custom
{"// ✓ 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 };
}
07 — Pièges classiques

Les erreurs que tout le monde fait

Voici les 4 erreurs les plus fréquentes avec useState, avec leur explication et leur correction.

Piège 1 — Lire le state juste après le setter
Le state ne se met pas à jour immédiatement
piège-1.jsx
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 ✓"}
}
Piège 2 — Muter un objet ou tableau directement
On l'a vu en section 05 — le résumé
piège-2.jsx
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"}
Piège 3 — Mettre trop de choses dans un seul state objet
Quand regrouper et quand séparer ?
✗ Tout dans un seul objet
{"// 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}));
✓ États séparés par responsabilité
{"// 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.

Piège 4 — State dérivé inutile
Ne pas stocker ce qui peut être calculé
✗ State redondant
const [etudiants, setEtudiants] = useState([...]);
{"// ❌ Inutile — se déduit d'etudiants"}
const [nbAdmis, setNbAdmis] = useState(0);
const [filtres, setFiltres] = useState([]);
✓ Valeurs calculées à la volée
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écapitulatif — les règles d'or
RègleCorrectIncorrect
Modifier le statesetX(nouvelle valeur)Modifier x directement
Objets/tableauxCréer une copie (spread).push(), mutation directe
Dépend de l'ancienne valeursetX(prev => prev + 1)setX(x + 1) en boucle
Emplacement du hookAu niveau racine du composantDans un if, une boucle
Lire après setterUtiliser une variable localeLire le state juste après set
08 — Validation

Quiz & Travaux pratiques

4 questions de validation puis 4 exercices progressifs — du compteur basique à la liste interactive complète.

1. Quelle est la différence entre une variable ordinaire et un state React ?
2. Comment ajouter un élément à un tableau en state sans le muter ?
3. Pourquoi faut-il utiliser la forme setCompte(prev => prev + 1) plutôt que setCompte(compte + 1) quand on appelle le setter plusieurs fois de suite ?
4. Que se passe-t-il si on appelle useState à l'intérieur d'un if ?

S6 — Travaux Pratiques · 4 exercices
Du compteur à la liste interactive
1
Compteur avec limites
Créez un composant 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.
2
Barre de recherche en temps réel
Partez d'un tableau de 8 étudiants fixe (données en dur). Créez un state 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.
3
Liste dynamique — ajouter et supprimer
State 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.
4
Tableau de bord avec onglets et filtres
Combinez tout. States nécessaires : 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.