Globaler Zustand — Context + useReducer
In diesem Kapitel lernst du, wie du React Context + useReducer verwendest, um gemeinsam genutzte Daten komponenten- und seitenübergreifend zu verwalten, und implementierst eine Funktion für 'Lieblingsartikel'.
Warum brauchen wir einen globalen Zustand?
Bisher werden Daten Ebene für Ebene durch Props weitergegeben. Aber auf einige Daten muss von mehreren nicht zusammenhängenden Komponenten zugegriffen werden:
- Die Favoritenliste muss zwischen Startseite, Detailseite und Navigationsleiste geteilt werden
- Alle Seiten müssen den Anmeldestatus des Benutzers kennen
- Warenkorbdaten müssen seitenübergreifend zugänglich sein
Props werden Ebene für Ebene weitergegeben (Prop Drilling)Der Schmerzpunkt: A → B → C → D, Zwischenkomponenten sind gezwungen, Props zu empfangen, die sie nicht verwenden.
ContextEs bietet einen globalen 'Datenkanal', aus dem jede untergeordnete Komponente direkt lesen kann, ohne die Zwischenschichten zu durchlaufen.
Kernkonzepte von Context
| Schritte | Code | Zweck |
|---|---|---|
| Context erstellen | createContext() | Einen gemeinsamen Datencontainer erstellen |
| Daten bereitstellen | <Provider value={...}> | Die oberste Ebene des Komponentenbaums umschließen und Daten injizieren |
| Daten konsumieren | useContext(MyContext) | Daten in jeder untergeordneten Komponente lesen |
createContext und Provider
Beispiel
// Schritt 1: Context erstellen
const ThemeContext = createContext(null)
// Schritt 2: Eine Provider-Komponente erstellen
function ThemeProvider({ children }) {
const [theme, setTheme] = useState('light')
const toggleTheme = () => setTheme(theme === 'light' ? 'dark' : 'light')
return (
<ThemeContext.Provider value={{ theme, toggleTheme }}>
{children}
</ThemeContext.Provider>
)
}
// Schritt 3: In jeder Komponente verwenden
function ThemedButton() {
const { theme, toggleTheme } = useContext(ThemeContext)
return (
<button onClick={toggleTheme}>
Aktuelles Theme:{theme}
</button>
)
}
// Schritt 4: Den Provider in App einbinden
function App() {
return (
<ThemeProvider>
<ThemedButton />
</ThemeProvider>
)
}
Context ist wie ein 'Sendeturm': Provider sendet Daten nach außen, und useContext empfängt die Daten.
useReducer — Komplexen State verwalten
Wenn die State-Logik komplex wird (mehrere Sub-States, mehrere Update-Methoden), reicht useState nicht aus.
useReducerEs bietet ein State-Management-Muster ähnlich wie Redux:dispatch action → reducer berechnet den neuen State。
Beispiel
// Reducer-Funktion: (aktueller State, action) ⇒ neuer State
function favoriteReducer(state, action) {
switch (action.type) {
case 'TOGGLE':
// Aus Favoriten entfernen, wenn bereits favorisiert, andernfalls hinzufügen
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, Anfangswert)
const [favoriteIds, dispatch] = useReducer(favoriteReducer, [])
return (
<div>
<p>Favoritenanzahl:{favoriteIds.length}</p>
<button onClick={() => dispatch({ type: 'TOGGLE', id: 1 })}>
{favoriteIds.includes(1) ? 'Aus Favoriten entfernen 1' : 'Favorit 1'}
</button>
<button onClick={() => dispatch({ type: 'LÖSCHEN' })}>Favoriten löschen</Schaltfläche>
</div>
)
}
useState vs. useReducer
| Szenario | Empfehlung | Grund |
|---|---|---|
| Ein einzelner unabhängiger Zustand | useState | Einfach und direkt |
| Mehrere zusammenhängende Zustände | useReducer | Mit einem dispatch können mehrere Zustände aktualisiert werden |
| Komplexe Aktualisierungslogik | useReducer | Der Reducer hat klare Action-Typen, was das Debuggen erleichtert |
| Muss an tief verschachtelte Komponenten weitergegeben werden | useState oder useReducer | Beide können mit Context verwendet werden |
Kombiniertes Muster aus Context + useReducer
Dies ist die leistungsstärkste Lösung für globales State-Management in React und zugleich die Kernidee von Redux.
Beispiel
import { createContext, useContext, useReducer, useEffect } from 'react'
// 1. Context erstellen
const FavoriteContext = createContext(null)
// 2. Den Reducer definieren
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. Provider-Komponente: Context + useReducer kombinieren
export function FavoriteProvider({ children }) {
// Anfangszustand aus localStorage wiederherstellen
const [favoriteIds, dispatch] = useReducer(favoriteReducer, [], () => {
const saved = localStorage.getItem('blog-favorites')
return saved ? JSON.parse(saved) : []
})
// Automatisch mit localStorage synchronisieren, wenn sich die Favoritenliste ändert
useEffect(() => {
localStorage.setItem('blog-favorites', JSON.stringify(favoriteIds))
}, [favoriteIds])
// Ein paar gängige Methoden umschließen
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. Benutzerdefinierter Hook: useContext umschließen, um den Aufrufer übersichtlicher zu machen
export function useFavorites() {
const context = useContext(FavoriteContext)
if (!context) {
throw new Error('useFavorites muss innerhalb von FavoriteProvider verwendet werden')
}
return context
}
Provider in main.jsx registrieren
Beispiel
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>
{/* Den Provider in der äußersten Ebene umschließen, damit alle Komponenten darauf zugreifen können */}
<FavoriteProvider>
<RouterProvider router={router} />
</FavoriteProvider>
</React.StrictMode>
)
Warum den Provider außerhalb von RouterProvider platzieren? Weil die NavBar (in App) auch den Favoritenstatus lesen muss. Der Provider muss alle Komponenten umschließen, die Zugriff auf diesen Status benötigen.
Verwenden der Favoriten-Funktion in Komponenten
Der Favoriten-Button in BlogCard
Beispiel
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() // Link-Navigation verhindern
toggleFavorite(id)
}
return (
<Link to={`/post/${id}`} className="card-link">
<div className="card">
<span className="tag">{Kategorie}</span>
<h3>{title}</h3>
<p>{summary}</p>
<div className="card-footer">
<span className="date">{Datum}</span>
<button className="fav-btn" onClick={handleFavorite}>
{isFavorite(id) ? '♥' : '♡'}
</button>
</div>
</div>
</Link>
)
}
export default BlogCard
Der Favoriten-Button in PostPage
Beispiel
import { useFavorites } from '../context/FavoriteContext'
function PostPage() {
// ... sonstiger 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) ? '♥ Favorisiert' : '♡ Favorit'}
</button>
</div>
{/* ... */}
</article>
)
}
Anzeigen der Favoritenanzahl in NavBar
Beispiel
import { useFavorites } from '../context/FavoriteContext'
function NavBar() {
const { favoriteCount } = useFavorites()
return (
<header className="navbar">
<a href="/" className="logo">BEISPIEL Blog</a>
<nav>
<a href="/">Startseite</a>
{favoriteCount > 0 && (
<span className="fav-badge">Favoriten{favoriteCount}</span>
)}
</nav>
</header>
)
}
Nachdem ein Artikel auf der Startseite favorisiert wurde, zeigt die Detailseite automatisch 'Favorisiert' an, und die Zahl in der Navigationsleiste wird synchron aktualisiert — das ist der Nutzen der globalen Zustandsteilung mit Context.
Context + useReducer vs. Vue3 Pinia
| Merkmal | React Context + useReducer | Vue3 Pinia |
|---|---|---|
| Integrationsmethode | In React integriert, keine Installation erforderlich | Eigenständige Bibliothek, Installation erforderlich |
| State-Definition | Initialwert von useReducer | state: () => ({}) |
| State-Update | dispatch({ type, payload }) | Direkte Änderung oder Aktionsfunktionen |
| Berechnete Eigenschaften | Manuelles useMemo | Getter |
| Reaktivitätsansatz | Änderungen des Provider-Werts lösen ein erneutes Rendern aus | Automatische Abhängigkeitsverfolgung |
| DevTools | Keine integrierte Unterstützung (erfordert Redux DevTools) | Native Unterstützung für Vue DevTools |
Kapitelzusammenfassung
In diesem Kapitel haben Sie die vollständige Lösung für die globale Zustandsverwaltung in React gemeistert: createContext erstellt den Container, Provider injiziert Daten, useContext konsumiert Daten und useReducer verwaltet komplexe Aktualisierungslogik.
Die Funktion „Lieblingsartikel“ hält die Daten auf der Startseite, der Detailseite und der Navigationsleiste global synchronisiert, und die Daten können nach dem Aktualisieren der Seite über localStorage wiederhergestellt werden.
Weitere Themen