Introdução ao React
Aprenda os fundamentos do React para construir interfaces de usuário dinâmicas e interativas. Descubra como criar componentes, gerenciar estados e passar dados entre eles. Comece sua jornada no desenvolvimento web com React.
Atividade Prática
🧪 Atividade Prática Detalhada – Fundamentos do React
🎯 Objetivo Geral
Ensinar os alunos a criarem sua primeira aplicação React funcional, com uso de componentes, props e estados (useState), consolidando os conceitos fundamentais de desenvolvimento com React.
🛠️ Parte 1 – Preparação do Ambiente (30 min)
✔️ Requisitos:
  • Editor de código (VS Code recomendado)
  • Terminal ou prompt de comando
📥 1. Instale o React (via Vite para mais leveza)
Abra o terminal e execute:
npm create vite@latest meu-catalogo-react --template react
Depois:
cd meu-catalogo-react npm install npm run dev
O navegador abrirá em http://localhost:5173
🧱 Parte 2 – Criando a Aplicação: "Mini Catálogo de Produtos" (2h)
📁 Estrutura Inicial:
src/ ├── App.jsx ├── components/ │ └── Produto.jsx
🧩 Passo 1: Criar o componente Produto.jsx
// src/components/Produto.jsx function Produto({ nome, preco }) { return ( <div style={{ border: "1px solid #ccc", padding: "10px", marginBottom: "10px" }}> <h3>{nome}</h3> <p>Preço: R$ {preco}</p> </div> ); } export default Produto;
🧩 Passo 2: Atualizar o App.jsx
import { useState } from 'react'; import Produto from './components/Produto'; function App() { const [produtos, setProdutos] = useState([ { id: 1, nome: "Notebook", preco: 3500 }, { id: 2, nome: "Mouse", preco: 150 } ]); const [novoNome, setNovoNome] = useState(''); const [novoPreco, setNovoPreco] = useState(''); function adicionarProduto() { const novo = { id: produtos.length + 1, nome: novoNome, preco: parseFloat(novoPreco) }; setProdutos([...produtos, novo]); setNovoNome(''); setNovoPreco(''); } return ( <div style={{ padding: '20px' }}> <h1>Catálogo de Produtos</h1> <input type="text" placeholder="Nome do produto" value={novoNome} onChange={(e) => setNovoNome(e.target.value)} /> <input type="number" placeholder="Preço" value={novoPreco} onChange={(e) => setNovoPreco(e.target.value)} /> <button onClick={adicionarProduto}>Adicionar Produto</button> <hr /> {produtos.map((p) => ( <Produto key={p.id} nome={p.nome} preco={p.preco} /> ))} </div> ); } export default App;
🧪 Resultado Esperado:
  • Página com título "Catálogo de Produtos"
  • Inputs para adicionar novos produtos
  • Lista renderizada com os produtos, exibindo nome e preço
  • Cada produto usando o componente Produto
🎓 Parte 3 – Entrega e Avaliação (30 min)
O que deve ser entregue:
  1. Código funcional via GitHub (repositório público)
  1. Aplicação rodando corretamente no navegador
  1. Uso correto de:
  • props
  • useState
  • .map() para renderização
📌 Pontos de avaliação:
💡 Dicas Extras para Alunos Avançados:
  • Estilizar usando CSS Modules ou Tailwind
  • Adicionar botão para remover produto da lista
  • Mostrar soma total dos preços
Atividade Prática
🧪 Atividade Prática : Desenvolvimento de Interfaces com React e Integração com API
🎯 Objetivo Geral
Capacitar os alunos a desenvolverem uma aplicação React mais robusta, com múltiplas páginas (SPA), navegação por rotas e integração com uma API pública externa, manipulando dados reais e criando uma interface interativa.
🛠️ Parte 1 – Preparação do Projeto (30 min)
✔️ Pré-requisitos:
  • Projeto React já instalado com Vite (pode aproveitar o da Aula 13)
  • Terminal ou editor (VS Code)
  • Acesso à internet (para consumir a API)
