Componentes, props e estado

A ideia que React, Vue e Angular compartilham: dividir a tela em peças e deixar a interface seguir os dados.

Cerca de 18 min · Revisado em

Ao final, você vai conseguir

  • Dividir uma tela em componentes
  • Passar dados por props e avisar o pai com eventos
  • Decidir onde cada estado deve ficar
  • Reconhecer o mesmo componente em React, Vue e Angular

Na aula de DOM você mudou a página na mão: achar o elemento, trocar o texto, lembrar do contador. Com três botões isso funciona; com uma loja inteira, alguém sempre esquece de atualizar um pedaço. React, Vue e Angular existem para resolver exatamente esse problema, e os três usam a mesma ideia. Aprendendo a ideia, você aprende os três pela metade.

A tela segue os dados

Imagine um catálogo com um botão de favoritar em cada produto, um contador de favoritos no topo e uma lista “Seus favoritos” no rodapé. Um clique precisa mudar três lugares da tela. Veja como isso fica escrito à mão.

Atualizando a tela na mão: cada mudança é um lugar a mais para lembrar

function favoritar(id) {
  favoritos.push(id);
  const botao = document.querySelector('#produto-' + id + ' button');
  botao.textContent = 'Desfavoritar';
  document.querySelector('#contador').textContent = favoritos.length;
  const item = document.createElement('li');
  item.textContent = buscarNome(id);
  document.querySelector('#favoritos').append(item);
}

function desfavoritar(id) {
  // Agora tudo ao contrário: tirar do array, trocar o botão,
  // atualizar o contador, achar e remover o <li> certo...
}

O problema não é a dificuldade de cada linha. É que os dados (o array favoritos) e a tela podem discordar. Basta esquecer o contador em desfavoritar para a página mostrar 3 favoritos quando só existem 2.

Os frameworks trazem essa ideia para o código. Você guarda os dados que mudam em um lugar, o estado, e escreve uma função que diz como a tela fica para aquele estado. É isso que se resume como interface = função(estado).

Estado
Os dados que podem mudar enquanto a página está aberta: o que foi digitado na busca, quais produtos são favoritos, se o menu está aberto.
Renderizar
Calcular como a tela deve ficar a partir do estado atual. Em vez de editar a tela, você muda o estado e pede uma nova renderização.
Framework
Uma base de código pronta que organiza seu projeto e faz o trabalho repetitivo. Aqui, o trabalho repetitivo é manter o DOM igual ao estado.

O time decide mostrar um selo “Favorito” no cartão de cada produto favoritado. Usando a ideia de interface = função(estado), o que você precisa mudar?

  • Só a parte que desenha o cartão: ela passa a mostrar o selo quando o produto está nos favoritos
  • As funções favoritar e desfavoritar, para criar e remover o selo em cada clique
  • Criar um novo array só para guardar quais cartões têm selo

Componentes: peças de LEGO

Um componente é uma peça da interface com HTML, estilo e comportamento juntos, que você pode reaproveitar. Em código, quase sempre é uma função ou classe que recebe dados e devolve um pedaço de tela.

Uma tela de catálogo pode virar: PaginaCatalogo (a tela toda), Cabecalho, BarraDeBusca, ListaDeProdutos e CartaoProduto. O cartão aparece uma vez para cada produto: escreveu uma vez, usa vinte.

A árvore de componentes do catálogo

PaginaCatalogo
├── Cabecalho
├── BarraDeBusca
└── ListaDeProdutos
    ├── CartaoProduto
    ├── CartaoProduto
    └── CartaoProduto

Em qual componente cada pedaço da tela do catálogo deve ficar?

Cabecalho · BarraDeBusca · ListaDeProdutos · CartaoProduto

  • Logo da loja
  • Contador de favoritos no topo
  • Campo de texto para buscar
  • Botão “Limpar busca”
  • Mensagem “Nenhum produto encontrado”
  • Foto, nome e preço de um produto
  • Botão de favoritar de um produto

