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 useRef para 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.

Três formas e quando o efeito roda
EscritaQuando rodaUso típico
useEffect(fn)Depois de toda renderizaçãoRaro; quase sempre é engano
useEffect(fn, [])Só depois da primeira renderizaçãoLigar algo que não depende de props nem estado
useEffect(fn, [sala])Na primeira e sempre que sala mudarSincronizar 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 sala nas dependências: com [], o efeito só roda na primeira renderização
  • document.title nã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]

  1. Componente → React: Renderiza sala "geral". O componente devolve o JSX. O React coloca no DOM e só depois roda o efeito.
  2. React → Servidor: Conecta em "geral". A configuração do efeito abre a conexão com a sala atual.
  3. Componente → React: Renderiza sala "vagas". A pessoa trocou de sala. A dependência mudou, então o efeito precisa sincronizar de novo.
  4. React → Servidor: Limpeza: sai de "geral". Antes de rodar de novo, o React chama a limpeza da execução anterior, com os valores antigos.
  5. React → Servidor: Conecta em "vagas". Agora sim a configuração roda com o valor novo.
  6. Componente → React: Sai da tela. A pessoa fechou o chat. O componente é desmontado, isto é, removido da tela.
  7. 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 null porque, na primeira renderização, o elemento ainda não existe no DOM.
  • Ligar ao elemento: Depois de colocar o input no DOM, o React guarda o elemento em campo.current. Quando ele sai da tela, volta a ser null.
  • Usar o elemento: Aqui campo.current é o elemento de verdade, o mesmo que querySelector devolveria. Use refs para o que o JSX não expressa: foco, rolagem, medir tamanho, tocar um vídeo.
Estado ou ref?
useStateuseRef
Mudar re-renderiza?SimNão
Como mudasetValor(novo)ref.current = novo
Pode ler durante a renderização?SimEvite: o valor pode estar desatualizado na tela
ExemplosTexto digitado, item selecionadoElemento 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) e renders.current++ num efeito sem dependências
  • Um estado: setRenders(renders + 1) num efeito sem dependências
  • Uma variável let renders = 0 dentro 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.
  • useRef guarda 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.

  1. Procure todos os useEffect do projeto e escreva ao lado de cada um com que sistema externo ele sincroniza
  2. Remova pelo menos um efeito que só copiava uma conta para o estado, trocando por uma variável
  3. Crie um componente com setInterval ou listener de resize, com limpeza, e confirme no console que a limpeza roda ao sair da tela
  4. Confira que o main.tsx usa <StrictMode> e que nenhum efeito se comporta diferente por causa dele
  5. Use uma ref para colocar o foco no primeiro campo de um formulário quando ele abrir

Referências

Cursos relacionados