Estado e eventos

Faça a tela reagir a cliques e digitação com useState, atualizações imutáveis, formulários controlados e estado derivado.

Cerca de 16 min · Revisado em

Ao final, você vai conseguir

  • Criar estado com useState e atualizá-lo em eventos como onClick e onChange
  • Usar a atualização funcional quando o novo valor depende do anterior
  • Atualizar arrays e objetos no estado sem modificar o original
  • Construir um formulário controlado que adiciona e remove itens
  • Elevar o estado para o pai comum e calcular valores derivados em vez de duplicá-los

Curtir uma foto, escolher o tamanho da pizza, digitar o CEP e ver o endereço aparecer: tudo isso é uma tela reagindo ao que a pessoa faz. Na aula anterior seus componentes só mostravam dados fixos. Agora eles vão lembrar de coisas e mudar quando alguém clica ou digita, que é o que faz uma interface parecer viva.

Por que uma variável comum não basta

Primeira tentativa natural de fazer um contador: uma variável let e um botão que soma 1. O console mostra o número subindo, mas a tela continua no zero. Rode o exercício abaixo e veja com seus olhos antes de consertar.

O estado resolve os dois problemas. É um valor que o React guarda fora da sua função, entre uma chamada e outra. E, quando você pede para trocá-lo, o React chama o componente de novo, tirando uma foto nova. Isso se chama re-renderizar.

A linha que cria um estado.

const [copos, setCopos] = useState(0);
  • Valor atual: O valor desta renderização. Trate como somente leitura: escrever copos = 5 não avisa ninguém.
  • Função de troca: O único jeito certo de mudar o estado. Ela guarda o valor novo e agenda uma nova renderização. Por convenção, o nome é set + o nome do valor.
  • Hook: Funções que começam com use são hooks: dão ao componente recursos do React. Chame sempre no topo do componente, nunca dentro de if, laço ou função interna.
  • Valor inicial: Usado só na primeira renderização. Depois, o React devolve o valor guardado.

Contador de copos de água

Clique em +1 copo e repare: o console mostra o número subindo, a tela não. Troque a variável let por useState e chame setCopos no clique. Depois crie um botão Zerar que volta o total para 0.

<div id="root"></div>
body { font-family: system-ui, sans-serif; margin: 16px; }
button { margin-right: 8px; padding: 6px 14px; cursor: pointer; }
#total { font-size: 1.5rem; }
const { useState } = React;

function Contador() {
  let copos = 0;

  function somar() {
    copos = copos + 1;
    console.log('copos agora vale', copos);
  }

  return (
    <div>
      <p>Copos de água hoje: <strong id="total">{copos}</strong></p>
      <button onClick={somar}>+1 copo</button>
    </div>
  );
}

ReactDOM.createRoot(document.getElementById('root')).render(<Contador />);
  • Três cliques em +1 copo fazem a tela mostrar 3 a mais
  • O botão Zerar volta o total para 0

Eventos: entregue a função, não o resultado

Na aula de DOM você usou addEventListener. No React, o evento vira um atributo em camelCase direto no JSX: onClick, onChange, onSubmit, onKeyDown. O valor é uma função que o React vai chamar quando o evento acontecer.

Três jeitos corretos de tratar um clique

// 1. Função declarada no componente
function curtir() { setCurtidas(curtidas + 1); }
<button onClick={curtir}>Curtir</button>

// 2. Função anônima, ótima para passar argumentos
<button onClick={() => remover(produto.id)}>Remover</button>

// 3. Usando o objeto do evento
<input onChange={(evento) => setBusca(evento.target.value)} />

A tela trava com o erro “Too many re-renders” assim que abre. Qual destas linhas causa isso?

  • <button onClick={setAberto(true)}>Abrir</button>
  • <button onClick={() => setAberto(true)}>Abrir</button>
  • <button onClick={abrir}>Abrir</button>

Complete para que o clique remova o item certo e o campo atualize o estado nome a cada tecla.

<button ____={() => remover(item.id)}>Remover</button>

<input
  value={nome}
  onChange={(evento) => setNome(evento.____)}
/>

O estado é uma foto: atualização funcional

Uma surpresa comum: chamar setPontos(pontos + 1) três vezes seguidas soma só 1. O motivo é a foto. Durante todo aquele clique, pontos vale o número da foto atual, e a função de troca não muda a variável na hora: ela agenda o valor novo para a próxima renderização.

Um clique em “+3” com pontos valendo 0.

function somarTres() {
  setPontos(pontos + 1);
  setPontos(pontos + 1);
  setPontos(pontos + 1);
}
// próxima renderização
  1. Linha 1: O clique chama somarTres. Nesta foto, pontos vale 0, e vai valer 0 até a função terminar.
  2. Linha 2: pontos + 1 é 0 + 1. O React anota: o próximo valor é 1.
  3. Linha 3: pontos ainda é 0 nesta foto. De novo 0 + 1: o React anota 1 outra vez.
  4. Linha 4: Mesma conta, mesmo resultado. Três chamadas, todas pedindo 1.
  5. Linha 6: O React renderiza de novo com o valor agendado. A tela mostra 1, não 3. Saída: Tela: 1 ponto

