Effects e refs
Sincronize componentes com o mundo fora do React usando useEffect com limpeza, evite efeitos desnecessários e use refs para foco e valores guardados.
Cerca de 15 min · Revisado em
Ao final, você vai conseguir
- Explicar quando um código pertence a um efeito, a um evento ou à renderização
- Declarar corretamente a lista de dependências de um efeito
- Escrever a limpeza de timers e listeners e explicar a execução dupla do StrictMode
- Reconhecer laços infinitos e efeitos que só copiam dados derivados
- Usar
useRefpara colocar o foco num elemento e guardar valores que não renderizam
Aquele número entre parênteses no título da aba do WhatsApp Web, o cronômetro do Pomodoro, o campo de busca que já abre com o cursor piscando: nada disso é desenhar a tela. É o React conversando com coisas que ficam fora dele. Fazer isso do jeito certo evita os bugs mais chatos de React, como timers que aceleram sozinhos e telas que piscam sem parar.
Renderizar é calcular; efeito é sincronizar
Até aqui seus componentes só faziam uma coisa: receber props e estado e devolver JSX. Essa conta precisa ser pura: mesmos dados, mesmo resultado, sem mexer em nada lá fora. Mas às vezes o componente precisa mexer lá fora: no título da aba, num timer, numa conexão de chat.
Um efeito (useEffect) é um código que o React roda depois de colocar a tela no DOM, para manter algum sistema de fora do React igual ao estado. “Fora do React” é qualquer coisa que o JSX não controla: document.title, setInterval, eventos da window, o servidor.
As três partes de um efeito.
useEffect(() => {
const id = setInterval(atualizarRelogio, 1000);
return () => clearInterval(id);
}, []);- Configuração: O que liga a sincronização. Roda depois que a tela aparece, nunca durante a renderização.
- Limpeza: Uma função opcional que desfaz o que a configuração fez. O React chama antes de rodar o efeito de novo e quando o componente sai da tela.
- Dependências: A lista de valores que o efeito usa. O React só roda de novo quando algum deles muda. Lista vazia: só depois da primeira renderização.
Onde cada código deve ficar?
Na renderização · No tratador do evento · Num efeito
- Calcular o total do carrinho
- Filtrar a lista pelo texto da busca
- Enviar o pedido quando a pessoa clica em Pagar
- Mostrar um aviso depois que o formulário é enviado
- Manter o título da aba igual ao número de mensagens
- Ouvir o redimensionamento da janela enquanto o componente está na tela
- Conectar ao chat da sala aberta e desconectar ao trocar de sala
O array de dependências
O segundo argumento do useEffect diz ao React quando sincronizar de novo. Ele compara cada valor da lista com o da renderização anterior; se nada mudou, o efeito é pulado.
| Escrita | Quando roda | Uso típico |
|---|---|---|
useEffect(fn) | Depois de toda renderização | Raro; quase sempre é engano |
useEffect(fn, []) | Só depois da primeira renderização | Ligar algo que não depende de props nem estado |
useEffect(fn, [sala]) | Na primeira e sempre que sala mudar | Sincronizar com um valor que muda |
A regra prática: todo valor de props ou estado usado dentro do efeito vai na lista. Você não escolhe as dependências; elas são consequência do código. Num projeto com Vite, o ESLint com o plugin de hooks avisa quando falta alguma.
O título da aba mostra o nome da primeira sala, mas não muda quando a pessoa troca de sala. Qual é o defeito?
function Chat({ sala }) {
useEffect(() => {
document.title = 'Sala ' + sala;
}, []);
// ...
}- Falta
salanas dependências: com[], o efeito só roda na primeira renderização document.titlenão pode ser alterado dentro de um efeito- Faltou uma função de limpeza que apague o título
Título da aba que acompanha o carrinho
Crie um efeito que mantém document.title sincronizado com o número de itens: com 0 itens, o título é Loja; com 2 itens, (2) Loja. Não esqueça a lista de dependências.
<div id="root"></div>body { font-family: system-ui, sans-serif; margin: 16px; }
button { margin-right: 8px; padding: 6px 14px; cursor: pointer; }const { useState, useEffect } = React;
function Carrinho() {
const [itens, setItens] = useState(0);
// TODO: sincronize o título da aba com o número de itens.
// 0 itens: "Loja". 2 itens: "(2) Loja".
return (
<div>
<p>Itens no carrinho: <strong id="itens">{itens}</strong></p>
<p>A prévia roda dentro de um quadro, então a aba do seu navegador não muda: os objetivos conferem o título por você.</p>
<button onClick={() => setItens(itens + 1)}>Adicionar item</button>
<button onClick={() => setItens(0)}>Esvaziar</button>
</div>
);
}
ReactDOM.createRoot(document.getElementById('root')).render(<Carrinho />);- Com 2 itens no carrinho, o título fica (2) Loja
- Ao esvaziar, o título volta para Loja
Limpar o que você ligou
A vida de um efeito com dependência [sala]
- Componente → React: Renderiza sala "geral". O componente devolve o JSX. O React coloca no DOM e só depois roda o efeito.
- React → Servidor: Conecta em "geral". A configuração do efeito abre a conexão com a sala atual.
- Componente → React: Renderiza sala "vagas". A pessoa trocou de sala. A dependência mudou, então o efeito precisa sincronizar de novo.
- React → Servidor: Limpeza: sai de "geral". Antes de rodar de novo, o React chama a limpeza da execução anterior, com os valores antigos.
- React → Servidor: Conecta em "vagas". Agora sim a configuração roda com o valor novo.
- Componente → React: Sai da tela. A pessoa fechou o chat. O componente é desmontado, isto é, removido da tela.
- React → Servidor: Limpeza: sai de "vagas". A última limpeza roda. Nada fica ligado sem dono.
Ouvir a janela enquanto o componente existe
useEffect(() => {
function aoRedimensionar() {
setLargura(window.innerWidth);
}
window.addEventListener('resize', aoRedimensionar);
return () => window.removeEventListener('resize', aoRedimensionar);
}, []);Cronômetro que não acelera
Clique em Iniciar, depois em Pausar: o tempo não para. Pause e inicie algumas vezes: ele acelera. O efeito liga um setInterval e nunca desliga. Guarde o id do intervalo e devolva uma limpeza com clearInterval.
<div id="root"></div>body { font-family: system-ui, sans-serif; margin: 16px; }
#tempo { font-size: 2rem; font-variant-numeric: tabular-nums; margin: 8px 0; }
button { margin-right: 8px; padding: 6px 14px; cursor: pointer; }const { useState, useEffect } = React;
function Cronometro() {
const [decimos, setDecimos] = useState(0);
const [rodando, setRodando] = useState(false);
useEffect(() => {
if (!rodando) return;
setInterval(() => {
setDecimos((anterior) => anterior + 1);
}, 100);
// TODO: devolva uma função de limpeza que pare o intervalo
}, [rodando]);
return (
<div>
<p id="tempo">{(decimos / 10).toFixed(1)} s</p>
<button onClick={() => setRodando(!rodando)}>{rodando ? 'Pausar' : 'Iniciar'}</button>
<button onClick={() => { setRodando(false); setDecimos(0); }}>Zerar</button>
</div>
);
}
ReactDOM.createRoot(document.getElementById('root')).render(<Cronometro />);- Iniciar faz o tempo andar
- Pausar desliga o intervalo, e o tempo para
- Pausar e iniciar várias vezes deixa só um intervalo ligado, sem acelerar
Três armadilhas com efeitos
Efeitos são a ferramenta do React mais usada sem necessidade. A documentação oficial tem uma página inteira chamada “Você talvez não precise de um efeito”. Estas são as três armadilhas que mais aparecem em código de iniciante.
Ao abrir esta tela, o navegador trava e o console enche de renderizações. Por quê?
function Perfil() {
const [visitas, setVisitas] = useState(0);
useEffect(() => {
setVisitas(visitas + 1);
});
return <p>{visitas} visitas</p>;
}- Sem lista de dependências, o efeito roda após toda renderização e muda o estado, que causa outra renderização, sem fim
useState(0)reinicia o contador a cada renderização- Faltou a função de limpeza
Armadilha dois: efeito para calcular algo que já dá para calcular
Com efeito (evite)
const [busca, setBusca] = useState('');
const [filtrados, setFiltrados] = useState(produtos);
useEffect(() => {
setFiltrados(produtos.filter((p) => p.nome.includes(busca)));
}, [busca]);
// Duas renderizações a cada tecla, e um estado espelho.Sem efeito (prefira)
const [busca, setBusca] = useState('');
const filtrados = produtos.filter((p) => p.nome.includes(busca));
// Calculado na renderização: uma renderização, sempre certo.A terceira armadilha é usar um efeito para reagir a uma ação da pessoa: guardar enviado = true no clique e ter um efeito que, ao ver enviado, faz o envio. Se o motivo do código é um clique, o código vai no tratador do clique. Efeito é para o que precisa acontecer porque a tela está aparecendo.
Uma colega diz: “coloquei a lista de dependências vazia para o efeito rodar menos e o aviso do ESLint sumiu quando apaguei a variável de lá”. O que pode dar errado?
O efeito passa a usar um valor congelado da primeira renderização. Se esse valor mudar, a tela fica dessincronizada, como o título que não troca de sala. Dependências não são um botão de desempenho: se o efeito roda demais, a solução é rever o código (talvez nem precise de efeito), não esconder as dependências.
useRef: uma gaveta que não redesenha a tela
useRef(valorInicial) devolve um objeto { current: valorInicial } que sobrevive às renderizações. Você lê e escreve em ref.current à vontade. Dois usos principais: guardar um valor que não aparece na tela (como o id de um timer) e acessar um elemento do DOM.
Colocar o foco num campo com uma ref.
function Busca() {
const campo = useRef(null);
return (
<>
<input ref={campo} />
<button onClick={() => campo.current.focus()}>
Buscar
</button>
</>
);
}- Criar a ref: Começa com
nullporque, na primeira renderização, o elemento ainda não existe no DOM. - Ligar ao elemento: Depois de colocar o
inputno DOM, o React guarda o elemento emcampo.current. Quando ele sai da tela, volta a sernull. - Usar o elemento: Aqui
campo.currenté o elemento de verdade, o mesmo quequerySelectordevolveria. Use refs para o que o JSX não expressa: foco, rolagem, medir tamanho, tocar um vídeo.
| useState | useRef | |
|---|---|---|
| Mudar re-renderiza? | Sim | Não |
| Como muda | setValor(novo) | ref.current = novo |
| Pode ler durante a renderização? | Sim | Evite: o valor pode estar desatualizado na tela |
| Exemplos | Texto digitado, item selecionado | Elemento do DOM, id de timer, valor anterior |
Foco no lugar certo
Crie duas refs. A primeira liga o campo de busca, e o botão Ir para a busca coloca o foco nele. A segunda liga o campo de nome; use um efeito com dependência [editando] para focar esse campo quando editando virar true.
<div id="root"></div>body { font-family: system-ui, sans-serif; margin: 16px; }
.busca { display: flex; gap: 8px; margin-bottom: 16px; }
input { padding: 6px; }
input:focus { outline: 3px solid #2563eb; }
button { padding: 6px 12px; cursor: pointer; }const { useState, useEffect, useRef } = React;
function Perfil() {
const [editando, setEditando] = useState(false);
const [nome, setNome] = useState('Maria');
// TODO 1: crie uma ref para o campo de busca
// TODO 2: crie uma ref para o campo de nome
// TODO 3: quando editando for true, coloque o foco no campo de nome
return (
<div>
<div className="busca">
<input id="busca" placeholder="Buscar na página" />
<button onClick={() => { /* TODO 4: foque o campo de busca */ }}>Ir para a busca</button>
</div>
{editando ? (
<div>
<label htmlFor="nome">Nome </label>
<input id="nome" value={nome} onChange={(e) => setNome(e.target.value)} />
<button onClick={() => setEditando(false)}>Salvar</button>
</div>
) : (
<p>
{nome} <button onClick={() => setEditando(true)}>Editar nome</button>
</p>
)}
</div>
);
}
ReactDOM.createRoot(document.getElementById('root')).render(<Perfil />);- Ir para a busca coloca o foco no campo de busca
- Ao clicar em Editar nome, o campo de nome já aparece com foco
Você quer contar quantas vezes o componente renderizou, só para depurar no console, sem mostrar na tela. O que usar?
- Uma ref:
const renders = useRef(0)erenders.current++num efeito sem dependências - Um estado:
setRenders(renders + 1)num efeito sem dependências - Uma variável
let renders = 0dentro do componente
Fechamento
- A renderização deve ser pura; um efeito roda depois dela para sincronizar o componente com algo de fora do React.
- A lista de dependências diz quando sincronizar de novo, e todo valor de props ou estado usado no efeito entra nela.
- Timers, listeners e conexões precisam de limpeza, a função devolvida pelo efeito; o StrictMode roda o efeito duas vezes em desenvolvimento para revelar limpezas faltando.
- Contas derivadas ficam na renderização e reações a cliques ficam no evento: muitos efeitos são desnecessários.
useRefguarda um valor que sobrevive às renderizações sem causar outra, e dá acesso a elementos do DOM para foco e medidas.
Faxina de efeitos
Use o projeto das aulas anteriores (ou um projeto React que você tenha) para praticar o que separa efeitos úteis de efeitos desnecessários.
- Procure todos os
useEffectdo projeto e escreva ao lado de cada um com que sistema externo ele sincroniza - Remova pelo menos um efeito que só copiava uma conta para o estado, trocando por uma variável
- Crie um componente com
setIntervalou listener deresize, com limpeza, e confirme no console que a limpeza roda ao sair da tela - Confira que o
main.tsxusa<StrictMode>e que nenhum efeito se comporta diferente por causa dele - Use uma ref para colocar o foco no primeiro campo de um formulário quando ele abrir