📥 1. Instale o React Router
Execute no terminal dentro da pasta do projeto:
npm install react-router-dom
📁 Estrutura Esperada do Projeto:
src/ ├── App.jsx ├── main.jsx ├── pages/ │ ├── Home.jsx │ ├── Usuarios.jsx │ └── UsuarioDetalhe.jsx
🧱 Parte 2 – Criando o App com Roteamento e API (2h)
🧩 Passo 1: Configurar o roteamento em main.jsx
import React from 'react'; import ReactDOM from 'react-dom/client'; import { BrowserRouter, Routes, Route } from 'react-router-dom'; import App from './App'; import Usuarios from './pages/Usuarios'; import UsuarioDetalhe from './pages/UsuarioDetalhe'; ReactDOM.createRoot(document.getElementById('root')).render( <BrowserRouter> <Routes> <Route path="/" element={<App />} /> <Route path="/usuarios" element={<Usuarios />} /> <Route path="/usuarios/:id" element={<UsuarioDetalhe />} /> </Routes> </BrowserRouter> );
🧩 Passo 2: Criar a página Home (App.jsx)
import { Link } from 'react-router-dom'; function App() { return ( <div style={{ padding: 20 }}> <h1>Bem-vindo!</h1> <p>Esta é a página inicial.</p> <Link to="/usuarios">Ver lista de usuários</Link> </div> ); } export default App;
🧩 Passo 3: Criar Usuarios.jsx (consome API externa)
import { useEffect, useState } from 'react'; import { Link } from 'react-router-dom'; function Usuarios() { const [usuarios, setUsuarios] = useState([]); useEffect(() => { fetch('https://jsonplaceholder.typicode.com/users') .then(resp => resp.json()) .then(dados => setUsuarios(dados)); }, []); return ( <div style={{ padding: 20 }}> <h2>Lista de Usuários</h2> {usuarios.map(user => ( <div key={user.id} style={{ marginBottom: 10 }}> <strong>{user.name}</strong> - {user.email} <br /> <Link to={`/usuarios/${user.id}`}>Ver detalhes</Link> </div> ))} </div> ); } export default Usuarios;
🧩 Passo 4: Criar UsuarioDetalhe.jsx
import { useParams } from 'react-router-dom'; import { useEffect, useState } from 'react'; function UsuarioDetalhe() { const { id } = useParams(); const [usuario, setUsuario] = useState(null); useEffect(() => { fetch(`https://jsonplaceholder.typicode.com/users/${id}`) .then(resp => resp.json()) .then(dados => setUsuario(dados)); }, [id]); if (!usuario) return <p>Carregando...</p>; return ( <div style={{ padding: 20 }}> <h2>Detalhes de {usuario.name}</h2> <p>Email: {usuario.email}</p> <p>Telefone: {usuario.phone}</p> <p>Website: {usuario.website}</p> <p>Empresa: {usuario.company.name}</p> </div> ); } export default UsuarioDetalhe;
🎓 Parte 3 – Entrega e Avaliação (30 min)
O que deve ser entregue:
  1. Projeto funcionando localmente com navegação entre páginas
  1. Consumo correto da API pública
  1. Dados sendo exibidos na tela de forma clara
📌 Critérios de Avaliação:
💡 Desafios Extras (para alunos avançados):
  • Estilizar com CSS ou Tailwind
  • Adicionar botão para voltar à lista
  • Paginar os usuários ou mostrar loaders
Atividade Prática - Consumindo API externa
📘 Atividade Prática: Desenvolvimento de Interfaces com React (3h)
Tema: Roteamento, Integração com API Externa e Criação de Interfaces Interativas Ferramentas: React + React Router + Fetch
🧠 Objetivo da Atividade
Nesta aula, você irá desenvolver uma pequena aplicação web em React com três páginas interativas, utilizando o React Router para navegação e consumindo dados reais de uma API externa para exibir informações dinâmicas.
Você vai aplicar os conceitos de:
  • Roteamento com react-router-dom
  • Uso de useState e useEffect
  • Consumo de API com fetch
  • Navegação dinâmica com parâmetros (useParams)
