5. Capítulo 4 - Introdução ao [React]
5.1. Fontes
Este capítulo se baseia na documentação oficial do [React]: react.dev.
5.2. Do AngularJS 1.x ao [React]
O documento original (2014) usava o AngularJS 1.x: um framework JavaScript (ainda não TypeScript) organizado em torno de $scope, controllers, diretivas (ng-repeat, ng-if…) e de um mecanismo de detecção de mudanças baseado no “ciclo de digestão” ($digest) e no monitoramento de variáveis ($watch).
O [React] (criado pela Meta, 2013) não é um framework completo como o AngularJS 1.x ou o [Angular]: é uma biblioteca dedicada a uma única tarefa: construir interfaces a partir de componentes. Sozinho, ele não fornece nem um cliente HTTP, nem um roteador, nem um mecanismo de injeção de dependência — por isso o cliente [RdvMedecins] deste capítulo se apoia, para essas finalidades, na API nativa do navegador (fetch(), veja abaixo) e em um mecanismo específico do [React], o Context, em vez de módulos dedicados como o [HttpClient] ou o roteador do [Angular]. Este capítulo apresenta esses conceitos um a um, com exemplos curtos independentes do estudo de caso — o próximo capítulo os mostrará em ação no cliente [RdvMedecins] completo, em [React] 19.
5.3. O conceito de aplicação [React]: a “aplicação de página única”
Uma aplicação [React] é, como uma aplicação [Angular], uma aplicação de página única (SPA): o servidor entrega ao navegador apenas uma única página (HTML), contendo um único arquivo (JavaScript) que incorpora toda a lógica da aplicação. Depois que essa página é carregada, nunca há outro recarregamento completo da página: cada interação do usuário (troca de views, envio de um formulário etc.) é tratada pelo código JavaScript já presente no navegador, que atualiza a exibição e se comunica com o servidor em segundo plano por meio de requisições HTTP assíncronas (na maioria das vezes em JSON). Esse já era o princípio do documento original com AngularJS 1.x, assim como da variante [Angular] deste curso — ele não mudou: apenas a biblioteca que gerencia a exibição difere de uma variante para outra.
5.4. Componentes: funções e [JSX]
Como no [Angular], um componente é a unidade básica de uma aplicação [React]: ele gera o que deve ser exibido na tela com base em seu estado atual e nas propriedades que recebe. A diferença está na forma: um componente [Angular] é uma classe decorada, associada a um template HTML separado (ou inline); um componente [React] é simplesmente uma função JavaScript (ou TypeScript) que retorna [JSX] - uma sintaxe que se parece com HTML, mas que na verdade é transformada pelo compilador em chamadas comuns de funções JavaScript.
Eis um componente muito pequeno, independente do estudo de caso, equivalente ao [CounterComponent] apresentado na variante [Angular] deste curso:
Vamos comentar este código:
- linha 3: import { useState } from 'react'; — [useState] é um hook [React]: uma função especial (reconhecível pelo prefixo "use") que permite a uma função de componente manter um estado que persiste de uma renderização para a seguinte — um papel comparável ao de um signal do lado [Angular], ou ao do $scope/controller do AngularJS;
- linha 5: export function Counter() { — um componente [React] é uma função comum, exportada: não há decorador nem seletor personalizado (HTML) a declarar (ao contrário de [@Component]({ selector: … }) no lado [Angular]) — ele é usado diretamente como uma tag com o próprio nome, <Counter />, dentro do [JSX] de um componente pai;
- linha 6: const [value, setValue] = useState(0); — [useState](0) cria um valor de estado inicializado com 0 e retorna um par: o valor atual (value) e uma função para substituí-lo (setValue). A desestruturação do array ([value, setValue]) é apenas uma convenção de nomes — nada impede você de dar nomes diferentes a esses dois elementos;
- linhas 8–10: setValue((v) => v + 1); — chamar setValue não modifica `value` no local (os valores de estado do [React] são imutáveis): isso instrui o [React] a redesenhar o componente com o novo valor calculado a partir do antigo, exatamente como mySignal.update(v => …) faz no lado [Angular];
- linhas 13–16: <p>Value: {value}</p> — o [JSX] retornado pela função É o template: as chaves { } inserem uma expressão JavaScript (aqui, o valor atual) — desempenhando o mesmo papel das chaves duplas {{ value() }} no template [Angular], mas sem os parênteses de chamada: `value` é o próprio dado, e não um signal que precisa ser interpretado quando chamado.
A tag <> … </> (um “fragmento”) agrupa vários elementos sem acrescentar um nó HTML supérfluo em volta deles — um detalhe técnico do [JSX], que exige que uma função de componente retorne apenas um único elemento raiz.
5.5. O estado local: [useState] e props
No AngularJS 1.x, o [Angular] detectava que um valor de dado havia mudado por meio de um ciclo de verificação sistemático ($digest), que foi substituído, na variante [Angular] deste curso, por signals (signal(), computed()). [React] adota uma terceira abordagem, que parece mais simples: um componente reexecuta completamente a sua função (e, portanto, recalcula todo o seu [JSX]) toda vez que um de seus valores [useState] muda - [React] então compara o resultado com a renderização anterior e modifica apenas o que de fato mudou no DOM real do navegador (uma técnica chamada reconciliação, ou “DOM virtual”). Ao contrário dos signals, um estado [useState] não “sabe” por conta própria o que depende dele: o mecanismo de nova renderização do componente inteiro cuida disso, o que é mais simples de raciocinar, mas — em teoria — um pouco mais custoso em aplicações muito grandes, um compromisso deliberado do [React].
Função | Finalidade |
cria um estado local e retorna o par [value, setValue]; setValue redesenha o componente com o novo valor | |
substitui o valor do estado por um valor previamente calculado | |
calcula o novo valor com base no antigo (veja increment() acima) | |
recalcula um valor derivado somente quando um dos elementos de [deps] muda — o equivalente conceitual de computed() no lado [Angular] |
Dois mecanismos complementam o [useState] para permitir que um componente se comunique com seu pai — nós os encontraremos constantemente no cliente [RdvMedecins] (próximo capítulo), exatamente onde ficavam input()/output() no lado [Angular]:
- props: um componente [React] recebe suas entradas como simples parâmetros de função (um objeto desestruturado, { doctors, onSearch }) — o equivalente direto de input.required<Doctor[]>() no lado [Angular] e, conceitualmente, de um atributo de diretiva do AngularJS 1.x;
- callback props: uma função fornecida pelo pai (onSearch: (criteria) => void), passada como prop e depois chamada pelo filho no momento certo — o equivalente direto de output<...>() (e de seu método .emit(value)) no lado [Angular] e dos eventos personalizados ($emit) do AngularJS 1.x.
5.6. Sem módulos: cada arquivo já é autocontido
Uma aplicação AngularJS 1.x era organizada em módulos (angular.module(...)). [Angular] adotou inicialmente essa ideia de uma forma mais rígida (o NgModule), antes de propor os componentes standalone como modo padrão — uma simplificação que a variante [Angular] deste curso já adotou. [React] nunca precisou desse conceito: um arquivo .tsx exporta um componente com a palavra-chave export da própria linguagem JavaScript, e outro arquivo o usa com um simples import — os módulos ECMAScript padrão, sem nenhuma camada adicional específica da biblioteca de interface:
Este é o estilo usado em todo o cliente [RdvMedecins] (próximo capítulo): nenhum arquivo *.module.ts, nenhum decorador imports: [...] a manter atualizado — uma simplificação adicional em relação ao AngularJS 1.x, ao [Angular] com NgModule, e até aos componentes standalone do [Angular] (que, no entanto, ainda listam suas dependências em imports: [...] do decorador [@Component]).
5.7. Compartilhando lógica: hooks personalizados e [Context]
Como no [NestJS] (Capítulo 2), o cliente [RdvMedecins] precisa de lógica compartilhada entre vários componentes: comunicar-se com o servidor, identificar o usuário conectado e trocar o idioma. [Angular] atende a essa necessidade com serviços injetáveis ([@Injectable]({ providedIn: 'root' }) + inject(...)) — o sucessor direto de .service()/.factory() do AngularJS 1.x. [React] não tem um mecanismo embutido de injeção de dependência; o uso moderno combina duas ferramentas já discutidas acima:
- um hook personalizado — uma função cujo nome começa com `use`, que pode ela mesma chamar outros hooks ([useState], [useContext]…) — encapsula lógica reutilizável, exatamente como um método de serviço no lado [Angular];
- o Context ([React.createContext]) compartilha um valor (estado + funções) com uma subárvore inteira de componentes sem ter de repassá-lo manualmente, prop por prop, por cada nível intermediário — o papel antes desempenhado por providedIn: 'root' no lado [Angular]: uma única instância, disponível onde for necessária.
Um breve exemplo, independente do estudo de caso, conceitualmente equivalente ao [MyService] apresentado na variante [Angular] deste curso:
Vamos comentar este código:
- linha 8: const MyContext = createContext<MyContextValue | null>(null); — cria o próprio Context; `null` é o valor padrão, usado apenas se não houver um `<MyProvider>` acima dele na árvore — um erro de programação detectado na linha 17;
- linhas 10–13: <MyContext.Provider value={value}>{children}</MyContext.Provider> — o componente Provider disponibiliza o valor a todos os seus descendentes ({children}); é ele que é colocado, uma única vez, perto da raiz da aplicação (veja main.tsx do cliente [RdvMedecins], no próximo capítulo) — o equivalente do “registro” implícito feito por providedIn: 'root' no lado [Angular];
- linhas 15–21: export function useMyContext(): MyContextValue { — o hook personalizado que dá acesso ao valor do Context; é isso que os componentes chamam (const my = useMyContext();), exatamente como teriam chamado inject(MyService) no lado [Angular].
5.8. Comunicando-se com o servidor: [fetch]
[HttpClient] ([Angular]) foi o sucessor direto do serviço $http do AngularJS 1.x usado pelo documento original. Como o [React] é apenas uma biblioteca de interface, ele não fornece nenhum cliente HTTP: o cliente [RdvMedecins] usa diretamente o [fetch], a API padrão do navegador (disponível sem nenhuma dependência adicional):
Uma diferença importante em relação ao $http e ao [HttpClient]: [fetch] retorna diretamente uma Promise (o mecanismo assíncrono padrão do JavaScript), e não um Observable — sem biblioteca RxJS, sem .subscribe({ next, error }), sem .pipe(map(...)). Ele pode ser usado com .then(...) ou, para maior legibilidade, com async/await (como mostrado acima, o que suspende a execução da função até que a promise seja resolvida, sem bloquear o restante da aplicação). Um erro de rede ou uma resposta de erro é então tratado com um simples bloco try/catch, em vez do ramo de erro de uma assinatura RxJS.
O hook useAppointmentService() do cliente [RdvMedecins] (próximo capítulo) encapsula sistematicamente essa chamada [fetch] seguida de .json(), por um motivo específico explicado naquele ponto (o envelope [ServerResponse]<T> comum a todas as respostas do servidor).
5.9. Renderização condicional e listas: [JSX] puro
O AngularJS 1.x usava diretivas estruturais (ng-if, ng-repeat) para exibir um elemento condicionalmente ou repetir um bloco de template para cada elemento de uma lista. A variante [Angular] deste curso usa a sintaxe embutida [@if]/[@for]. [React] não tem uma sintaxe de template separada a aprender: o [JSX] retornado por um componente É JavaScript, e o controle de fluxo é expresso com operadores JavaScript comuns:
Vamos comentar este código:
- linhas 1–5: loggedInUser ? (...) : (...) — o operador ternário do JavaScript substitui [@if]/[@else] ([Angular]) e ng-if (AngularJS 1.x): a condição determina qual das duas expressões [JSX] é retornada. Para uma condição sem alternativa, o operador && é suficiente: {condition && <p>...</p>} não exibe absolutamente nada se a condição for falsa (este é o estilo usado, por exemplo, pelo banner ADMIN/USER no componente App do cliente [RdvMedecins], discutido no próximo capítulo);
- linha 8: itemList.map((item) => (...)) — .map() (um método padrão de array do JavaScript) substitui [@for] ([Angular]) e ng-repeat (AngularJS 1.x): ele transforma cada elemento do array em um elemento [JSX];
- linha 9: key={item.id} (obrigatório em uma lista [JSX]) — informa ao [React] como reconhecer um elemento já exibido quando ele redesenha a lista; isso desempenha exatamente o mesmo papel de track item.id depois de [@for] no lado [Angular].
5.10. Resumo: correspondências [Angular] -> [React]
[Angular] (versão anterior deste curso) | [React] (2026) |
Componentes funcionais | |
[useState](), props, callback props, [useMemo]() | |
[useEffect]() | |
[JSX] incorporado ao componente (.tsx) | |
Operador ternário / &&, .map() | |
Hooks personalizados + [Context] | |
[fetch] (Promises nativas) | |
Sem roteador (mesma conclusão, levada um passo adiante) | |
[Vite] |
Esses conceitos são suficientes para abordar o cliente [RdvMedecins] no próximo capítulo: cada novo uso será, no entanto, explicado novamente ali, à medida que o código avança, no ponto exato em que aparecer.