Memoização no React: quando useMemo ajuda

Entenda o que useMemo, useCallback e React.memo realmente fazem, por que envolver tudo neles costuma piorar o código, e um critério prático pra decidir quando a memoização compensa.


Quem aprende React logo descobre useMemo e useCallback e passa a envolver tudo neles, por precaução. O resultado costuma ser um código mais difícil de ler que não ficou mais rápido. Memoização é uma ferramenta útil, mas com custo, e vale entender quando ele compensa.

Por que o React renderiza de novo

Um componente React é uma função. Sempre que o estado ou as props mudam, o React chama a função de novo, e todos os componentes filhos são renderizados junto, mesmo que as props deles não tenham mudado:

function Pai() {
  const [contador, setContador] = useState(0);
 
  return (
    <>
      <button onClick={() => setContador(contador + 1)}>+</button>
      <ListaPesada />
    </>
  );
}

A cada clique, ListaPesada renderiza de novo sem necessidade. Na maioria dos casos isso é rápido o bastante pra ninguém notar, e é por isso que a primeira regra é: não otimize antes de medir.

useMemo: guardar um cálculo

useMemo guarda o resultado de uma função e só a recalcula quando as dependências mudam:

function Relatorio({ vendas, filtro }) {
  const total = useMemo(() => {
    return vendas
      .filter((v) => v.categoria === filtro)
      .reduce((soma, v) => soma + v.valor, 0);
  }, [vendas, filtro]);
 
  return <p>Total: {total}</p>;
}

Faz sentido quando o cálculo é realmente caro (milhares de itens, ordenações, transformações pesadas). Para somar vinte números, o custo de comparar dependências e guardar o valor é maior que o do próprio cálculo.

React.memo: pular a renderização de um filho

React.memo envolve um componente e faz o React reaproveitar o resultado anterior se as props forem iguais:

const ListaPesada = memo(function ListaPesada({ itens }) {
  // renderização cara
  return <ul>{itens.map((i) => <li key={i.id}>{i.nome}</li>)}</ul>;
});

Agora, quando o Pai renderiza por causa do contador, a ListaPesada é pulada, desde que itens continue sendo a mesma referência.

useCallback: o pedaço que confunde

O problema aparece quando você passa funções ou objetos como props. Em JavaScript, duas funções com o mesmo código não são iguais:

(() => {}) === (() => {}); // false

A cada renderização do pai, uma função nova é criada, e o memo do filho enxerga uma prop diferente, anulando a otimização:

function Pai() {
  const [contador, setContador] = useState(0);
 
  // nova função a cada renderização, o memo do filho não adianta
  const salvar = () => console.log("salvo");
 
  return <ListaPesada onSalvar={salvar} />;
}

O useCallback mantém a mesma referência entre renderizações:

const salvar = useCallback(() => console.log("salvo"), []);

Aqui está o ponto central: useCallback sozinho não acelera nada. Ele só faz sentido combinado com um memo no filho que recebe a função, ou quando a função é dependência de um useEffect. Sem isso, você paga o custo e não recebe nada.

O problema do excesso

Memoizar tudo tem custos reais:

  • Complexidade: arrays de dependência pra manter, e uma dependência esquecida gera valores velhos (o mesmo mecanismo das closures).
  • Memória: valores guardados ficam vivos.
  • Comparação: o React compara as dependências a cada renderização, e isso também custa.
  • Leitura: código cheio de wrappers esconde a lógica.

Antes de memoizar, tente isto

Muitas vezes o problema se resolve sem nenhum hook:

  • Mover o estado pra baixo. Se só um pedaço da tela usa o contador, coloque o estado dentro de um componente menor, e o resto nem renderiza de novo.
  • Passar filhos como children. Elementos criados fora do componente que muda não são recriados.
  • Reduzir o trabalho. Paginar ou virtualizar uma lista de 10 mil itens ganha mais que qualquer useMemo.
// o estado fica isolado, ListaPesada não é afetada
function Contador() {
  const [n, setN] = useState(0);
  return <button onClick={() => setN(n + 1)}>{n}</button>;
}
 
function Pai() {
  return (
    <>
      <Contador />
      <ListaPesada />
    </>
  );
}

Um critério prático

  1. Perceba o problema primeiro: a tela engasga, ou o Profiler do React DevTools mostra renderizações caras.
  2. Tente reorganizar os componentes.
  3. Só então memoize o ponto específico que o Profiler apontou.

Vale lembrar que o React Compiler, que já vem sendo adotado em projetos novos, aplica memoização automática no build. Em projetos que o usam, boa parte desse trabalho manual deixa de ser necessário.

Fechando

useMemo guarda cálculos caros, memo pula renderizações de filhos e useCallback estabiliza funções pra esse memo funcionar. Nenhum deles é grátis, e nenhum substitui medir antes. Escreva o código simples, descubra o gargalo real e memoize só onde o ganho for visível.

Direto na sua
caixa de entrada.

Um aviso por e-mail sempre que eu publicar um post novo. Sem spam, sem newsletter chata, só isso.