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 map e uma key estável
  • Mostrar ou esconder elementos com &&, ternário e if antes do return

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 h1 que 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 div extra, 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, input e br, terminam em />.
  • className: class é uma palavra reservada do JavaScript, então no JSX o atributo se chama className. Pelo mesmo motivo, o for do label vira htmlFor.
  • Expressão entre chaves: Entre chaves vai qualquer expressão JavaScript: variável, conta, chamada de função, ternário. Comandos como if e for não cabem aqui, porque não produzem um valor.
  • Estilo como objeto: O atributo style recebe 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, como fontSize.
  • 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 Saudacao que 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 Modal cuida da moldura e recebe o conteúdo em children
  • 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 />);
  1. Linha 11: Tudo começa aqui: o React recebe <App /> e chama a função App.
  2. Linha 8: App cria o array de dados. Ele existe só durante esta chamada.
  3. Linha 9: App devolve a planta: um ul com um Item dentro. O Item ainda não foi chamado, é só uma descrição com a key 1.
  4. Linha 5: O React chama Item com as props que App escreveu. A key não chega como prop: ela é do React.
  5. Linha 2: Dentro do Item existe um Preco, então o React chama Preco com valor igual a 5.
  6. 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.

Três formas de renderização condicional
QuandoFormaExemplo
Mostrar algo ou nadacondição && <JSX />{novo && <span>Novo</span>}
Escolher entre duas coisasternário ? :{logado ? <Sair /> : <Entrar />}
Um caso muda a tela todaif antes do returnif (!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 key no 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 map sobre o array de produtos, com key

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, style como 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 uma key ú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 um if antes do return.

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.

  1. Desenhe a tela e a árvore de componentes antes de abrir o editor
  2. Guarde os produtos num array de objetos com id, nome, preço e estoque
  3. Crie CartaoProduto recebendo os dados por props, sem alterar nenhuma delas
  4. Renderize a lista com map e key={produto.id} e confira que o console não mostra avisos
  5. Mostre um selo quando o estoque for zero e uma mensagem quando a lista estiver vazia
  6. Use um componente de moldura com children em pelo menos dois lugares

Referências

Cursos relacionados