Semaine 10 · React Fondamentaux

État global avec
Context API

Partager des données entre composants distants sans prop drilling. createContext, Provider, useContext — et quand l'utiliser ou non.

Problème du prop drilling
createContext + Provider
useContext
Hooks personnalisés
Cas d'usage réels
Prérequis : S6 useState · S9 useEffect · S2 Props
01 — Le problème

Le prop drilling — quand les props deviennent un enfer

Quand une valeur doit traverser de nombreux niveaux de composants pour atteindre celui qui en a besoin, on doit la passer à chaque intermédiaire — même si ces intermédiaires n'en ont pas besoin. C'est le "prop drilling".

Prop drilling — l'utilisateur connecté doit traverser 3 niveaux inutilement
App
user = { nom: 'Fatou' }
user={user}
Layout
reçoit user, le passe juste…
user={user}
Sidebar
reçoit user, le passe juste…
user={user}
ProfilBouton ← a VRAIMENT besoin de user

Layout et Sidebar ne font que transmettre user sans l'utiliser. C'est du bruit dans le code.

✗ Sans Context — prop drilling
{"// App.jsx — possède la donnée"}
function App() {
  const [user, setUser] = useState({nom:'Fatou'});
  return <Layout user={user} />;
}
{"// Layout — ne l'utilise pas, la passe"}
function Layout({ user }) {
  return <Sidebar user={user} />;
}
{"// Sidebar — idem"}
function Sidebar({ user }) {
  return <ProfilBouton user={user} />;
}
{"// ProfilBouton — enfin !"}
function ProfilBouton({ user }) {
  return <span>{user.nom}</span>;
}
✓ Avec Context — accès direct
{"// App.jsx — fournit le contexte"}
function App() {
  const [user, setUser] = useState({nom:'Fatou'});
  return (
    <UserContext.Provider value={user}>
      <Layout /> {"← pas de prop user !"}
    </UserContext.Provider>
  );
}
{"// Layout & Sidebar — rien à passer"}
function Layout() { return <Sidebar />; }
function Sidebar() { return <ProfilBouton />; }

{"// ProfilBouton — accès direct"}
function ProfilBouton() {
  const user = useContext(UserContext);
  return <span>{user.nom}</span>;
}
02 — Créer un contexte

Créer un contexte avec createContext

Un contexte se crée en dehors de tout composant, dans un fichier dédié. Il définit le "canal" par lequel les données vont circuler dans l'arbre de composants.

1
createContext — créer le canal
Un fichier dédié par contexte — bonne organisation
contexts/UserContext.jsxcreateContext
import { createContext } from 'react';

{"// createContext() crée le contexte"}
{"// L'argument est la valeur par défaut (si pas de Provider parent)"}
export const UserContext = createContext(null);

{"// Autres exemples de contextes :"}
export const ThemeContext  = createContext('clair');
export const PanierContext = createContext({ items: [], total: 0 });
export const AuthContext   = createContext({
  user:       null,
  connecte:   false,
  connexion:  () => {},
  deconnexion:() => {},
});
La valeur par défaut passée à createContext n'est utilisée que si un composant consomme le contexte sans avoir de Provider parent. En pratique, on met null ou une structure vide pour documenter la forme attendue.
💡
Structure de fichiers recommandée : créez un dossier src/contexts/ avec un fichier par contexte. Par exemple : AuthContext.jsx, ThemeContext.jsx, PanierContext.jsx. Chaque fichier exporte le contexte ET son Provider.
03 — Provider

Fournir les données avec le Provider

Le Provider est un composant qui enveloppe une partie de l'arbre et rend le contexte accessible à tous ses descendants. Il fournit la valeur via sa prop value.

1
Provider basique — fournir une valeur statique
Le composant racine enveloppe tout
main.jsxProvider
import { ThemeContext } from './contexts/ThemeContext';

{"// Envelopper l'application dans le Provider"}
ReactDOM.createRoot(document.getElementById('root')).render(
  <ThemeContext.Provider value="sombre">
    <App />
  </ThemeContext.Provider>
);
2
Provider avec state — valeur dynamique
La bonne pratique : encapsuler dans un composant dédié
contexts/ThemeContext.jsxProvider complet
import { createContext, useState } from 'react';

{"// 1. Créer le contexte"}
export const ThemeContext = createContext(null);

