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
useStatee atualizá-lo em eventos comoonClickeonChange - 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 = 5nã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
usesão hooks: dão ao componente recursos do React. Chame sempre no topo do componente, nunca dentro deif, 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- Linha 1: O clique chama
somarTres. Nesta foto,pontosvale 0, e vai valer 0 até a função terminar. - Linha 2:
pontos + 1é0 + 1. O React anota: o próximo valor é 1. - Linha 3:
pontosainda é 0 nesta foto. De novo0 + 1: o React anota 1 outra vez. - Linha 4: Mesma conta, mesmo resultado. Três chamadas, todas pedindo 1.
- 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.
| Quero | Evite (modifica o original) | Use (cria um novo) |
|---|---|---|
| Adicionar no fim | itens.push(x) | [...itens, x] |
| Remover | itens.splice(i, 1) | itens.filter((i) => i.id !== id) |
| Alterar um item | itens[0].feito = true | itens.map((i) => i.id === id ? { ...i, feito: true } : i) |
| Ordenar | itens.sort() | [...itens].sort() |
| Mudar campo de objeto | perfil.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, apertarEnterno 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 cadaonChange - Num estado no componente pai, só para garantir
Fechamento
- Variáveis comuns não sobrevivem entre renderizações nem avisam o React;
useStateguarda 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,
mapefilter, nunca modificados no lugar. - Inputs controlados usam
valueeonChange; 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.
- Adicione um campo de busca controlado no componente pai da lista
- Calcule a lista filtrada na renderização, sem criar um estado para ela
- Implemente favoritar e desfavoritar com arrays novos e mostre a quantidade com
favoritos.length - Crie um formulário para cadastrar produto que funcione com
Entere ignore campos vazios - Escreva num comentário no topo do componente quais estados existem e por que cada um é necessário