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".
user = { nom: 'Fatou' }
reçoit user, le passe juste…
reçoit user, le passe juste…
Layout et Sidebar ne font que transmettre user sans l'utiliser. C'est du bruit dans le code.
{"// 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>; }
{"// 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>; }
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.
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:() => {}, });
src/contexts/ avec un fichier par contexte. Par exemple : AuthContext.jsx, ThemeContext.jsx, PanierContext.jsx. Chaque fichier exporte le contexte ET son 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.
import { ThemeContext } from './contexts/ThemeContext'; {"// Envelopper l'application dans le Provider"} ReactDOM.createRoot(document.getElementById('root')).render( <ThemeContext.Provider value="sombre"> <App /> </ThemeContext.Provider> );
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 :"} {"//"}
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.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.
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"}
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é.
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 !"}
{"// Dans chaque composant"} import { useContext } from 'react'; import { ThemeContext } from './contexts/ThemeContext'; const { theme, toggleTheme } = useContext(ThemeContext);
{"// Dans chaque composant"} import { useTheme } from './contexts/ThemeContext'; const { theme, toggleTheme } = useTheme();
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.
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; }
{"// 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>; }
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.
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.
{"// ❌ Inutile — useState suffit"} const FormulaireCtx = createContext(null); function Formulaire() { const [nom, setNom] = useState(''); return ( <FormulaireCtx.Provider value={{nom, setNom}}> <ChampNom /> </FormulaireCtx.Provider> ); }
{"// ✓ Props directes — lisible"} function Formulaire() { const [nom, setNom] = useState(''); return ( <ChampNom nom={nom} onChange={setNom} /> ); }
| Élément | Rôle | Où |
|---|---|---|
createContext(défaut) | Crée le canal de communication | En dehors des composants, dans un fichier dédié |
<Context.Provider value={...}> | Fournit la valeur à tous les descendants | Haut dans l'arbre (souvent main.jsx ou App) |
useContext(Context) | Lit la valeur du Provider le plus proche | Dans n'importe quel composant descendant |
useXxx() hook custom | Encapsule useContext + vérification sécurité | Exporté depuis le fichier du contexte |
Quiz & Travaux pratiques
4 questions de validation puis 3 exercices progressifs.
useContext(MonContext) si le composant n'est pas entouré par un Provider ?useAuth()) plutôt d'utiliser directement useContext(AuthContext) ?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.
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).
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.