É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

ÉtapesCodeObjectif
Créer un contextecreateContext()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éesuseContext(MyContext)Lire les données dans n'importe quel composant descendant

createContext et Provider

Exemple

import { createContext, useContext, useState } from 'react'

// É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

import { useReducer } from 'react'

// 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énarioRecommandationRaison
Un seul état indépendantuseStateSimple et direct
Plusieurs états interdépendantsuseReducerUn seul dispatch peut mettre à jour plusieurs états
Logique de mise à jour complexeuseReducerLe reducer a des types d'action clairs, ce qui facilite le débogage
Doit être transmis à des composants profondément imbriquésuseState ou useReducerLes 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

// Chemin du fichier : src/context/FavoriteContext.jsx
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

// Chemin du fichier : src/main.jsx
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

// Chemin du fichier : src/components/BlogCard.jsx
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) ? '&#x2665;' : '♡'}
          </button>
        </div>
      </div>
    </Lien>
  )
}

export default BlogCard

Le bouton Favori dans PostPage

Exemple

// Chemin du fichier : src/pages/PostPage.jsx (partie clé)
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) ? '&#x2665; Ajouté aux favoris' : '♡ Ajouter aux favoris'}
        </button>
      </div>
      {/* ... */}
    </article>
  )
}

Affichage du nombre de favoris dans NavBar

Exemple

// Chemin du fichier : src/components/NavBar.jsx
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 + useReducerVue3 Pinia
Méthode d'intégrationIntégré à React, aucune installation requiseBibliothèque autonome, nécessite une installation
Définition de l'étatValeur initiale de useReducerstate: () => ({})
Mise à jour de l'étatdispatch({ type, payload })Modification directe ou fonctions d'action
Propriétés calculéesUtilisation manuelle de useMemogetters
Approche de la réactivitéLes changements de valeur du Provider déclenchent un nouveau renduSuivi automatique des dépendances
DevToolsAucun 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