🛠️ Passo a Passo da Atividade
📌 1. Criar o projeto com Vite (se não tiver o da aula anterior)
No terminal:
npm create vite@latest usuarios-app --template react cd usuarios-app npm install npm run dev
📌 2. Instalar o React Router
npm install react-router-dom
📁 3. Estrutura Esperada de Arquivos
src/ ├── main.jsx ├── App.jsx ├── pages/ │ ├── Home.jsx │ ├── Usuarios.jsx │ └── UsuarioDetalhe.jsx
📌 4. Configurar as rotas em main.jsx
import React from 'react'; import ReactDOM from 'react-dom/client'; import { BrowserRouter, Routes, Route } from 'react-router-dom'; import App from './App'; import Usuarios from './pages/Usuarios'; import UsuarioDetalhe from './pages/UsuarioDetalhe'; ReactDOM.createRoot(document.getElementById('root')).render( <BrowserRouter> <Routes> <Route path="/" element={<App />} /> <Route path="/usuarios" element={<Usuarios />} /> <Route path="/usuarios/:id" element={<UsuarioDetalhe />} /> </Routes> </BrowserRouter> );
📌 5. Criar a página inicial (App.jsx)
import { Link } from 'react-router-dom'; function App() { return ( <div style={{ padding: 20 }}> <h1>Bem-vindo!</h1> <p>Esta é a página inicial do sistema.</p> <Link to="/usuarios">Ver lista de usuários</Link> </div> ); } export default App;
📌 6. Criar a página de usuários (Usuarios.jsx)
import { useEffect, useState } from 'react'; import { Link } from 'react-router-dom'; function Usuarios() { const [usuarios, setUsuarios] = useState([]); useEffect(() => { fetch('https://jsonplaceholder.typicode.com/users') .then(resp => resp.json()) .then(dados => setUsuarios(dados)); }, []); return ( <div style={{ padding: 20 }}> <h2>Usuários</h2> {usuarios.map(user => ( <div key={user.id} style={{ marginBottom: 10 }}> <strong>{user.name}</strong><br /> Email: {user.email}<br /> <Link to={`/usuarios/${user.id}`}>Ver detalhes</Link> <hr /> </div> ))} </div> ); } export default Usuarios;
📌 7. Criar a página de detalhes do usuário (UsuarioDetalhe.jsx)
import { useParams } from 'react-router-dom'; import { useEffect, useState } from 'react'; function UsuarioDetalhe() { const { id } = useParams(); const [usuario, setUsuario] = useState(null); useEffect(() => { fetch(`https://jsonplaceholder.typicode.com/users/${id}`) .then(resp => resp.json()) .then(dados => setUsuario(dados)); }, [id]); if (!usuario) return <p>Carregando...</p>; return ( <div style={{ padding: 20 }}> <h2>Detalhes de {usuario.name}</h2> <p><strong>Email:</strong> {usuario.email}</p> <p><strong>Telefone:</strong> {usuario.phone}</p> <p><strong>Site:</strong> {usuario.website}</p> <p><strong>Empresa:</strong> {usuario.company.name}</p> </div> ); } export default UsuarioDetalhe;
Critérios de Avaliação da Atividade
📤 Entrega
  • Envie o link do repositório GitHub com o código do projeto completo
  • Certifique-se de que a aplicação está funcionando corretamente
  • Prazo de entrega: Efetuar a atividade durante a aula
🔍 Como o React consome uma API externa (explicado com base no exemplo da atividade)
🎯 Objetivo:
A aplicação React vai se conectar a uma API externa (JSONPlaceholder) para buscar dados em tempo real e exibir esses dados no navegador de forma dinâmica.
⚙️ Fluxo completo da comunicação com a API:
  1. O componente é carregado na tela
  1. O React executa um código assim que o componente é montado (useEffect)
  1. Esse código usa fetch() para fazer uma requisição HTTP GET
  1. A resposta vem em formato JSON e é armazenada no estado do componente (useState)
  1. A interface é atualizada com os dados recebidos
🧪 Exemplo prático: Usuarios.jsx
🔗 1. A API usada
https://jsonplaceholder.typicode.com/users
Esse endpoint retorna uma lista com 10 usuários fictícios, contendo nome, e-mail, telefone, site, empresa, etc.
💡 2. Hook useState – Armazena os usuários
const [usuarios, setUsuarios] = useState([]);
Inicialmente o array está vazio. Assim que os dados chegarem da API, ele será preenchido.
3. Hook useEffect – Executa ao carregar a página
useEffect(() => { fetch('https://jsonplaceholder.typicode.com/users') .then(resp => resp.json()) .then(dados => setUsuarios(dados)); }, []);
O que esse código faz:
  • fetch() faz a chamada HTTP GET para a URL da API
  • O resultado (resp.json()) converte a resposta para um objeto JavaScript
  • A função setUsuarios(dados) atualiza o estado, o que faz o React re-renderizar a interface com os novos dados