Props descem, eventos sobem

O cartão precisa saber o nome e o preço do produto, mas quem tem a lista de produtos é a página. Então o componente pai passa os dados para o filho. Esses dados se chamam props (de propriedades), e funcionam como os parâmetros de uma função.

Um componente React escrito em JSX, um HTML que aceita JavaScript entre chaves.

function CartaoProduto({ nome, preco, onFavoritar }) {
  return (
    <article>
      <h3>{nome}</h3>
      <p>R$ {preco}</p>
      <button onClick={onFavoritar}>Favoritar</button>
    </article>
  );
}
  • Nome do componente: Começa com letra maiúscula. É assim que o React diferencia <CartaoProduto /> (seu componente) de <article> (uma tag HTML).
  • Props: O objeto de props, já desmontado em variáveis. O pai decide os valores; o cartão só lê. Mudar uma prop dentro do filho é proibido.
  • Chaves: Entre chaves vai uma expressão JavaScript. Aqui, o valor da prop aparece na tela. Se o pai mandar outro nome, o título muda sozinho.
  • Evento que sobe: O cartão não sabe o que é favoritar. Ele recebe uma função do pai e a chama no clique. É assim que o filho avisa o pai.

O pai usa o cartão como se fosse uma tag e passa as props como atributos

<CartaoProduto
  nome={produto.nome}
  preco={produto.preco}
  onFavoritar={() => alternarFavorito(produto.id)}
/>

Repare na direção: dados descem do pai para o filho em props; avisos sobem do filho para o pai em eventos. O filho nunca mexe direto nos dados do pai. Ele pede, e o pai decide.

Complete o componente para mostrar o nome recebido e avisar o pai no clique.

function BotaoFavorito({ nome, onAlternar }) {
  return (
    <button onClick={____}>
      Favoritar {____}
    </button>
  );
}

Dentro de CartaoProduto, alguém escreve preco = preco * 0.9 para mostrar um desconto. Qual o problema?

  • Props são do pai: o filho não deve alterá-las. O desconto deve ser calculado numa variável nova ou decidido pelo pai
  • Nenhum, props funcionam como variáveis normais
  • O problema é usar número; preço deveria ser texto

Onde cada estado deve morar

Todo estado pertence a algum componente. A regra prática: coloque o estado no componente mais próximo que seja pai de todos que precisam dele. Se só o cartão usa, fica no cartão. Se dois irmãos usam, sobe para o pai deles.

Esse movimento tem nome: elevar o estado (em inglês, lifting state up). O estado sobe, e o pai entrega o valor por props e as funções de mudança como eventos.

A tela tem BarraDeBusca (onde se digita) e ListaDeProdutos (que filtra pelo texto). As duas são filhas de PaginaCatalogo. Onde deve ficar o texto da busca?

  • Em PaginaCatalogo, que passa o texto para os dois filhos
  • Em BarraDeBusca, porque é lá que a pessoa digita
  • Em ListaDeProdutos, porque é ela que usa o texto para filtrar
  • Uma cópia em cada um, sincronizadas a cada digitação

O ciclo de toda interação em um framework

  1. Pessoa → Componente: Clica em Favoritar. O clique chega ao componente pelo evento. Até aqui, nada mudou na tela.
  2. Componente → Componente: Muda o estado. O tratador do evento só faz uma coisa: atualiza os dados, por exemplo acrescentando o id ao estado favoritos.
  3. Componente → Framework: Estado mudou. O framework percebe a mudança. Cada um percebe de um jeito: React pela função setFavoritos, Vue e Angular pelo valor reativo.
  4. Framework → Framework: Recalcula a interface. Ele roda de novo a função de desenho dos componentes afetados e compara o resultado novo com o anterior.
  5. Framework → DOM: Aplica só a diferença. Só o que mudou vai para o DOM: o texto do botão, o número do contador, um item novo na lista.
  6. DOM → Pessoa: Tela atualizada. A pessoa vê a tela coerente com os dados. Você não escreveu nenhum querySelector.

