JSX, componentes e props
Escreva seus primeiros componentes React: as regras do JSX, props, children, listas com key e renderização condicional.
Cerca de 16 min · Revisado em
Ao final, você vai conseguir
- Explicar por que o React descreve a tela a partir dos dados em vez de editar o DOM
- Escrever JSX válido, com uma raiz,
className, tags fechadas e expressões entre chaves - Criar componentes que recebem props e children
- Renderizar listas com
mape umakeyestável - Mostrar ou esconder elementos com
&&, ternário eifantes doreturn
Abra o iFood, o app do banco ou o Instagram no navegador: boa parte dessas telas é feita com React. Ele é a biblioteca de interface mais pedida em vagas de frontend no Brasil, e também é o lado cliente da maioria das stacks fullstack com Node.js. Nesta aula você escreve seus primeiros componentes de verdade e entende o que acontece quando o React desenha a tela.
Descrever a tela em vez de editá-la
Na aula Componentes e estado você viu a ideia central: a tela é calculada a partir dos dados, interface = função(estado). Lá, você mesmo escreveu a função render() que apagava e redesenhava a lista. O React é uma biblioteca que faz esse trabalho por você, e de um jeito eficiente.
Essa planta é escrita em JSX: um jeito de escrever, dentro do JavaScript, algo que parece HTML. O navegador não entende JSX. Antes de rodar, uma ferramenta (o Vite, no seu projeto, ou o Babel, nos exercícios desta aula) traduz cada tag para uma chamada de função comum.
O mesmo trecho escrito em JSX e no JavaScript que ele vira
Você escreve (JSX)
const titulo = (
<h1 className="titulo">
Olá, {nome}!
</h1>
);O navegador recebe
const titulo = React.createElement(
'h1',
{ className: 'titulo' },
'Olá, ',
nome,
'!'
);Repare: React.createElement não cria nada na página. Ele devolve um objeto simples que descreve o elemento, como uma linha da planta. Só depois o React compara esses objetos com a tela atual e aplica as diferenças.
O que é, de fato, o resultado de <h1>Olá</h1> dentro de um arquivo React?
- Um objeto JavaScript que descreve um
h1; o React decide depois se e como colocá-lo na página - Um elemento
h1que já foi inserido na página - Um texto em HTML, como se fosse uma string
As regras do JSX
JSX é parecido com HTML, mas tem regras próprias, porque no fim é JavaScript. São poucas, e o editor ou o console avisam quando você quebra uma delas. Explore cada parte destacada.
Um componente com as principais regras do JSX.
function CartaoPerfil() {
const nome = 'Joana';
return (
<>
<img src="foto.jpg" alt="Foto de Joana" />
<h2 className="nome">{nome.toUpperCase()}</h2>
<p style={{ color: 'gray' }}>Desenvolvedora</p>
</>
);
}- Uma raiz só: Um componente devolve um elemento. Para juntar vários sem criar uma
divextra, use o fragmento<>...</>. Duas tags soltas lado a lado dão erro. - Tags fechadas: Toda tag precisa ser fechada. Tags que no HTML não têm fechamento, como
img,inputebr, terminam em/>. - className:
classé uma palavra reservada do JavaScript, então no JSX o atributo se chamaclassName. Pelo mesmo motivo, ofordolabelvirahtmlFor. - Expressão entre chaves: Entre chaves vai qualquer expressão JavaScript: variável, conta, chamada de função, ternário. Comandos como
ifefornão cabem aqui, porque não produzem um valor. - Estilo como objeto: O atributo
stylerecebe um objeto, por isso as chaves duplas: as de fora abrem a expressão, as de dentro são o objeto. As propriedades usam camelCase, comofontSize. - Fecha o fragmento: O fragmento não aparece no HTML final. Ele só agrupa.
Qual destes trechos de JSX funciona e qual quebra?
Funciona · Quebra ou não faz o esperado
<input type="text" /><p>Total: {2 + 3}</p><label htmlFor="email">E-mail</label><><h1>Oi</h1><p>Tudo bem?</p></><br><p>{if (logado) { "Oi" }}</p><div style="color: red">Erro</div><h1>Oi</h1><p>Tudo bem?</p>como retorno
Complete o JSX para que ele funcione: atributo de classe, valor do nome e fechamento da imagem.
<div ____="avatar">
<img src={foto} alt="" ____
<span>{____}</span>
</div>Componentes são funções; props são os argumentos
No React, um componente é uma função JavaScript que devolve JSX. O nome começa com letra maiúscula, e é assim que o React diferencia <Saudacao /> (seu componente) de <section> (uma tag do HTML).
Os atributos que você escreve ao usar o componente chegam juntos num objeto, as props. É comum já desmontar esse objeto nos parâmetros, com a desestruturação que você viu na aula de arrays e objetos.
Cada tipo de valor tem um jeito de ser passado
function Produto({ nome, preco, emPromocao, aoComprar }) {
return (
<article>
<h3>{nome}</h3>
<p>R$ {preco}</p>
{emPromocao ? <strong>Promoção</strong> : null}
<button onClick={aoComprar}>Comprar</button>
</article>
);
}
<Produto
nome="Caneca" // texto: entre aspas
preco={39.9} // número: entre chaves
emPromocao={true} // booleano: entre chaves
aoComprar={() => alert('Comprou!')} // função: entre chaves
/>Alguém escreve <Saudacao nome={Ana} /> e a tela fica em branco, com um erro no console. Qual é o problema?
- Entre chaves,
Anaé lido como o nome de uma variável que não existe; texto fixo vai entre aspas:nome="Ana" - Props só aceitam números entre chaves
- O nome da prop deveria começar com letra maiúscula
Seu primeiro componente
Crie o componente Saudacao. Ele recebe a prop nome e devolve <p className="saudacao">Olá, {nome}!</p>. Depois use <Saudacao /> duas vezes dentro de App: uma para Ana e outra para Bruno.
<div id="root"></div>body { font-family: system-ui, sans-serif; margin: 16px; }
.saudacao { padding: 8px 12px; border-left: 4px solid #2563eb; background: #eff6ff; }// Crie aqui o componente Saudacao.
// Ele recebe a prop nome e devolve um <p className="saudacao">.
function App() {
return (
<main>
<h1>Boas-vindas à turma</h1>
{/* Use <Saudacao /> duas vezes aqui, com nomes diferentes */}
</main>
);
}
ReactDOM.createRoot(document.getElementById('root')).render(<App />);- Existe um componente
Saudacaoque mostra o nome recebido na prop - A página mostra Olá, Ana! e Olá, Bruno! em parágrafos com a classe
saudacao
Children: componentes que embrulham outros
Tudo o que fica entre <Cartao> e </Cartao> chega ao componente numa prop especial chamada children (filhos). Assim, o mesmo Cartao serve para um aviso, um formulário ou uma foto, sem uma prop para cada caso.
Um componente de moldura e dois usos diferentes
Cartao.jsx
function Cartao({ titulo, children }) {
return (
<section className="cartao">
<h2>{titulo}</h2>
<div className="cartao-corpo">{children}</div>
</section>
);
}Usando
<Cartao titulo="Aviso">
<p>A padaria fecha às 20h no feriado.</p>
</Cartao>
<Cartao titulo="Seu pedido">
<ul>
<li>2 pães de queijo</li>
<li>1 café</li>
</ul>
<button>Pagar com Pix</button>
</Cartao>Esse jeito de montar telas encaixando componentes se chama composição. É a forma principal de reaproveitar código no React: em vez de criar um componente “especial” que herda de outro, você combina peças pequenas.
Você tem <Modal> usado com um formulário de login numa tela e com uma foto ampliada em outra. Qual desenho de componente é mais fácil de manter?
// Opção A
<Modal tipo="login" />
<Modal tipo="foto" url="praia.jpg" />
// Opção B
<Modal><FormLogin /></Modal>
<Modal><img src="praia.jpg" alt="Praia" /></Modal>- A opção B: o
Modalcuida da moldura e recebe o conteúdo emchildren - A opção A: tudo fica concentrado num lugar só
- Tanto faz, as duas geram exatamente o mesmo esforço de manutenção
Listas com map e key
Dados de verdade vêm em listas: produtos, mensagens, pedidos. Para transformar um array de dados num array de elementos, use o map que você conhece da aula de arrays. O React sabe desenhar um array de JSX.
De um array de objetos para uma lista na tela
const linhas = [
{ id: '8700', nome: 'Terminal Pinheiros' },
{ id: '875A', nome: 'Perdizes' },
{ id: '702U', nome: 'Butantã' },
];
function Linhas() {
return (
<ul>
{linhas.map((linha) => (
<li key={linha.id}>{linha.id} — {linha.nome}</li>
))}
</ul>
);
}A key precisa ser única entre os irmãos e estável: o mesmo item deve ter sempre a mesma key. O melhor candidato é o id que vem dos dados. Sem key, o React avisa no console: Each child in a list should have a unique "key" prop.
Por que usar a posição no array (key={indice}) é perigoso quando a lista pode mudar de ordem ou ganhar itens no começo?
Porque a posição muda e o item não. Se um item novo entra no topo, o antigo item 0 vira 1, e o React acha que o “item 0” só mudou de texto. Se cada linha tiver um campo de texto ou uma caixa marcada, o que você digitou fica grudado na linha errada. Com um id estável, isso não acontece.
Siga o React desenhando uma lista de um item só.
function Preco({ valor }) {
return <span>R$ {valor}</span>;
}
function Item({ nome, preco }) {
return <li>{nome} <Preco valor={preco} /></li>;
}
function App() {
const itens = [{ id: 1, nome: 'Café', preco: 5 }];
return <ul>{itens.map((i) => <Item key={i.id} nome={i.nome} preco={i.preco} />)}</ul>;
}
root.render(<App />);- Linha 11: Tudo começa aqui: o React recebe
<App />e chama a funçãoApp. - Linha 8:
Appcria o array de dados. Ele existe só durante esta chamada. - Linha 9:
Appdevolve a planta: umulcom umItemdentro. OItemainda não foi chamado, é só uma descrição com a key 1. - Linha 5: O React chama
Itemcom as props queAppescreveu. A key não chega como prop: ela é do React. - Linha 2: Dentro do
Itemexiste umPreco, então o React chamaPrecocomvalorigual a 5. - Linha 11: Sem mais componentes para chamar, o React tem a planta completa só com tags de HTML e coloca no DOM. Saída: <ul><li>Café <span>R$ 5</span></li></ul>
Qual destas é a melhor key para uma lista de pedidos vinda da API?
key={pedido.id}key={indice}key={Math.random()}key={pedido.cliente}
Mostrar ou esconder
Muitas partes da tela só aparecem em certas condições: o selo de “Esgotado”, a mensagem de lista vazia, o botão de sair para quem fez login. Como if não cabe dentro do JSX, você usa expressões.
| Quando | Forma | Exemplo |
|---|---|---|
| Mostrar algo ou nada | condição && <JSX /> | {novo && <span>Novo</span>} |
| Escolher entre duas coisas | ternário ? : | {logado ? <Sair /> : <Entrar />} |
| Um caso muda a tela toda | if antes do return | if (!itens.length) return <p>Vazio</p>; |
O carrinho está vazio (itens.length é 0). O que aparece na tela com o código abaixo?
<p>{itens.length && `Você tem ${itens.length} itens`}</p>- O número
0 - Nada: o parágrafo fica vazio
- O texto “Você tem 0 itens”
Cardápio da padaria
Complete Cardapio. Use map para criar um <li> por produto, com key={produto.id}, o nome e o preço. Quando o estoque for zero, mostre dentro do <li> um <span className="esgotado">Esgotado</span>. Se a lista vier vazia, o componente deve mostrar <p>Nada no cardápio hoje.</p>.
<div id="root"></div>body { font-family: system-ui, sans-serif; margin: 16px; }
ul { list-style: none; padding: 0; }
li { padding: 8px 0; border-bottom: 1px solid #e5e7eb; }
.esgotado { margin-left: 8px; padding: 2px 8px; border-radius: 99px; background: #fee2e2; color: #991b1b; font-size: 0.8rem; }const produtos = [
{ id: 'p1', nome: 'Pão francês', preco: 0.8, estoque: 120 },
{ id: 'p2', nome: 'Pão de queijo', preco: 4.5, estoque: 0 },
{ id: 'p3', nome: 'Coxinha', preco: 7, estoque: 15 },
{ id: 'p4', nome: 'Bolo de fubá', preco: 25, estoque: 0 },
];
function formatarPreco(valor) {
return valor.toFixed(2).replace('.', ',');
}
function Cardapio({ produtos }) {
// TODO 1: se produtos estiver vazio, devolva <p>Nada no cardápio hoje.</p>
return (
<ul id="cardapio">
{/* TODO 2: um <li key={...}> por produto, com nome e R$ preço */}
{/* TODO 3: selo Esgotado quando o estoque for zero */}
</ul>
);
}
function App() {
return (
<main>
<h1>Padaria Pão Quente</h1>
<Cardapio produtos={produtos} />
</main>
);
}
ReactDOM.createRoot(document.getElementById('root')).render(<App />);- Aparece um item para cada produto, sem aviso de
keyno console - Só os produtos com estoque zero mostram o selo Esgotado
- Com a lista vazia, aparece Nada no cardápio hoje
Você vai transformar uma tela de catálogo em componentes React. Coloque os passos na ordem que mais ajuda.
- Desenhar a tela no papel e circular os pedaços que se repetem
- Dar nome aos componentes e montar a árvore de quem fica dentro de quem
- Decidir quais dados cada componente recebe por props
- Escrever o componente da peça repetida, como
CartaoProduto, com dados fixos - Trocar os dados fixos por um
mapsobre o array de produtos, comkey
Fechamento
- O React recebe uma descrição da tela, escrita em JSX, e atualiza o DOM só onde há diferença.
- JSX tem regras próprias: uma raiz,
className, tags fechadas,stylecomo objeto e expressões entre chaves. - Componentes são funções com nome em maiúscula; props são o objeto de argumentos, e
childrené o conteúdo entre as tags. - Listas vêm de
map, e cada item precisa de umakeyúnica e estável, de preferência o id dos dados. - Para mostrar ou esconder, use
&&com uma condição booleana, o ternário ou umifantes doreturn.
Monte um catálogo com componentes
Crie um projeto React com Vite e divida a tela de um catálogo que você conhece (uma padaria, uma loja de roupas, uma livraria) em componentes que recebem dados por props.
- Desenhe a tela e a árvore de componentes antes de abrir o editor
- Guarde os produtos num array de objetos com
id, nome, preço e estoque - Crie
CartaoProdutorecebendo os dados por props, sem alterar nenhuma delas - Renderize a lista com
mapekey={produto.id}e confira que o console não mostra avisos - Mostre um selo quando o estoque for zero e uma mensagem quando a lista estiver vazia
- Use um componente de moldura com
childrenem pelo menos dois lugares