🖼️ 4. Renderização com .map()
{usuarios.map(user => ( <div key={user.id}> <strong>{user.name}</strong><br /> Email: {user.email}<br /> </div> ))}
Agora que o estado usuarios está preenchido com dados reais, usamos .map() para exibir cada usuário dinamicamente na interface.
🧠 Em resumo:
💡 Observação Importante:
Esse mesmo padrão serve para qualquer API REST, seja pública como a do exemplo, ou privada (como APIs próprias da empresa ou de um back-end que você criou com FastAPI ou Node.js, por exemplo).
🖼️ Diagrama: Ciclo de Consumo de API com React
┌────────────────────────────┐ │ Componente │ │ React (SPA) │ └────────────┬───────────────┘ │ │ Montagem do componente ▼ ┌────────────────────────────┐ │ useEffect() │ │ Dispara requisição fetch │ └────────────┬───────────────┘ │ │ Requisição HTTP GET ▼ ┌────────────────────────────┐ │ API Externa │ │ (jsonplaceholder.typicode) │ └────────────┬───────────────┘ │ │ Resposta JSON ▼ ┌────────────────────────────┐ │ setState() │ │ Atualiza estado com dados │ └────────────┬───────────────┘ │ │ Re-renderização do componente ▼ ┌────────────────────────────┐ │ Interface Atualizada │ │ Dados exibidos na tela │ └────────────────────────────┘
🧭 Explicação do Diagrama:
  1. Montagem do Componente: Quando o componente React é montado, o hook useEffect é executado.
  1. Disparo da Requisição: Dentro do useEffect, é realizada uma requisição HTTP GET utilizando fetch para a API externa.
  1. Resposta da API: A API externa responde com os dados em formato JSON.
  1. Atualização do Estado: Os dados recebidos são armazenados no estado do componente utilizando useState.
  1. Re-renderização: A atualização do estado provoca a re-renderização do componente, exibindo os dados atualizados na interface.
🎯 Objetivo do Diagrama:
Este diagrama visa ilustrar o fluxo de consumo de uma API externa em uma aplicação React, destacando a interação entre os hooks useEffect e useState, a requisição e resposta da API, e a atualização da interface com os dados obtidos.
O que é o React?
React é uma biblioteca JavaScript de código aberto, desenvolvida pelo Facebook (agora Meta), para a construção de interfaces de usuário (UIs) interativas e complexas. Ele utiliza um modelo de programação declarativa, onde você descreve o que a UI deve parecer, e o React se encarrega de atualizar a tela com as alterações necessárias, com foco na eficiência e na performance.
O React é baseado em componentes, unidades independentes de código que representam partes da UI. Cada componente possui seu próprio estado e lógica, e pode ser reutilizado em diferentes partes da aplicação. Essa abordagem modular facilita o desenvolvimento, a manutenção e o teste de aplicações web.
Vantagens do React
Reutilização de código
Um dos principais benefícios do React é a capacidade de reutilizar componentes. Isso significa que você pode criar componentes individuais e reutilizá-los em diferentes partes do seu aplicativo. Essa abordagem modular reduz o código redundante e torna o desenvolvimento mais rápido e eficiente.
Desempenho aprimorado
O React utiliza um mecanismo de renderização virtual que otimiza o processo de atualização da interface do usuário. Isso significa que o React apenas atualiza as partes do aplicativo que realmente mudaram, resultando em melhor desempenho e responsividade.
Facilidade de aprendizado
React é relativamente fácil de aprender, especialmente para desenvolvedores com experiência em JavaScript. Sua sintaxe concisa e estrutura de componentes facilitam o desenvolvimento e a manutenção de aplicativos complexos.
Grande comunidade e ecossistema
React possui uma grande comunidade ativa de desenvolvedores, oferecendo amplo suporte, recursos e bibliotecas. Isso significa que você sempre terá acesso a ajuda e soluções para qualquer problema que possa encontrar.
Ambiente de desenvolvimento e configuração inicial

1

2

3