{"// 2. Créer le Provider — composant qui encapsule la logique"}
export function ThemeProvider({ children }) {
  const [theme, setTheme] = useState('clair');

  function toggleTheme() {
    setTheme(prev => prev === 'clair' ? 'sombre' : 'clair');
  }

  {"// La valeur contient données ET fonctions"}
  const valeur = { theme, toggleTheme };

  return (
    <ThemeContext.Provider value={valeur}>
      {children}
    </ThemeContext.Provider>
  );
}

{"// Utilisation dans main.jsx :"}
{"// "}
Toujours encapsuler le Provider dans son propre composant. Cela garde la logique dans le fichier du contexte et simplifie l'utilisation dans main.jsx. On ne met pas le state directement dans main.jsx.
⚠️
Quand la valeur du Provider change, tous les consommateurs se re-rendent. Si vous passez un objet littéral value={{ theme, toggleTheme }} directement, un nouvel objet est créé à chaque rendu — même si theme n'a pas changé. Stocker la valeur dans une variable comme ci-dessus évite ce problème.
04 — useContext

Consommer le contexte avec useContext

useContext est le hook qui permet à n'importe quel composant enfant du Provider d'accéder à la valeur du contexte — sans props, directement.

1
useContext — lire la valeur du contexte
Une seule ligne pour accéder à tout
BoutonTheme.jsxuseContext
import { useContext } from 'react';
import { ThemeContext } from './contexts/ThemeContext';

function BoutonTheme() {
  {"// useContext retourne la valeur fournie par le Provider le plus proche"}
  const { theme, toggleTheme } = useContext(ThemeContext);

  return (
    <button
      onClick={toggleTheme}
      className={`btn-theme ${theme}`}
    >
      {theme === 'clair' ? '🌙 Mode sombre' : '☀️ Mode clair'}
    </button>
  );
}

function Page() {
  const { theme } = useContext(ThemeContext);
  return <div className={theme}>...</div>;
}

{"// Ces composants peuvent être n'importe où dans l'arbre"}
{"// tant qu'ils sont à l'intérieur du ThemeProvider"}
useContext se re-rend automatiquement quand la valeur du contexte change. Si le contexte retourne { theme, toggleTheme } et que theme change, tous les composants appelant useContext(ThemeContext) se re-rendent.
🚨
useContext retourne undefined si aucun Provider n'est présent. Si un composant appelle useContext mais n'est pas entouré par le Provider correspondant, il reçoit la valeur par défaut de createContext (souvent null). Toujours vérifier que le Provider enveloppe bien les bons composants.
05 — Hook personnalisé

Simplifier avec un hook personnalisé

Plutôt que d'importer useContext ET le contexte dans chaque composant, on crée un hook personnalisé qui fait les deux — et qui peut ajouter une vérification de sécurité.

→
Pattern useTheme / useAuth — le standard
Un hook par contexte, exporté depuis le fichier du contexte
contexts/ThemeContext.jsxHook custom
import { createContext, useState, useContext } from 'react';

const ThemeContext = createContext(null);

export function ThemeProvider({ children }) {
  const [theme, setTheme] = useState('clair');
  const valeur = {
    theme,
    estSombre: theme === 'sombre',
    toggleTheme: () => setTheme(t => t === 'clair' ? 'sombre' : 'clair'),
    setTheme,
  };
  return <ThemeContext.Provider value={valeur}>{children}</ThemeContext.Provider>;
}

{"// Hook personnalisé — la partie clé"}
export function useTheme() {
  const context = useContext(ThemeContext);

  {"// Vérification de sécurité — erreur claire si Provider absent"}
  if (context === null) {
    throw new Error('useTheme doit être utilisé dans un ThemeProvider');
  }

  return context;
}

{"// Utilisation dans n'importe quel composant enfant :"}
{"// import { useTheme } from './contexts/ThemeContext';"}
{"// const { theme, toggleTheme } = useTheme();"}
{"// Plus besoin d'importer useContext et ThemeContext séparément !"}
Ce pattern (contexte + provider + hook) est la structure standard utilisée dans tous les projets React professionnels. Le ThemeContext reste privé (non exporté) — seuls ThemeProvider et useTheme sont publics.
Avant vs après le hook personnalisé
Avant — 2 imports
{"// Dans chaque composant"}
import { useContext } from 'react';
import { ThemeContext } from
  './contexts/ThemeContext';