O que precisa ser estado e o que deve ser calculado a partir dele?

Guarde como estado · Calcule na renderização

  • Texto digitado na busca
  • Ids dos produtos favoritados
  • Se o menu do celular está aberto
  • Quantidade de favoritos
  • Produtos que combinam com a busca
  • Se o botão “Limpar busca” aparece
O contador de favoritos fica no Cabecalho e os botões ficam em cada CartaoProduto. Onde mora o estado favoritos?

Em PaginaCatalogo, o pai comum. Ela passa favoritos.length ao cabeçalho, passa a cada cartão se ele é favorito e entrega uma função alternarFavorito que os cartões chamam no clique.

Construa o padrão com JavaScript puro

Antes de instalar qualquer framework, vale ver que a ideia cabe em JavaScript que você já conhece: um objeto estado, uma função render() que desenha a tela a partir dele, e tratadores que mudam o estado e chamam render(). O framework só faz isso de forma mais eficiente.

Favoritos guiados pelo estado

Complete os quatro TODO. Em alternarFavorito, mude só o estado e chame render(). Em render, desenhe o contador e a lista de favoritos a partir de estado.favoritos. Não altere o DOM fora de render.

<header>
  <h1>Lojinha</h1>
  <p>Favoritos: <strong id="contador">0</strong></p>