1
Instalar Node.js
2
Criar projeto React
3
Iniciar o servidor de desenvolvimento
Para começar a desenvolver com React, você precisa de um ambiente de desenvolvimento configurado. O primeiro passo é instalar o Node.js, uma plataforma de execução JavaScript que inclui o gerenciador de pacotes npm. Com o Node.js instalado, você pode usar o npm para criar um novo projeto React. O comando `create-react-app` cria um novo projeto React com todas as configurações necessárias para começar a desenvolver. Depois de criar o projeto, você pode iniciar o servidor de desenvolvimento com o comando `npm start`. Isso inicia o servidor de desenvolvimento e abre o projeto no navegador, permitindo que você visualize e teste o código React.
Estrutura de um projeto React
Pasta src
Contém os arquivos de código-fonte do aplicativo, como componentes, estilos e lógica de negócios.
Pasta public
Armazena arquivos estáticos, como o arquivo HTML principal (index.html), imagens e arquivos CSS.
Componentes no React
Componentes são blocos de código reutilizáveis que formam a estrutura de uma aplicação React. Pense neles como peças de Lego que você pode montar e desmontar para criar aplicativos complexos.
Cada componente é uma função JavaScript que recebe dados de entrada (chamados de "props") e retorna uma representação HTML do que deve ser exibido na tela. Essa representação HTML é chamada de "JSX", uma sintaxe JavaScript que permite escrever código HTML dentro do código JavaScript. Você pode até combinar vários componentes para criar componentes mais complexos.
Componentes são o coração do React e permitem a construção de interfaces de usuário complexas e dinâmicas de forma organizada e eficiente.
Tipos de Componentes: Funcionais e de Classe
Componentes Funcionais
Componentes funcionais são a maneira mais simples e eficiente de criar componentes no React. Eles são funções JavaScript puras que recebem props como argumentos e retornam um elemento React.
Componentes de Classe
Componentes de classe são mais complexos e permitem a implementação de funcionalidades adicionais, como o gerenciamento de estado e o ciclo de vida do componente.
Renderização de Componentes
1
Processo de Renderização
A renderização de componentes é o processo pelo qual o React transforma a estrutura de um componente em elementos HTML reais, que são então exibidos na página web. Este processo ocorre quando o componente é montado pela primeira vez ou quando seu estado ou props são alterados.
2
Reutilização de Componentes
A renderização de componentes permite a reutilização eficiente de código, pois um componente pode ser renderizado em vários lugares da aplicação. Isso torna o desenvolvimento mais rápido e facilita a manutenção do código.
3
Atualização Dinâmica
A renderização de componentes é dinâmica, o que significa que o React pode atualizar automaticamente a interface do usuário quando houver alterações no estado ou props do componente. Isso garante que a página web permaneça sincronizada com os dados da aplicação.
Propriedades (props) em componentes
Props, abreviação de "propriedades", são um mecanismo essencial para a comunicação e personalização de componentes em React. Elas permitem que você passe dados e informações de um componente para outro, tornando seus componentes reutilizáveis e flexíveis.
Imagine props como atributos HTML. Ao definir props, você configura como um componente deve se comportar ou renderizar.
Por exemplo, você pode ter um componente Card que exibe um título e um texto. Você pode usar props para personalizar o título e o texto de cada instância do componente Card, tornando-o versátil para vários cenários.
Passagem de props entre componentes

1

2

3