const { theme, toggleTheme }
  = useContext(ThemeContext);
✓ Après — 1 import, plus lisible
{"// Dans chaque composant"}
import { useTheme } from
  './contexts/ThemeContext';

const { theme, toggleTheme }
  = useTheme();
06 — Cas d'usage réels

Les contextes qu'on retrouve partout

Voici les 4 contextes qu'on retrouve dans pratiquement toutes les applications React professionnelles, avec leur implémentation complète.

🔐
AuthContext
Utilisateur connecté, token JWT, rôles, fonctions connexion/déconnexion
🎨
ThemeContext
Thème clair/sombre, couleurs personnalisées, persisté dans localStorage
🛒
PanierContext
Articles du panier, total, quantités, ajouter/supprimer des articles
🌍
LangueContext
Langue active, fonction de traduction, liste des langues disponibles
🔔
NotifContext
File de notifications toast, ajouter/supprimer des messages
📱
UIContext
Menu ouvert, modals actives, breakpoints, états d'interface globaux
→
AuthContext — exemple complet avec useEffect
Le contexte d'authentification le plus courant
contexts/AuthContext.jsxComplet
import { createContext, useState, useContext, useEffect } from 'react';

const AuthContext = createContext(null);

export function AuthProvider({ children }) {
  const [user,      setUser]      = useState(null);
  const [chargement, setChargement] = useState(true);

  {"// Restaurer la session au démarrage"}
  useEffect(() => {
    const userSauvegarde = localStorage.getItem('user');
    if (userSauvegarde) {
      setUser(JSON.parse(userSauvegarde));
    }
    setChargement(false);
  }, []);

  async function connexion(email, motDePasse) {
    const res = await fetch('/api/connexion', {
      method: 'POST',
      body: JSON.stringify({ email, motDePasse }),
      headers: { 'Content-Type': 'application/json' },
    });
    const data = await res.json();
    setUser(data.user);
    localStorage.setItem('user', JSON.stringify(data.user));
  }

  function deconnexion() {
    setUser(null);
    localStorage.removeItem('user');
  }

  const valeur = {
    user,
    chargement,
    connecte:  !!user,
    estAdmin:  user?.role === 'admin',
    connexion,
    deconnexion,
  };

  return (
    <AuthContext.Provider value={valeur}>
      {chargement ? <p>Chargement...</p> : children}
    </AuthContext.Provider>
  );
}

export function useAuth() {
  const ctx = useContext(AuthContext);
  if (!ctx) throw new Error('useAuth doit être dans AuthProvider');
  return ctx;
}
Le AuthProvider gère le chargement initial (lecture localStorage) et n'affiche les enfants qu'une fois prêt — ça évite un flash de contenu non authentifié au démarrage.
→
Utiliser AuthContext dans l'application
Routes protégées, composants conditionnels
App.jsx + composantsuseAuth
{"// main.jsx — envelopper toute l'app"}
<AuthProvider>
  <ThemeProvider>
    <App />
  </ThemeProvider>
</AuthProvider>

{"// Header.jsx — menu selon connexion"}
function Header() {
  const { connecte, user, deconnexion } = useAuth();
  return (
    <header>
      {connecte
        ? <span>Bonjour {user.nom} <button onClick={deconnexion}>Déconnexion</button></span>
        : <a href="/connexion">Se connecter</a>
      }
    </header>
  );
}

{"// RouteProtegee.jsx — rediriger si non connecté"}
function RouteProtegee({ children }) {
  const { connecte } = useAuth();
  if (!connecte) return <Navigate to="/connexion" />;
  return children;
}

{"// PanneauAdmin.jsx — affiché seulement si admin"}
function PanneauAdmin() {
  const { estAdmin } = useAuth();
  if (!estAdmin) return null;
  return <div className="admin-panel">...</div>;
}
07 — Limites & alternatives

Quand ne pas utiliser Context

Context n'est pas la solution à tout. L'utiliser à mauvais escient crée des problèmes de performance et de complexité. Voici les règles pour savoir quand l'utiliser ou non.

✓ Bons cas d'usage — utilisez Context
Des données vraiment globales, qui changent rarement

Thème (clair/sombre), utilisateur connecté, langue, panier — des données que de nombreux composants à différents niveaux ont besoin, et qui ne changent pas à chaque frappe.