Quando o valor novo depende do anterior, passe uma função para o set: setPontos((anterior) => anterior + 1). O React guarda essas funções numa fila e entrega a cada uma o resultado da anterior. Três chamadas assim somam 3.

Reescreva a soma com atualização funcional, para que as três chamadas somem 3.

function somarTres() {
  setPontos((____) => ____);
  setPontos((anterior) => anterior + 1);
  setPontos((anterior) => anterior + 1);
}
Logo depois de setPontos(10), você escreve console.log(pontos). O que aparece, se pontos valia 0?

Aparece 0. A troca só vale para a próxima renderização; nesta foto, pontos continua 0. Se você precisa do valor novo ainda na mesma função, guarde-o numa variável: const novo = 10; setPontos(novo); console.log(novo);.

Arrays e objetos: sempre uma cópia nova

É exatamente assim: o React compara o estado antigo com o novo usando Object.is, que diz se é o mesmo objeto, não se o conteúdo é igual. Por isso itens.push(novo) seguido de setItens(itens) não atualiza a tela: é o mesmo array. Atualizar sem modificar o original se chama atualização imutável.

As receitas imutáveis do dia a dia
QueroEvite (modifica o original)Use (cria um novo)
Adicionar no fimitens.push(x)[...itens, x]
Removeritens.splice(i, 1)itens.filter((i) => i.id !== id)
Alterar um itemitens[0].feito = trueitens.map((i) => i.id === id ? { ...i, feito: true } : i)
Ordenaritens.sort()[...itens].sort()
Mudar campo de objetoperfil.cidade = "Recife"{ ...perfil, cidade: "Recife" }

Qual destas atualizações o React percebe, e qual passa despercebida?

O React percebe · Passa despercebida

  • setItens([...itens, novo])
  • setItens(itens.filter((i) => i.id !== 3))
  • setPerfil({ ...perfil, nome: "Ana" })
  • setItens([...itens].reverse())
  • itens.push(novo); setItens(itens)
  • perfil.nome = "Ana"; setPerfil(perfil)
  • itens.sort(); setItens(itens)

Formulários controlados

Num campo de texto comum, quem guarda o que foi digitado é o navegador. No React, o mais comum é o estado guardar, e o campo apenas mostrar. Esse é o input controlado: o React é a fonte da verdade, e o que está na tela é sempre igual ao estado.

Um formulário controlado, do campo ao envio.

const [cep, setCep] = useState('');

function enviar(evento) {
  evento.preventDefault();
  buscarEndereco(cep);
}

<form onSubmit={enviar}>
  <label htmlFor="cep">CEP</label>
  <input
    id="cep"
    value={cep}
    onChange={(evento) => setCep(evento.target.value)}
  />
  <button type="submit">Buscar</button>
</form>
  • Sem recarregar: Por padrão, enviar um formulário recarrega a página. Numa aplicação React, você impede isso e trata os dados no JavaScript.
  • onSubmit no form: Trate o envio no form, não no clique do botão. Assim, apertar Enter no campo também envia, e quem usa teclado agradece.
  • value vem do estado: O campo mostra o que está no estado. Se você trocar o estado por código (por exemplo, limpar depois de enviar), o campo acompanha.
  • onChange atualiza o estado: A cada tecla o estado muda e o componente renderiza de novo. Sem o onChange, o campo fica travado: o React sempre volta para o valor do estado.

Lista de compras

Transforme o campo em controlado (crie o estado texto). No envio, se o texto sem espaços nas pontas não estiver vazio, crie um array novo com o item no fim e limpe o campo. Faça o Remover criar um array novo sem aquele item. Use Date.now() como id dos itens novos.

