Carrinho de Compras com React: Context API e Reducer
⚡ Curso de React.js • Web-ZoneWare

Projeto Prático 1: Sistema de Carrinho de Compras com Context API e useReducer

Lição 47 de 50

Projeto Prático 1: Sistema de Carrinho de Compras com Context API e useReducer

Módulo 6 • Lição 47 (Projeto Prático 1 • 94% do Curso • Pauta Satélite 392)

Projeto Prático 1: Sistema de Carrinho de Compras com Context API e useReducer

Bem-vindo ao primeiro grande projeto final da Web Academy! Neste projeto de nível de produção, consolidaremos os conceitos mais críticos do React moderno: a união entre Context API e useReducer para criar um sistema de Carrinho de Compras completo, com persistência no localStorage, cálculos reativos de cupons de desconto e drawer lateral acessível.

1. Requisitos do Sistema & Arquitetura Global

O gerenciamento de um carrinho de compras em uma plataforma de e-commerce é um dos maiores desafios de estado compartilhado. Componentes espalhados por toda a aplicação precisam de acesso simultâneo aos dados:

  • Badge do Cabeçalho: Precisa exibir a quantidade total de itens atualizada em tempo real;
  • Cards da Vitrine: Precisam disparar a ação de adicionar itens ou incrementar a quantidade caso o produto já esteja na cesta;
  • Drawer Lateral de Checkout: Precisa listar os itens, permitir alterações incrementais (+/-), exclusão direta, aplicação de cupons promocionais e cálculo instantâneo de totais;
  • Persistência no Disco: Se o usuário fechar a aba ou recarregar a página (F5), os itens do carrinho e cupons devem permanecer salvos no localStorage.

2. Definindo o Reducer Puro: `cartReducer`

Para garantir previsibilidade absoluta e facilidade de testes, centralizamos todas as mutações de estado em uma função reducer pura com ações descritivas:

JavaScript 48 linhas
export const initialState = {
    items: [],
    couponCode: '',
    discountPercent: 0
};
 
export function cartReducer(state, action) {
    switch (action.type) {
        case 'ADD_ITEM': {
            const existingIndex = state.items.findIndex(i => i.id === action.payload.id);
            if (existingIndex > -1) {
                // Item já existe: incrementar quantidade imutavelmente
                const updatedItems = state.items.map((item, idx) => 
                    idx === existingIndex ? { ...item, qty: item.qty + 1 } : item
                );
                return { ...state, items: updatedItems };
            }
            // Item novo: adicionar com quantidade 1
            return { ...state, items: [...state.items, { ...action.payload, qty: 1 }] };
        }
 
        case 'UPDATE_QTY': {
            const { id, qty } = action.payload;
            if (qty  i.id !== id) };
            }
            return {
                ...state,
                items: state.items.map(i => i.id === id ? { ...i, qty } : i)
            };
        }
 
        case 'REMOVE_ITEM':
            return { ...state, items: state.items.filter(i => i.id !== action.payload.id) };
 
        case 'APPLY_COUPON':
            return { 
                ...state, 
                couponCode: action.payload.code, 
                discountPercent: action.payload.discount 
            };
 
        case 'CLEAR_CART':
            return { ...state, items: [], couponCode: '', discountPercent: 0 };
 
        default:
            return state;
    }
}

3. Criando o Provedor Contextual e o Custom Hook `useCart`

Empacotamos o reducer dentro de um Provedor Contextual que sincroniza automaticamente com o localStorage e expõe um custom hook com memoização inteligente para evitar re-computações desnecessárias:

JavaScript 59 linhas
import React, { createContext, useContext, useReducer, useEffect, useMemo } from 'react';
 
const CartContext = createContext(null);
 
export function CartProvider({ children }) {
    // Inicialização segura com persistência no localStorage
    const [state, dispatch] = useReducer(cartReducer, initialState, () => {
        try {
            const saved = localStorage.getItem('wzw_cart_data');
            return saved ? JSON.parse(saved) : initialState;
        } catch {
            return initialState;
        }
    });
 
    // Sincronizar qualquer alteração do carrinho no disco
    useEffect(() => {
        try {
            localStorage.setItem('wzw_cart_data', JSON.stringify(state));
        } catch (e) {
            console.warn('Erro ao salvar carrinho no localStorage', e);
        }
    }, [state]);
 
    // Métricas financeiras calculadas com useMemo
    const subtotal = useMemo(() => {
        return state.items.reduce((acc, item) => acc + (item.price * item.qty), 0);
    }, [state.items]);
 
    const totalItems = useMemo(() => {
        return state.items.reduce((acc, item) => acc + item.qty, 0);
    }, [state.items]);
 
    const discountValue = useMemo(() => {
        return (subtotal * state.discountPercent) / 100;
    }, [subtotal, state.discountPercent]);
 
    const totalFinal = Math.max(0, subtotal - discountValue);
 
    const value = {
        state,
        dispatch,
        subtotal,
        totalItems,
        discountValue,
        totalFinal
    };
 
    return <CartContext.Provider value={value}>{children}</CartContext.Provider>;
}
 
// Hook defensivo com validação de escopo
export function useCart() {
    const context = useContext(CartContext);
    if (!context) {
        throw new Error('useCart deve ser utilizado obrigatoriamente dentro de um ');
    }
    return context;
}

4. Vantagens Arquiteturais Desta Solução

  • Desacoplamento Completo: A vitrine de produtos não sabe nem precisa saber como o carrinho calcula cupons ou salva dados no disco; ela apenas dispara dispatch({ type: 'ADD_ITEM', payload: prod }).
  • Fonte Única da Verdade: Não há risco de discrepância entre o contador do cabeçalho e os itens listados no drawer lateral.
  • Zero Dependências Externas: Implementado 100% com hooks nativos do React (useContext, useReducer, useMemo, useEffect), sem necessidade de bibliotecas pesadas de estado global como Redux.

Laboratório Prático no Playground Web IDE

Experimente no editor abaixo a aplicação completa em funcionamento! Adicione produtos à cesta, abra o Drawer lateral, teste os cupons de desconto (use REACT10 para 10% OFF ou WZW20 para 20% OFF), altere quantidades e teste a persistência em tempo real!

🛠️ Laboratório Prático & Prática Imediata

Aplique o que você aprendeu nesta lição

Utilize nossas ferramentas online gratuitas para experimentar os conceitos ou teste o código ao vivo no Playground IDE.

💻 Desenvolvedor & Código

Editor de Códigos Web Online

Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.

Abrir Ferramenta Online
⚡ Live Code Studio

Playground Web Online

Escreva seu código HTML, CSS ou JavaScript e veja o resultado renderizado ao vivo no navegador com zero configuração.

⚡ Codificar no Playground IDE
Foto de Web-Zoneware
✓ Verificado
🎓 Tutor & Coordenador da Web Academy

Web-Zoneware

Tutor Técnico & Desenvolvedor Full-Stack

Desenvolvedor web e instrutor focado na formação prática de novos programadores. Defensor ferrenho de código semântico, arquitetura limpa e acessibilidade W3C/WCAG, dedicando-se a construir cursos estruturados em metodologia passo a passo com execução ao vivo no Playground IDE.

Especialidades: HTML5 Semântico CSS3 & Flexbox/Grid JavaScript Moderno Acessibilidade WCAG 2.2 Didática Prática
Rolar para cima