Hook useMemo: Computações Custosas em Cache e Referências Estáveis
Hook useMemo: Computações Custosas em Cache e Referências Estáveis
Executar filtragens massivas, ordenações complexas ou cálculos matemáticos pesados a cada renderização pode degradar severamente a taxa de quadros (FPS) da sua aplicação. O hook useMemo armazena em cache o resultado dessas computações e preserva referências imutáveis de objetos e arrays, poupando ciclos preciosos de CPU.
📑 Índice do Conteúdo
1. O que é o useMemo e Como Ele Funciona?
O useMemo é um hook nativo do React projetado para memorizar o resultado do cálculo de uma função entre as passadas de renderização. Sua anatomia consiste em uma função de cálculo e um array de dependências:
import { useMemo } from 'react';
const memoizedResult = useMemo(() => {
// ⚙️ Função de cálculo pura (executada apenas se 'a' ou 'b' mudarem)
return executeExpensiveCalculation(a, b);
}, [a, b]);
O ciclo de execução do useMemo opera sob duas regras estritas:
- Na montagem inicial (Mount): O React invoca a função fornecida, salva o valor retornado na memória e o entrega para o componente.
- Nas re-renderizações subsequentes: O React compara os valores do array de dependências com o render anterior via
Object.is(). Se nenhum valor tiver mudado, ele pula a execução da função de cálculo e retorna instantaneamente o valor que já estava em cache!
2. useCallback vs. useMemo: A Diferença Conceitual Definitiva
Uma das maiores fontes de confusão entre desenvolvedores React é a fronteira entre esses dois hooks irmãos. Na realidade, eles são duas faces da mesma moeda:
| Característica | useCallback(fn, deps) | useMemo(() => fn(), deps) |
|---|---|---|
| O que ele armazena em cache? | A própria função (o ponteiro da função). | O valor retornado pela função executada. |
| Objetivo Principal | Evitar que componentes filhos (React.memo) re-renderizem por quebra de referência de callbacks. |
Evitar re-computações pesadas de CPU e estabilizar objetos/arrays de configuração. |
| Equivalência | useCallback(fn, deps) |
Equivalente a: useMemo(() => fn, deps) |
3. Os Dois Grandes Casos de Uso do useMemo
Caso de Uso 1: Computações Pesadas (Expensive Calculations)
Imagine filtrar e ordenar uma lista de 5.000 produtos com múltiplos critérios. Se o componente pai re-renderizar por conta de um timer ou de um campo de texto não relacionado, re-filtrar 5.000 itens sem que a lista ou os filtros tenham mudado é um desperdício flagrante de CPU:
function ProductCatalog({ products, selectedCategory }) {
const [searchNote, setSearchNote] = useState(''); // Estado secundário
// ✅ O filtro pesado SÓ re-executa se 'products' ou 'selectedCategory' mudarem!
// Digitar em 'searchNote' não causa re-processamento da lista.
const filteredProducts = useMemo(() => {
console.time('filtro-pesado');
const result = products
.filter(p => p.category === selectedCategory)
.sort((a, b) => b.rating - a.rating);
console.timeEnd('filtro-pesado');
return result;
}, [products, selectedCategory]);
return (
<div>
<input value={searchNote} onChange={e => setSearchNote(e.target.value)} />
<ProductList items={filteredProducts} />
</div>
);
}
Caso de Uso 2: Estabilização de Referências de Objetos e Arrays
Assim como funções, literais de objetos ({ ... }) e arrays ([ ... ]) criam novos ponteiros de memória a cada renderização. O useMemo é essencial para estabilizar objetos passados como:
- Prop para Componentes Memoizados: Impede que um
<Chart options={options} />envolto emReact.memosofra re-render desnecessário. - Dependência de useEffect: Evita que um
useEffect(..., [config])dispare loops infinitos de chamadas à API. - Valor de Context Provider: Estabiliza
<ThemeContext.Provider value={contextValue}>para não disparar re-render em todos os consumidores da árvore global.
// ✅ Estabilizando o objeto de contexto:
const contextValue = useMemo(() => ({
theme,
toggleTheme,
user
}), [theme, toggleTheme, user]);
return <AppContext.Provider value={contextValue}>{children}</AppContext.Provider>;
4. Quando NÃO Usar useMemo: O Perigo da Otimização Prematura
Não adicione useMemo em todas as linhas do seu código! O hook introduz custos de sobrecarga:
- Alocação de um array de dependências e de uma função anônima em cada render.
- Tempo de CPU gasto pelo React comparando cada item do array de dependências com
Object.is.
useMemo, como:
// ❌ PÉSSIMA PRÁTICA (Gasta mais memória e CPU do que o próprio cálculo!):
const sum = useMemo(() => a + b, [a, b]);
const fullName = useMemo(() => `${firstName} ${lastName}`, [firstName, lastName]);
const isAdult = useMemo(() => age >= 18, [age]);
// ✅ FORMA CORRETA (Cálculos primitivos em nano-segundos):
const sum = a + b;
const fullName = `${firstName} ${lastName}`;
const isAdult = age >= 18;
Regra Prática da Engenharia: Só utilize useMemo para cálculos que consumam mais de 1ms a 2ms de tempo de CPU (aferidos via performance.now() ou React Profiler) ou para garantir estabilidade referencial de objetos.
5. Laboratório Prático: Simulador de Benchmark de Computações Pesadas
No laboratório interativo abaixo, teste o impacto de useMemo em um cálculo simulado de processamento de carteira de investimentos com milhares de operações financeiras. Alterne o estado do formulário de anotações no componente pai e compare em tempo real o tempo de execução (em milissegundos) e o consumo de CPU entre o cálculo não memoizado e o cálculo blindado com useMemo!
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.
Editor de Códigos Web Online
Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.
Abrir Ferramenta OnlinePlayground 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