1
Componentes Filhos
Recebem dados de componentes pais através de props.
2
Componentes Pais
Transmitem dados para componentes filhos usando props.
3
Comunicação
Permite criar interfaces dinâmicas e reutilizáveis.
A passagem de props é um conceito fundamental no React, permitindo a comunicação entre componentes e a criação de interfaces mais dinâmicas e reutilizáveis. Os componentes pais passam dados para seus componentes filhos através de props, que são propriedades que podem ser acessadas dentro do componente filho. Essa comunicação unidirecional garante que os componentes filhos não possam modificar diretamente os dados dos pais, promovendo uma arquitetura mais organizada e previsível.
Estados (state) em componentes
No React, o estado (state) é uma das características fundamentais que permitem a dinâmica e interatividade dos componentes. Pense no estado como a fonte de verdade de um componente, contendo dados que podem mudar ao longo do tempo. Esses dados podem ser qualquer coisa: texto, números, objetos, arrays e até mesmo funções.
Cada componente possui seu próprio estado, que é gerenciado e atualizado por ele mesmo. Quando o estado de um componente muda, o React re-renderiza esse componente e todos os seus filhos, garantindo que a interface do usuário reflita as mudanças de forma eficiente e precisa.
Manipulação de Estados
1
Definindo o estado inicial
O estado é definido como uma propriedade especial do componente, geralmente inicializada como um objeto. Esse objeto contém os dados que serão usados para renderizar o componente e serão atualizados ao longo do tempo. Isso é feito usando o método `useState`, que retorna um array com dois elementos: o estado atual e uma função para atualizá-lo.
2
Atualizando o estado
O estado pode ser modificado usando a função de atualização fornecida pelo `useState`. Quando o estado é atualizado, o React re-renderiza o componente, tornando as alterações visíveis para o usuário.
3
Reagindo a eventos
A atualização do estado é geralmente feita em resposta a eventos do usuário, como cliques em botões ou alterações em campos de entrada. Isso permite que o componente seja dinâmico e interativo, respondendo a ações do usuário.
Ciclo de vida dos componentes
Compreendendo o ciclo de vida
O ciclo de vida de um componente React descreve as diferentes etapas que um componente passa desde sua criação até sua destruição. Saber como funciona esse ciclo é crucial para gerenciar estados, realizar operações de inicialização e limpeza, e otimizar a performance dos seus componentes.
Métodos importantes
O ciclo de vida oferece diversos métodos que você pode utilizar para controlar o comportamento do seu componente em cada etapa. Por exemplo, você pode usar o método `componentDidMount` para realizar operações de inicialização, como buscar dados de uma API, ou o método `componentWillUnmount` para liberar recursos antes de o componente ser removido.
Componentes Controlados e Não Controlados
Componentes Controlados
Os componentes controlados mantêm seus valores em sincronia com o estado da aplicação. Essa sincronização é feita através do uso de eventos e de métodos para atualizar o estado. O React controla os valores dos campos de entrada e os usa para exibir informações em tempo real, o que resulta em uma experiência mais responsiva para o usuário.
Componentes Não Controlados
Os componentes não controlados permitem que o navegador controle os valores dos campos de entrada. Os valores são atualizados diretamente no DOM, e o React pode ler esses valores para realizar operações ou renderizar informações. Essa abordagem pode ser mais simples para cenários básicos, mas oferece menos controle sobre os valores dos campos de entrada.
Uso de Hooks para Manipular Estados
Simplificação do Gerenciamento de Estado
Hooks fornecem uma maneira mais simples e direta de gerenciar estados em componentes funcionais sem a necessidade de classes.
Reutilização de Lógica
Você pode extrair a lógica de gerenciamento de estado para hooks personalizados, tornando-a reutilizável em diferentes componentes.
Melhoria da Legibilidade
O uso de hooks geralmente resulta em código mais limpo e fácil de entender, especialmente em componentes complexos.
Comunicação entre componentes
1
Props
Os dados são passados para baixo, de componentes pai para filho, por meio de props.
2
Callbacks
Os componentes filhos podem enviar dados de volta aos componentes pai através de callbacks, que são funções passadas como props.
3
State Management
Para comunicação mais complexa, use bibliotecas de gerenciamento de estado como Redux ou Context API para compartilhar dados entre componentes.
Fluxo de dados unidirecional
Uma das características mais importantes do React é o seu fluxo de dados unidirecional. Isso significa que os dados fluem em uma única direção, desde a raiz da árvore de componentes até as folhas. Essa abordagem garante previsibilidade e simplifica o raciocínio sobre como os dados são atualizados e como as mudanças afetam os componentes.
No React, o estado de um componente é imutável. Quando você precisa atualizar o estado, você cria um novo objeto com as alterações desejadas. Essa abordagem ajuda a evitar erros comuns relacionados à mutabilidade e torna mais fácil rastrear como os dados mudam ao longo do tempo.
O fluxo de dados unidirecional torna o React mais fácil de entender, depurar e testar. É uma abordagem poderosa que ajuda a criar aplicativos web complexos e escaláveis.
Reutilização de componentes
Economia de tempo e esforço
Ao criar componentes reutilizáveis, você economiza tempo e esforço no desenvolvimento de seu projeto. Em vez de escrever o mesmo código várias vezes, você pode simplesmente reutilizar um componente já existente.
Código mais organizado e consistente
A reutilização de componentes ajuda a manter seu código organizado e consistente. Ao usar o mesmo componente em diferentes partes do seu projeto, você garante que ele esteja funcionando da mesma forma em todos os lugares.
Facilidade de manutenção
Se precisar fazer alguma alteração em um componente, você só precisa fazer isso em um único lugar. Isso facilita a manutenção do seu código e garante que todas as instâncias do componente sejam atualizadas ao mesmo tempo.
Estilização de Componentes
CSS Inline
Aplique estilos diretamente no elemento HTML usando o atributo `style`.
CSS Modules
Crie arquivos CSS separados para cada componente e importe-os. Os nomes das classes são gerados automaticamente, evitando conflitos.
CSS-in-JS
Utilize bibliotecas como styled-components para escrever CSS dentro do JavaScript, permitindo estilos dinâmicos e reutilização.
Gerenciamento de Eventos em Componentes
Adicionando Handlers de Eventos
No React, você pode adicionar handlers de eventos a elementos HTML usando o atributo `onClick`.
Por exemplo, para adicionar um handler de evento ao clique em um botão, você pode usar o seguinte código:
<button onClick={handleClick}>Clique em mim</button>
A função `handleClick` será chamada quando o botão for clicado.
Passando Argumentos para Handlers de Eventos
Você pode passar argumentos adicionais para handlers de eventos usando funções anônimas.
Por exemplo, para passar um argumento para a função `handleClick`, você pode usar o seguinte código:
<button onClick={() => handleClick('argumento')}>Clique em mim</button>
A função `handleClick` será chamada com o argumento `'argumento'` quando o botão for clicado.
Condicionais e Renderização Condicional