</header>
<ul id="lista"></ul>
<h2>Seus favoritos</h2>
<ul id="favoritos"></ul>
body { font-family: system-ui, sans-serif; margin: 16px; }
header { display: flex; justify-content: space-between; align-items: center; }
h1 { font-size: 1.25rem; margin: 0; }
h2 { font-size: 1rem; margin-top: 20px; }
ul { padding: 0; list-style: none; }
#lista li { display: flex; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid #ddd; }
button { cursor: pointer; padding: 4px 10px; }
button[aria-pressed="true"] { background: #ffe08a; }
const estado = {
  produtos: [
    { id: 1, nome: 'Caneca', preco: 39 },
    { id: 2, nome: 'Camiseta', preco: 59 },
    { id: 3, nome: 'Boné', preco: 45 },
  ],
  favoritos: [],
};

function alternarFavorito(id) {
  // TODO 1: se o id já está em estado.favoritos, tire; senão, adicione.
  // TODO 2: depois de mudar o estado, chame render().
}

function render() {
  const lista = document.querySelector('#lista');
  lista.replaceChildren();
  for (const produto of estado.produtos) {
    const favorito = estado.favoritos.includes(produto.id);
    const item = document.createElement('li');
    const nome = document.createElement('span');
    nome.textContent = produto.nome + ' (R$ ' + produto.preco + ')';
    const botao = document.createElement('button');
    botao.textContent = favorito ? 'Desfavoritar' : 'Favoritar';
    botao.setAttribute('aria-pressed', String(favorito));
    botao.addEventListener('click', () => alternarFavorito(produto.id));
    item.append(nome, botao);
    lista.append(item);
  }

  // TODO 3: mostre em #contador quantos favoritos existem.
  // TODO 4: preencha #favoritos com um <li> (nome do produto) para cada favorito.
}

render();
  • Clicar em Favoritar troca só aquele botão para Desfavoritar
  • O contador acompanha os favoritos, subindo e descendo
  • A lista Seus favoritos mostra exatamente os produtos favoritados
Por que render() apaga e redesenha a lista inteira a cada clique? Isso não é desperdício?

Com três produtos, não faz diferença. Com mil, seria lento e perderia o foco do teclado no botão clicado. É justamente essa parte que os frameworks otimizam: eles comparam a tela nova com a anterior e mexem só no que mudou. A ideia que você escreveu continua a mesma.

O mesmo componente em React, Vue e Angular

Agora compare o mesmo botão de favoritar nos três frameworks mais usados no Brasil. Ele recebe o nome do produto por prop e guarda se está favoritado em um estado local. Procure as mesmas três peças em cada aba: prop, estado e evento.

Um botão de favoritar com uma prop e um estado

React

import { useState } from 'react';

export function BotaoFavorito({ nome }: { nome: string }) {
  const [favorito, setFavorito] = useState(false);

  return (
    <button aria-pressed={favorito} onClick={() => setFavorito(!favorito)}>
      {favorito ? 'Desfavoritar' : 'Favoritar'} {nome}
    </button>
  );
}

Vue

<script setup lang="ts">
import { ref } from 'vue';

defineProps<{ nome: string }>();
const favorito = ref(false);
</script>

<template>
  <button :aria-pressed="favorito" @click="favorito = !favorito">
    {{ favorito ? 'Desfavoritar' : 'Favoritar' }} {{ nome }}
  </button>
</template>

Angular

import { Component, input, signal } from '@angular/core';

@Component({
  selector: 'app-botao-favorito',
  standalone: true,
  template: `
    <button [attr.aria-pressed]="favorito()" (click)="alternar()">
      {{ favorito() ? 'Desfavoritar' : 'Favoritar' }} {{ nome() }}
    </button>
  `,
})
export class BotaoFavoritoComponent {
  nome = input.required<string>();
  favorito = signal(false);

  alternar() {
    this.favorito.update((valor) => !valor);
  }
}
As mesmas ideias, com nomes diferentes
IdeiaReactVueAngular
Propparâmetro da funçãodefinePropsinput()
EstadouseStaterefsignal
Evento no HTMLonClick={...}@click="..."(click)="..."
Mostrar valor{nome}{{ nome }}{{ nome() }}

O que useState no React, ref no Vue e signal no Angular têm em comum?

  • Guardam um valor e avisam o framework quando ele muda, para a tela ser recalculada
  • Selecionam um elemento da página, como querySelector
  • Recebem dados do componente pai

Biblioteca

React

Componentes são funções JavaScript com JSX. Muito presente em vagas e com um ecossistema enorme, mas você escolhe rotas, formulários e outras peças à parte.

Framework progressivo

Vue

HTML, script e estilo no mesmo arquivo .vue, com uma sintaxe de template próxima do HTML. Costuma ser considerado o mais suave para começar.

Framework completo

Angular

Já vem com rotas, formulários, requisições e injeção de dependência, sempre em TypeScript. Comum em empresas grandes, bancos e sistemas corporativos.

Fechamento

  • Em vez de editar a tela na mão, você guarda os dados no estado e descreve a tela a partir dele: interface = função(estado).
  • Um componente é uma peça reaproveitável de interface; uma tela é uma árvore de componentes.
  • Props levam dados do pai para o filho e não são alteradas pelo filho; eventos levam avisos do filho para o pai.
  • O estado mora no componente mais próximo que é pai de todos que o usam, e o que dá para calcular não vira estado.
  • React (useState), Vue (ref) e Angular (signal) aplicam a mesma ideia com sintaxes diferentes.

Recrie uma tela do catálogo com componentes

Escolha um framework, crie um projeto com Vite (ou com o Angular CLI) e reconstrua a tela do catálogo desta aula. O objetivo não é ficar bonito, é ficar bem dividido e saber explicar cada decisão.

  1. Desenhe no papel a árvore de componentes antes de escrever código
  2. Crie CartaoProduto recebendo nome, preço e se é favorito por props
  3. Implemente busca e favoritos, com o estado no pai comum dos componentes que o usam
  4. Mostre a quantidade de favoritos calculada, sem guardá-la como estado separado
  5. Escreva no README onde cada estado mora e por quê

Referências

Cursos relacionados