✗ Mauvais cas d'usage — n'utilisez pas Context
State local d'un formulaire
{"// ❌ Inutile — useState suffit"}
const FormulaireCtx = createContext(null);

function Formulaire() {
  const [nom, setNom] = useState('');
  return (
    <FormulaireCtx.Provider value={{nom, setNom}}>
      <ChampNom />
    </FormulaireCtx.Provider>
  );
}
✓ useState + props (simpler)
{"// ✓ Props directes — lisible"}
function Formulaire() {
  const [nom, setNom] = useState('');
  return (
    <ChampNom
      nom={nom}
      onChange={setNom}
    />
  );
}
⚠️
Context et performance. Quand la valeur du contexte change, tous les composants qui le consomment se re-rendent. Si vous mettez des données qui changent souvent (comme la valeur d'un champ de recherche tapé lettre par lettre) dans un contexte consommé par 20 composants, vous déclenchez 20 re-renders à chaque frappe. Gardez le contexte pour les données stables.
La règle des 3 niveaux
Simple heuristique pour décider
1 niveau
Prop directe — ne même pas envisager le contexte
2-3 niveaux
Props encore raisonnables — pensez à la composition de composants avant le contexte
4+ niveaux
Le prop drilling devient pénible — Context est justifié si la donnée est utilisée à plusieurs endroits distants

Récapitulatif — les 3 pièces du puzzle
ÉlémentRôleOù
createContext(défaut)Crée le canal de communicationEn dehors des composants, dans un fichier dédié
<Context.Provider value={...}>Fournit la valeur à tous les descendantsHaut dans l'arbre (souvent main.jsx ou App)
useContext(Context)Lit la valeur du Provider le plus procheDans n'importe quel composant descendant
useXxx() hook customEncapsule useContext + vérification sécuritéExporté depuis le fichier du contexte
08 — Validation

Quiz & Travaux pratiques

4 questions de validation puis 3 exercices progressifs.

1. Quel problème le Context API résout-il principalement ?
2. Que retourne useContext(MonContext) si le composant n'est pas entouré par un Provider ?
3. Pourquoi créer un hook personnalisé (ex: useAuth()) plutôt d'utiliser directement useContext(AuthContext) ?
4. Quel est le risque de mettre une valeur qui change très fréquemment (ex: texte d'un input) dans un Context consommé par 15 composants ?

S10 — Travaux Pratiques · 3 exercices
Context API en pratique
1
ThemeContext — thème clair/sombre persisté
Créez ThemeContext.jsx avec ThemeProvider et useTheme(). State : theme ('clair'|'sombre'), initialisé depuis localStorage. Fonctions : toggleTheme, setTheme. Synchronisez avec localStorage via useEffect. Appliquez data-theme={theme} sur le body via useEffect. Créez 3 composants qui consomment useTheme() : BoutonToggle (toggle le thème), CarteProfil (change son fond selon le thème), Navbar (change sa couleur). Vérifiez que le thème persiste au rechargement.
2
PanierContext — panier e-commerce
Créez PanierContext.jsx avec PanierProvider et usePanier(). State : tableau items (chaque item : id, nom, prix, quantite). Fonctions : ajouterAuPanier(produit) (incrémente la quantité si déjà présent), retirerDuPanier(id), viderPanier(). Valeurs calculées dans le contexte : nbArticles (somme des quantités), total (prix × quantités). Composants à créer : ListeProduits (5 produits fixes, chacun avec un bouton "Ajouter"), IconePanier dans la navbar (affiche nbArticles), RecapPanier (liste les items avec quantité et prix, affiche le total).
3
AuthContext — authentification simulée complète
Créez AuthContext.jsx avec AuthProvider et useAuth(). Simulez l'API : si email="admin@test.com" et mdp="admin123" → connecté comme admin ; si email contient "@" et mdp de 6+ car. → connecté comme étudiant ; sinon → erreur. Persistez l'utilisateur dans localStorage et restaurez au montage. Créez : PageConnexion (formulaire RHF + Zod ou contrôlé, affiche les erreurs API via useAuth), Header (affiche nom + bouton déconnexion si connecté), RouteProtegee (composant wrapper qui affiche un message "Connectez-vous" si non connecté), PanneauAdmin (visible seulement si estAdmin). Composez tout dans App.