1

2

3

1
Lógica Condicional
O React permite incorporar lógica condicional em seus componentes, permitindo que você controle o que é renderizado com base em condições específicas.
2
Operadores Ternários
Utilize o operador ternário para renderizar diferentes elementos com base em uma condição.
3
Expressões Condicionais
Utilize instruções `if` e `else` para controlar a renderização de elementos dentro do seu componente.
A renderização condicional no React é essencial para criar interfaces dinâmicas e interativas. Com ela, você pode exibir elementos específicos de acordo com as condições do seu aplicativo, como o estado do usuário ou a disponibilidade de dados.
Listas e Chaves em Componentes
Renderizando Listas
O React permite renderizar listas de elementos dinamicamente usando o método map() de arrays. Isso é fundamental para criar interfaces interativas e dinâmicas, onde o conteúdo da lista pode mudar com base em dados ou eventos.
A Importância das Chaves
Ao renderizar listas, é crucial usar a propriedade key para cada item. A key fornece ao React uma identidade única para cada elemento, ajudando-o a rastrear alterações e otimizar a renderização. Isso é essencial para garantir que o React atualize a lista de maneira eficiente, especialmente quando dados são adicionados, removidos ou modificados.
Fragmentos em React
Fragmentos em React são uma maneira de agrupar vários elementos sem adicionar um nó pai adicional ao DOM. Eles são úteis quando você deseja renderizar uma lista de elementos sem adicionar um nó extra como `
` ou ``.
Para criar um fragmento, use a sintaxe `` ou a abreviação `<> ... `.
Fragmentos são uma ótima maneira de manter seu código limpo e organizado, especialmente ao trabalhar com listas de elementos.
Portais em React
Portais em React são uma técnica que permite renderizar conteúdo em um local diferente da árvore de componentes padrão do React. Eles são usados ​​para casos em que você precisa inserir conteúdo em um elemento específico do DOM que não está diretamente dentro do componente atual. Por exemplo, você pode usar um portal para renderizar modais, tooltips ou mensagens flutuantes.
A função ReactDOM.createPortal() é usada para criar um portal. Ela recebe dois argumentos: o conteúdo que você deseja renderizar e o elemento DOM onde você deseja que ele seja renderizado. O portal será renderizado no elemento DOM especificado, mesmo que ele não seja um descendente direto do componente React.
Formulários em React
Criar formulários em React é um processo direto e eficiente, aproveitando a natureza declarativa da biblioteca. Você pode controlar o estado do formulário com o state e usar eventos para atualizar o estado sempre que o usuário interage com os campos.
O React oferece componentes de formulário pré-construídos como <input>, <textarea> e <select> para lidar com diferentes tipos de entrada do usuário. Você pode também personalizar o comportamento e a aparência desses componentes com CSS ou bibliotecas de estilos.
Gerenciando o estado do formulário
Para gerenciar o estado do formulário, você pode usar o state do componente. Isso permite que você armazene os valores dos campos do formulário e os atualize em tempo real à medida que o usuário digita ou seleciona opções.
Você pode então usar esses valores do estado para realizar validações, enviar dados para um servidor ou renderizar diferentes partes do formulário com base no estado atual.
Lifecycle Methods em Componentes de Classe
Métodos de ciclo de vida são funções especiais que permitem que você execute código em momentos específicos durante a vida útil de um componente de classe. Por exemplo, você pode executar ações personalizadas ao montar o componente, atualizar o estado ou desmontar o componente.
Usando métodos de ciclo de vida, você pode interagir com o componente e realizar ações específicas em diferentes fases do seu ciclo de vida. Isso permite que você personalize o comportamento do componente e realize tarefas complexas.
Alguns dos métodos de ciclo de vida mais usados são:
  • **componentDidMount()**: Executado após o componente ser renderizado na tela.
  • **componentDidUpdate()**: Executado após uma atualização de estado ou propriedades.
  • **componentWillUnmount()**: Executado antes que o componente seja removido do DOM.
