État global — Context + useReducer
Dans ce chapitre, vous apprendrez à utiliser React Context + useReducer pour gérer les données partagées entre les composants et les pages, et à implémenter une fonctionnalité « articles favoris ».
Pourquoi avons-nous besoin d'un état global ?
Jusqu'à présent, les données sont transmises de couche en couche via les Props. Mais certaines données doivent être accessibles par plusieurs composants non liés :
- La liste des favoris doit être partagée entre la page d'accueil, la page de détail et la barre de navigation
- Toutes les pages doivent connaître l'état de connexion de l'utilisateur
- Les données du panier doivent être accessibles sur toutes les pages
Passage de Props de couche en couche (Prop Drilling)Le problème : A → B → C → D, les composants intermédiaires sont forcés de recevoir des Props qu'ils n'utilisent pas.
ContexteIl fournit un 'canal de données' global où tout composant descendant peut lire directement, en sautant les couches intermédiaires.
Concepts fondamentaux du Contexte
| Étapes | Code | Objectif |
|---|---|---|
| Créer un contexte | createContext() | Créer un conteneur de données partagé |
| Fournir des données | <Provider value={...}> | Envelopper le sommet de l'arbre de composants et injecter des données |
| Consommer des données | useContext(MyContext) | Lire les données dans n'importe quel composant descendant |
createContext et Provider
Exemple
// Étape 1 : Créer un contexte
const ThemeContext = createContext(null)
// Étape 2 : Créer un composant Provider
function ThemeProvider({ children }) {
const [theme, setTheme] = useState('light')
const toggleTheme = () => setTheme(theme === 'light' ? 'dark' : 'light')
return (
<ThemeContext.Provider value={{ theme, toggleTheme }}>
{children}
</ThemeContext.Provider>
)
}
// Étape 3 : Utilisez-le dans n'importe quel composant
function ThemedButton() {
const { theme, toggleTheme } = useContext(ThemeContext)
return (
<button onClick={toggleTheme}>
Thème actuel :{theme}
</button>
)
}
// Étape 4 : Envelopper le Provider dans App
function App() {
return (
<ThemeProvider>
<ThemedButton />
</ThemeProvider>
)
}
Le Context est comme une 'tour de diffusion' : le Provider diffuse les données vers l'extérieur, et useContext reçoit les données.
useReducer — Gestion d'un état complexe
Lorsque la logique d'état devient complexe (plusieurs sous-états, plusieurs méthodes de mise à jour), useState ne suffit plus.
useReducerIl fournit un modèle de gestion d'état similaire à Redux :dispatch action → reducer calcule le nouvel état。
Exemple
// fonction reducer : (état actuel, action) ⇒ nouvel état
function favoriteReducer(state, action) {
switch (action.type) {
case 'TOGGLE':
// Retirer des favoris si déjà dans les favoris, sinon ajouter
if (state.includes(action.id)) {
return state.filter(id => id !== action.id)
} else {
return [...state, action.id]
}
case 'CLEAR':
return []
default:
return state
}
}
function FavoriteDemo() {
// useReducer(reducer, valeur initiale)
const [favoriteIds, dispatch] = useReducer(favoriteReducer, [])
return (
<div>
<p>Nombre de favoris :{favoriteIds.length}</p>
<button onClick={() => dispatch({ type: 'TOGGLE', id: 1 })}>
{favoriteIds.includes(1) ? 'Retirer des favoris 1' : 'Favori 1'}
</button>
<button onClick={() => dispatch({ type: 'CLEAR' })}>Effacer les favoris</bouton>
</div>
)
}
useState vs useReducer
| Scénario | Recommandation | Raison |
|---|---|---|
| Un seul état indépendant | useState | Simple et direct |
| Plusieurs états interdépendants | useReducer | Un seul dispatch peut mettre à jour plusieurs états |
| Logique de mise à jour complexe | useReducer | Le reducer a des types d'action clairs, ce qui facilite le débogage |
| Doit être transmis à des composants profondément imbriqués | useState ou useReducer | Les deux peuvent être utilisés avec Context |
Modèle combiné Context + useReducer
C'est la solution de gestion d'état global la plus puissante dans React, et aussi l'idée centrale de Redux.
Exemple
import { createContext, useContext, useReducer, useEffect } from 'react'
// 1. Créer un contexte
const FavoriteContext = createContext(null)
// 2. Définir le reducer
function favoriteReducer(state, action) {
switch (action.type) {
case 'TOGGLE':
if (state.includes(action.id)) {
return state.filter(id => id !== action.id)
} else {
return [...state, action.id]
}
case 'CLEAR':
return []
default:
return state
}
}
// 3. Composant Provider : combiner Context + useReducer
export function FavoriteProvider({ children }) {
// Restaurer l'état initial depuis localStorage
const [favoriteIds, dispatch] = useReducer(favoriteReducer, [], () => {
const saved = localStorage.getItem('blog-favorites')
return saved ? JSON.parse(saved) : []
})
// Synchronisation automatique vers localStorage lorsque la liste des favoris change
useEffect(() => {
localStorage.setItem('blog-favorites', JSON.stringify(favoriteIds))
}, [favoriteIds])
// Encapsuler quelques méthodes courantes
function toggleFavorite(id) {
dispatch({ type: 'TOGGLE', id })
}
function isFavorite(id) {
return favoriteIds.includes(id)
}
const value = {
favoriteIds,
favoriteCount: favoriteIds.length,
toggleFavorite,
isFavorite
}
return (
<FavoriteContext.Provider value={value}>
{children}
</FavoriteContext.Provider>
)
}
// 4. Hook personnalisé : encapsuler useContext pour rendre l'appelant plus propre
export function useFavorites() {
const context = useContext(FavoriteContext)
if (!context) {
throw new Error('useFavorites doit être utilisé dans FavoriteProvider')
}
return context
}
Enregistrement du Provider dans main.jsx
Exemple
import React from 'react'
import ReactDOM from 'react-dom/client'
import { RouterProvider } from 'react-router-dom'
import { FavoriteProvider } from './context/FavoriteContext'
import router from './router'
import './index.css'
ReactDOM.createRoot(document.getElementById('root')).render(
<React.StrictMode>
{/* Enveloppez le Provider à la couche la plus externe afin que tous les composants puissent y accéder */}
<FavoriteProvider>
<RouterProvider router={router} />
</FavoriteProvider>
</React.StrictMode>
)
Pourquoi placer le Provider à l'extérieur de RouterProvider ? Parce que la NavBar (dans App) doit aussi lire l'état des favoris. Le Provider doit envelopper tous les composants qui ont besoin d'accéder à cet état.
Utilisation de la fonctionnalité Favoris dans les composants
Le bouton Favori dans BlogCard
Exemple
import { Link } from 'react-router-dom'
import { useFavorites } from '../context/FavoriteContext'
function BlogCard({ id, title, summary, date, category }) {
const { isFavorite, toggleFavorite } = useFavorites()
function handleFavorite(e) {
e.preventDefault() // Empêcher la navigation de Link
toggleFavorite(id)
}
return (
<Link to={`/post/${id}`} className="card-link">
<div className="card">
<span className="tag">{catégorie}</span>
<h3>{title}</h3>
<p>{summary}</p>
<div className="card-footer">
<span className="date">{date}</span>
<button className="fav-btn" onClick={handleFavorite}>
{isFavorite(id) ? '♥' : '♡'}
</button>
</div>
</div>
</Lien>
)
}
export default BlogCard
Le bouton Favori dans PostPage
Exemple
import { useFavorites } from '../context/FavoriteContext'
function PostPage() {
// ... autre code
const { isFavorite, toggleFavorite } = useFavorites()
return (
<article className="post-view">
<div className="post-header">
<h1>{article.title}</h1>
<button className="fav-btn" onClick={() => toggleFavorite(article.id)}>
{isFavorite(article.id) ? '♥ Ajouté aux favoris' : '♡ Ajouter aux favoris'}
</button>
</div>
{/* ... */}
</article>
)
}
Affichage du nombre de favoris dans NavBar
Exemple
import { useFavorites } from '../context/FavoriteContext'
function NavBar() {
const { favoriteCount } = useFavorites()
return (
<header className="navbar">
<a href="/" className="logo">EXEMPLE Blog</a>
<nav>
<a href="/">Accueil</a>
{favoriteCount > 0 && (
<span className="fav-badge">Favoris{favoriteCount}</span>
)}
</nav>
</header>
)
}
Après avoir ajouté un article aux favoris sur la page d'accueil, la page de détail affiche automatiquement « Ajouté aux favoris », et le nombre dans la barre de navigation se met à jour en synchronisation — c'est tout l'intérêt du partage global de Context.
Context + useReducer vs Vue3 Pinia
| Fonctionnalité | React Context + useReducer | Vue3 Pinia |
|---|---|---|
| Méthode d'intégration | Intégré à React, aucune installation requise | Bibliothèque autonome, nécessite une installation |
| Définition de l'état | Valeur initiale de useReducer | state: () => ({}) |
| Mise à jour de l'état | dispatch({ type, payload }) | Modification directe ou fonctions d'action |
| Propriétés calculées | Utilisation manuelle de useMemo | getters |
| Approche de la réactivité | Les changements de valeur du Provider déclenchent un nouveau rendu | Suivi automatique des dépendances |
| DevTools | Aucun outil intégré (nécessite Redux DevTools) | Prise en charge native de Vue DevTools |
Résumé du chapitre
Dans ce chapitre, vous avez maîtrisé la solution complète pour la gestion de l'état global de React : createContext crée le conteneur, Provider injecte les données, useContext consomme les données, et useReducer gère la logique de mise à jour complexe.
La fonctionnalité « articles favoris » maintient les données de la page d'accueil, de la page de détail et de la barre de navigation synchronisées globalement, et elles peuvent être restaurées via localStorage après l'actualisation de la page.
Plus de sujets