Quando você realmente precisa de uma biblioteca de gerenciamento de estado?

Question

Accepted Answer

Você **não precisa sempre de uma**. Frameworks modernos têm ferramentas de estado integradas capazes, e recorrer prematuro a Redux/Zustand adiciona complexidade. A resposta honesta: adicione uma biblioteca apenas quando as opções integradas se tornarem dolorosas.

## Comece com ferramentas integradas

```jsx
// most state needs are met by:
const [x, setX] = useState();           // local component state
const value = useContext(MyContext);    // share across a subtree
const memo = useMemo(() => derive(), [x]); // derived values
// + a server-state library (React Query) for fetched data
```

Estado local + Context + (para dados remotos) React Query cobre a grande maioria dos apps. Muitos apps em produção não precisam de nenhuma biblioteca de estado global.

## Sinais de que você pode realmente precisar de uma biblioteca

```text
✓ Lots of GLOBAL state shared across many distant components
✓ Complex state interactions / frequent updates that Context handles poorly
                       (Context re-renders all consumers on any change)
✓ You need devtools, time-travel debugging, or strict update traceability
✓ Many components both read AND write the same shared state
✓ Predictable, centralized update logic matters for a large team
```

## Por que não apenas "sempre usar Redux"?

```text
Cost of a library: boilerplate, learning curve, more indirection, bundle size.
For a small/medium app, that cost often outweighs the benefit.
```

## Combine a ferramenta à necessidade

```text
Server/remote data        → React Query / SWR (NOT a global store)
A few global values        → Context, or a tiny store (Zustand/Jotai)
Large, complex shared state→ Redux Toolkit, or Zustand for less boilerplate
Form state                 → a form library (React Hook Form), not global state
```

Uma grande parcela de "precisamos de Redux" é na verdade um problema de estado do servidor melhor resolvido por React Query, ou alguns valores resolvidos por Context/Zustand.

## Por que isso importa

Saber *quando* uma biblioteca de estado é justificada previne o erro comum de over-engineering — adicionar Redux a um app que precisa apenas de `useState` e Context.

A abordagem madura é começar simples, identificar a *dor específica* (compartilhamento profundo, atualizações complexas, cache de servidor) e recorrer à *ferramenta certa* para essa dor (frequentemente um store leve ou uma biblioteca de estado do servidor, não uma pesada global).

Escolher a solução mínima que se adequa mantém apps mais simples, mais rápidos de construir e mais fáceis de manter.