Contexto (Context) em React
Compartilhamento de dados globalmente
O React Context fornece uma maneira de compartilhar dados entre componentes sem passar props manualmente pela árvore de componentes.
Evita prop drilling
Elimina a necessidade de passar props para cada componente intermediário, simplificando a estrutura do código.
Gerenciamento de estado centralizado
Permite centralizar o estado global da aplicação, tornando mais fácil a atualização e o acesso de diferentes partes da aplicação.
React Hooks
React Hooks são uma funcionalidade poderosa que permite usar funcionalidades de componentes de classe dentro de funções componentes, como o estado e o ciclo de vida, sem precisar escrever uma classe. Eles permitem que você escreva código mais conciso, reutilizável e fácil de entender.
Alguns hooks populares incluem useState para gerenciar o estado local, useEffect para efeitos colaterais como chamadas de API, useContext para acessar valores de contexto e muitos outros.
Otimização de Performance em React
1
Memorização
Use o hook `useMemo` para memorizar resultados de cálculos complexos, evitando recálculos desnecessários. Isso pode aumentar o desempenho, especialmente em componentes que renderizam frequentemente.
2
Renderização Condicional
Evite renderizar componentes ou elementos que não são necessários. Utilize `shouldComponentUpdate` para controlar quando um componente é re-renderizado. Isso pode reduzir o tempo de renderização e melhorar a performance.
3
Otimização de Listas
Utilize a chave `key` para identificar elementos únicos dentro de listas, permitindo que o React realize atualizações eficientes. Essa técnica garante que o React apenas atualize os itens que realmente mudaram.
4
Componentes de Estado Controlado
Use componentes de estado controlado, onde o estado é gerenciado pelo componente pai. Isso permite que o React otimize a renderização, atualizando apenas o estado que realmente mudou.
Boas práticas de código em React
Legibilidade e organização
Escrever código limpo e organizado é essencial para facilitar a manutenção e colaboração em projetos React. Utilize nomes de variáveis e funções descritivos, siga convenções de estilo de código e utilize ferramentas de formatação automática.
Testes automatizados
Implementar testes automatizados para seus componentes React garante a qualidade e a estabilidade do código. Utilize frameworks de teste como Jest ou React Testing Library para criar testes unitários, de integração e de ponta a ponta.
Revisão de código
Realizar revisões de código com outros desenvolvedores ajuda a identificar erros, melhorar a qualidade do código e compartilhar conhecimento. Utilize ferramentas de controle de versão como Git para facilitar o processo de revisão.
Conclusão e Próximos Passos
Domine os Fundamentos
Você aprendeu sobre os principais conceitos do React, como componentes, estados e props, e como usá-los para criar interfaces dinâmicas. Esta base sólida é crucial para o seu sucesso com React.
Explore Avançado
Mergulhe em tópicos mais avançados, como hooks, gerenciamento de estado, roteamento, testes e otimização de desempenho. O React oferece um ecossistema rico para construir aplicações complexas.
Pratique Constantemente
A prática é essencial para dominar o React. Crie seus próprios projetos, participe de comunidades online e explore exemplos de código. A prática constante aprimora suas habilidades.