rochasolutions
Arquitetura

Hooks Customizados em React: Como Criar e Quando Usar?

Danilo Rocha6 min de leitura

O que são hooks customizados em React

Hook customizado em React é uma função própria, com nome começando em use, que reaproveita lógica com estado ou efeito entre componentes diferentes. Não é um recurso novo da biblioteca: é uma convenção que empacota um ou mais hooks nativos, como useState ou useEffect, dentro de uma função que qualquer componente pode chamar.

Na prática, o padrão aparece quando dois componentes resolvem o mesmo problema cada um à sua maneira. Suponha um componente que busca dados de pedidos e outro que busca dados de clientes: os dois declaram useState para o resultado, useState para o estado de carregamento, useState para o erro, e um useEffect que dispara a chamada à API. O código é quase idêntico, só muda a URL. Um hook customizado como useFetch(url) tira essa repetição do componente e devolve só o que ele precisa: dado, carregando, erro.

function useFetch(url) {
  const [dado, setDado] = useState(null);
  const [carregando, setCarregando] = useState(true);
  const [erro, setErro] = useState(null);

  useEffect(() => {
    let ativo = true;
    fetch(url)
      .then((res) => res.json())
      .then((json) => ativo && setDado(json))
      .catch((err) => ativo && setErro(err))
      .finally(() => ativo && setCarregando(false));
    return () => {
      ativo = false;
    };
  }, [url]);

  return { dado, carregando, erro };
}

Cada componente que chama useFetch ganha a mesma lógica sem copiar uma linha dela.

Quando vale extrair lógica para um hook customizado

Vale extrair quando a mesma combinação de estado e efeito aparece em dois componentes ou mais, ou quando a lógica é complexa demais para testar sem montar a tela inteira.

O sinal mais fácil de ver é a repetição: se você copiou um bloco de useState e useEffect de um componente para outro e só trocou um parâmetro, esse bloco já é candidato a hook. O segundo sinal é menos óbvio, mas pesa mais a longo prazo. Um componente que mistura regra de negócio, como validação de formulário ou cálculo de total de carrinho, com o JSX que desenha a tela fica difícil de testar isoladamente: todo teste precisa renderizar a árvore inteira para validar uma conta que não tem nada a ver com renderização. Extrair essa conta para um hook como useCarrinho() separa o que é lógica do que é interface, e divide a responsabilidade do componente de um jeito que vai além de só quebrar JSX em pedaços menores.

Nem toda função precisa virar hook. Se o código não usa useState, useEffect, useContext ou qualquer outro hook por dentro, ele é uma função utilitária comum e deve ficar fora da convenção use. Forçar o prefixo numa função pura só confunde quem lê, porque sinaliza uma dependência do ciclo de vida do React que não existe ali.

As regras dos hooks que um hook customizado precisa seguir

Hook só pode ser chamado no nível superior de uma função React, nunca dentro de um if, de um laço ou de uma função aninhada. E só pode ser chamado de dentro de um componente ou de outro hook, nunca de uma função comum.

Essas duas regras existem porque o React identifica cada useState e cada useEffect pela ordem em que são chamados durante a renderização, não pelo nome da variável. Se um hook roda dentro de uma condicional, essa ordem muda de uma renderização para a outra, e o React associa o estado errado ao hook errado. O prefixo use no nome cumpre uma função prática: permite ao eslint-plugin-react-hooks identificar a função como hook e aplicar essas duas regras automaticamente, apontando erro antes de o bug chegar em produção.

Vale também declarar com clareza o que o hook devolve. Hooks nativos como useState devolvem um array, porque o consumidor sempre renomeia os dois itens. Hooks customizados que devolvem vários valores sem relação entre si costumam ficar mais legíveis como objeto, porque quem consome escolhe só os campos que precisa, na ordem que quiser, como no exemplo do useFetch acima.

Como criar um hook customizado: passo a passo

Criar o hook a partir de um código que já existe e funciona reduz o risco de introduzir um bug durante a extração.

  1. Identifique dois componentes, ou mais, que repetem a mesma combinação de useState e useEffect, ou um trecho de lógica difícil de testar sem renderizar a tela inteira.
  2. Crie uma função nova com nome começando em use, e mova o useState e o useEffect repetidos para dentro dela, trocando o valor fixo pelo parâmetro que varia entre os componentes.
  3. Defina o retorno do hook pensando em quem vai consumir: array quando são poucos valores sempre usados juntos, objeto quando o consumidor normalmente usa só parte deles.
  4. Troque, em cada componente original, o bloco de useState e useEffect pela chamada ao hook novo, e confirme no navegador que o comportamento visível não mudou.
  5. Escreva um teste isolado para o hook, sem renderizar nenhum componente, usando renderHook da @testing-library/react. Esse teste cobre a lógica sozinha, sem depender de layout nem de interação de tela.
  6. Documente, num comentário curto ou numa assinatura tipada, o que cada parâmetro espera e o que cada campo do retorno representa, principalmente se o hook vai ser usado por outra pessoa do time.

Esse mesmo raciocínio de separar lógica de apresentação também orienta como escolher entre useState, Context, Zustand ou Redux: um hook customizado pode envolver qualquer uma dessas fontes de estado por dentro, sem que o componente que o consome precise saber qual delas está ali.

Erros comuns ao criar hooks customizados

O erro mais comum é o hook que cresce demais e passa a resolver problemas sem relação entre si, como buscar dado, validar formulário e controlar um modal, tudo na mesma função. Isso não reduz complexidade, só move ela para um lugar com nome mais bonito. Um hook deve responder a uma pergunta só, do mesmo jeito que um componente bem dividido.

Outro erro é devolver uma função ou um objeto novo a cada renderização sem memoizar, quando esse retorno alimenta o array de dependências de um useEffect em outro lugar. O efeito dispara de novo a cada renderização, porque a referência mudou mesmo que o conteúdo seja igual, e isso costuma virar um laço de atualização difícil de rastrear até a causa raiz.

O terceiro erro é ignorar a limpeza do efeito. Um hook que inicia uma assinatura, um intervalo ou uma requisição precisa devolver uma função de limpeza que desfaz esse efeito quando o componente que o usa desmonta. Sem isso, o hook continua rodando em segundo plano depois que a tela que o chamou já não existe mais, o que aparece em produção como atualização de estado num componente que já saiu da árvore.

Um hook customizado bem feito tira do componente a lógica que não é interface, deixa ela testável sozinha e reaproveitável em qualquer tela que precise do mesmo comportamento. O nome com use é só a convenção que torna isso visível. Se sua base de código tem a mesma lógica de estado copiada em vários componentes, fale com a gente para revisar a arquitetura React do seu projeto.