Estado global con useContext y useReducer
Vídeo, capítulos y transcripción
Contenido acompañado de los subtítulos automáticos del vídeo. La transcripción puede contener errores de reconocimiento.
- 0:00Introducción, iniciar proyecto e instalación dependencias
- 2:40Limpiar el código que viene por defecto
- 3:25Copia de iconos
- 3:55Listar Productos de la tienda
- 10:40Añadir filtros de la tienda
- 19:12Estilando los filtros
- 20:54Mejorando filtro rango
- 22:15Hacer que los filtros funcionen
- 29:46Prop Drilling
- 32:30useId, para crear identificadores
- 37:50useContext, crear contextos en React y para qué sirve
- 55:42¿Cuándo usar useContext?
- 57:15Evitar prop drilling con useContext
- 60:10Dos fuentes de la verdad. ¿Qué es y cómo arreglarlo?
- 69:41Creación de un carrito desde cero
- 72:50Crear menú flotante con CSS
- 76:50Crear Contexto para el Carrito de la Tienda
- 87:21Mostrar visualmente que el producto está añadido al carrito
- 94:34Mostrar la info del carrito
- 98:55¿Qué es el método bind y para qué sirve?
- 100:11useReducer, manejando estados más complejos
Una tienda con una sola fuente de la verdad
En esta clase construimos una tienda con filtros y carrito. El recorrido del vídeo empieza listando productos, añade filtros por categoría y precio y termina separando las operaciones del carrito en un reducer. El objetivo es entender dónde vive el estado, cómo lo leen los componentes y cómo lo actualizamos sin duplicarlo.
Abre la demo de la tienda y prueba a añadir dos veces el mismo producto, eliminarlo y cambiar el precio mínimo. Son comportamientos distintos: los filtros afectan al catálogo visible; el carrito conserva los productos que has elegido.
Primero, deriva los productos visibles
Guarda en el estado las decisiones del usuario: categoría y precio mínimo. La lista filtrada puede calcularse a partir de esos valores y del catálogo. Guardar también esa lista como estado obliga a sincronizar dos representaciones de la misma información.
const [filters, setFilters] = useState({ category: 'all', minPrice: 0 })
const filteredProducts = products.filter(product => {
const matchesCategory = filters.category === 'all'
|| product.category === filters.category
return matchesCategory && product.price >= filters.minPrice
})El control de categoría actualiza filters.category; el rango de precio actualiza filters.minPrice. Usa la forma funcional si la actualización depende del objeto anterior: setFilters(previous => ({ ...previous, minPrice })).
Identifica el prop drilling
Pasar props explícitas es una buena opción mientras el recorrido sea corto. El problema aparece cuando varios componentes intermedios reciben datos que no utilizan, solo para reenviarlos. En el vídeo se introduce Context para dar acceso a los filtros y al carrito desde lugares separados del árbol.
import { createContext, useContext, useState } from 'react'
const FiltersContext = createContext(null)
export function FiltersProvider({ children }) {
const [filters, setFilters] = useState({ category: 'all', minPrice: 0 })
return (
<FiltersContext.Provider value={{ filters, setFilters }}>
{children}
</FiltersContext.Provider>
)
}
export function useFilters() {
const context = useContext(FiltersContext)
if (!context) throw new Error('Falta FiltersProvider')
return context
}Coloca el provider por encima de los componentes que necesitan compartir esos datos. Dos providers separados representan dos estados independientes: es la causa del problema de las «dos fuentes de la verdad» que se analiza en la clase.
Modela el carrito como acciones
El carrito tiene operaciones reconocibles: añadir, eliminar y vaciar. En lugar de repartir sus reglas entre componentes, una función reducer recibe el estado anterior y una acción, y devuelve el siguiente estado.
function cartReducer(cart, action) {
switch (action.type) {
case 'add': {
const exists = cart.some(item => item.id === action.product.id)
return exists
? cart.map(item => item.id === action.product.id
? { ...item, quantity: item.quantity + 1 }
: item)
: [...cart, { ...action.product, quantity: 1 }]
}
case 'remove':
return cart.filter(item => item.id !== action.id)
case 'clear':
return []
default:
return cart
}
}
const [cart, dispatch] = useReducer(cartReducer, [])La interfaz solo necesita expresar una intención: dispatch({ type: 'add', product }). El reducer decide cómo cambiar la cantidad o insertar una nueva línea. Evita modificar el array recibido: una nueva referencia permite representar correctamente la actualización.
dispatch({ type: 'add', product })El botón describe qué ha ocurrido. No necesita conocer las reglas para incrementar cantidades.
nextCart = cartReducer(cart, action)El reducer calcula el estado siguiente sin modificar el anterior.
cart.map(item => <CartItem />)Context distribuye el nuevo valor y los componentes muestran las cantidades actualizadas.
Persistencia y accesibilidad
Puedes guardar el carrito en localStorage y recuperarlo al iniciar. Como ampliación respecto al ejemplo original, mantén el reducer puro y realiza la persistencia en un efecto. La lectura inicial debe contemplar JSON inválido o almacenamiento no disponible. En un entorno con servidor, no leas window durante el render del servidor.
Para los filtros, useId ayuda a relacionar un label con su control. No lo uses como identificador de productos: esos IDs deben proceder de los datos y ser estables.
Comprueba lo aprendido
- Añade un producto dos veces: debe existir una línea con cantidad dos.
- Cambia los filtros: el contenido del carrito no debe desaparecer.
- Elimina un producto: los demás conservan sus cantidades.
- Recarga la página y comprueba la persistencia.
Reto: añade una acción para reducir una unidad. Decide explícitamente qué ocurre cuando la cantidad llega a cero. Calcula el importe total a partir del carrito, sin guardarlo como un estado independiente.