<div id="root"></div>
body { font-family: system-ui, sans-serif; margin: 16px; }
form { display: flex; gap: 8px; align-items: center; }
input { padding: 6px; }
ul { padding: 0; list-style: none; }
li { display: flex; justify-content: space-between; max-width: 280px; padding: 6px 0; border-bottom: 1px solid #e5e7eb; }
const { useState } = React;

function ListaDeCompras() {
  const [itens, setItens] = useState([
    { id: 1, nome: 'Feijão' },
    { id: 2, nome: 'Café' },
  ]);
  // TODO 1: crie o estado do texto digitado

  function adicionar(evento) {
    evento.preventDefault();
    // TODO 2: ignore texto vazio, adicione com um array novo e limpe o campo
  }

  function remover(id) {
    // TODO 3: crie um array novo sem o item desse id
  }

  return (
    <div>
      <form onSubmit={adicionar}>
        <label htmlFor="item">Item</label>
        <input id="item" />
        <button type="submit">Adicionar</button>
      </form>
      <ul id="itens">
        {itens.map((item) => (
          <li key={item.id}>
            {item.nome}
            <button type="button" onClick={() => remover(item.id)}>Remover</button>
          </li>
        ))}
      </ul>
    </div>
  );
}

ReactDOM.createRoot(document.getElementById('root')).render(<ListaDeCompras />);
  • Digitar Arroz e clicar em Adicionar põe o item na lista e limpa o campo
  • Texto vazio ou só com espaços é ignorado, mas Leite entra
  • Remover tira só o item clicado

Elevar o estado e calcular o resto

Na aula Componentes e estado você viu duas regras: o estado mora no pai comum de quem precisa dele, e o que dá para calcular não vira estado. Agora é hora de aplicar as duas em React, onde elas aparecem em quase todo componente.

Elevar o estado: o pai guarda, o filho recebe valor e função por props

function Loja() {
  const [busca, setBusca] = useState('');
  const visiveis = produtos.filter((p) =>
    p.nome.toLowerCase().includes(busca.toLowerCase())
  ); // calculado a cada renderização, não é estado

  return (
    <>
      <BarraDeBusca valor={busca} aoMudar={setBusca} />
      <ListaDeProdutos produtos={visiveis} />
    </>
  );
}

function BarraDeBusca({ valor, aoMudar }) {
  return <input value={valor} onChange={(e) => aoMudar(e.target.value)} />;
}

Busca e favoritos

Este código tem dois defeitos. A busca mora dentro de BarraDeBusca, então a lista não consegue filtrar: eleve o estado para Loja e passe valor e função por props. E o contador usa um estado espelho, quantidade, que não diminui ao desfavoritar: apague esse estado e mostre favoritos.length. A busca não deve diferenciar maiúsculas de minúsculas.

<div id="root"></div>
body { font-family: system-ui, sans-serif; margin: 16px; }
input { padding: 6px; width: 220px; }
ul { padding: 0; list-style: none; }
li { display: flex; justify-content: space-between; max-width: 300px; padding: 6px 0; border-bottom: 1px solid #e5e7eb; }
const { useState } = React;

const produtos = [
  { id: 1, nome: 'Caneca' },
  { id: 2, nome: 'Camiseta' },
  { id: 3, nome: 'Boné' },
  { id: 4, nome: 'Caderno' },
];

function BarraDeBusca() {
  const [busca, setBusca] = useState('');
  return (
    <input
      aria-label="Buscar produto"
      placeholder="Buscar produto"
      value={busca}
      onChange={(evento) => setBusca(evento.target.value)}
    />
  );
}

function Loja() {
  const [favoritos, setFavoritos] = useState([]);
  const [quantidade, setQuantidade] = useState(0);

  function alternar(id) {
    if (favoritos.includes(id)) {
      setFavoritos(favoritos.filter((f) => f !== id));
    } else {
      setFavoritos([...favoritos, id]);
      setQuantidade(quantidade + 1);
    }
  }

  return (
    <div>
      <p>Favoritos: <strong id="quantidade">{quantidade}</strong></p>
      <BarraDeBusca />
      <ul id="produtos">
        {produtos.map((produto) => (
          <li key={produto.id}>
            {produto.nome}
            <button onClick={() => alternar(produto.id)}>
              {favoritos.includes(produto.id) ? 'Desfavoritar' : 'Favoritar'}
            </button>
          </li>
        ))}
      </ul>
    </div>
  );
}

ReactDOM.createRoot(document.getElementById('root')).render(<Loja />);
  • Digitar ca na busca deixa só Caneca, Camiseta e Caderno
  • Favoritar e desfavoritar o mesmo produto volta o contador para 0
  • Um favorito continua marcado enquanto você busca

Um formulário tem os estados nome e sobrenome. Onde deve ficar o nome completo mostrado no topo?

  • Numa variável calculada na renderização: const completo = nome + " " + sobrenome
  • Num terceiro estado, completo, atualizado em cada onChange
  • Num estado no componente pai, só para garantir

Fechamento

  • Variáveis comuns não sobrevivem entre renderizações nem avisam o React; useState guarda o valor e, ao trocar, re-renderiza o componente.
  • Eventos recebem uma função, como onClick={() => remover(id)}; com parênteses direto, ela rodaria durante a renderização.
  • Cada renderização é uma foto: quando o novo valor depende do anterior, use a atualização funcional setX((anterior) => ...).
  • Arrays e objetos no estado são trocados por cópias novas, com spread, map e filter, nunca modificados no lugar.
  • Inputs controlados usam value e onChange; o estado sobe para o pai comum e o que dá para calcular não vira estado.

Busca e favoritos de verdade

No catálogo que você montou na aula anterior, adicione interação. A meta é ter o mínimo de estado possível e saber explicar cada atualização.

  1. Adicione um campo de busca controlado no componente pai da lista
  2. Calcule a lista filtrada na renderização, sem criar um estado para ela
  3. Implemente favoritar e desfavoritar com arrays novos e mostre a quantidade com favoritos.length
  4. Crie um formulário para cadastrar produto que funcione com Enter e ignore campos vazios
  5. Escreva num comentário no topo do componente quais estados existem e por que cada um é necessário

Referências

Cursos relacionados