Skip to content

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:

// Counter.tsx

import { useState } from 'react';

export function Counter() {
  const [value, setValue] = useState(0);

  function increment(): void {
    setValue((v) => v + 1);
  }

  return (
    <>
      <p>Value: {value}</p>
      <button onClick={increment}>+1</button>
    </>
  );
}

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
useState(initialValue)
cria um estado local e retorna o par [value, setValue]; setValue redesenha o componente com o novo valor
setValue(newValue)
substitui o valor do estado por um valor previamente calculado
setValue(v => ...)
calcula o novo valor com base no antigo (veja increment() acima)
useMemo(() => ..., [deps])
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:

// Parent.tsx

import { Counter } from './Counter';

export function Parent() {
  return (
    <div>
      <Counter />
    </div>
  );
}

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:

// my-context.tsx
import { createContext, useContext, type ReactNode } from 'react';

interface MyContextValue {
  greet: () => string;
}

const MyContext = createContext<MyContextValue | null>(null);

export function MyProvider({ children }: { children: ReactNode }) {
  const value: MyContextValue = { greet: () => 'Hello' };
  return <MyContext.Provider value={value}>{children}</MyContext.Provider>;
}

export function useMyContext(): MyContextValue {
  const context = useContext(MyContext);
  if (context === null) {
    throw new Error('useMyContext() must be called under a <MyProvider>');
  }
  return context;
}

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):

1
2
3
const httpResponse = await fetch('http://localhost:8080/hello');
const response = (await httpResponse.json()) as { message: string };
console.log(response.message);

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:

{loggedInUser ? (
  <p>Welcome!</p>
) : (
  <p>Please log in.</p>
)}

<ul>
  {itemList.map((item) => (
    <li key={item.id}>{item.name}</li>
  ))}
</ul>

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)
Standalone components ([@Component])
Componentes funcionais
Signals (signal(), input(), output(), computed())
[useState](), props, callback props, [useMemo]()
effect()
[useEffect]()
Separate template (.html) + decorator (.ts)
[JSX] incorporado ao componente (.tsx)
[@if], [@for]
Operador ternário / &&, .map()
Injectable services ([@Injectable]({ providedIn: 'root' })) + inject()
Hooks personalizados + [Context]
[HttpClient] (RxJS Observables)
[fetch] (Promises nativas)
[@angular/router] (empty routing table)
Sem roteador (mesma conclusão, levada um passo adiante)
Angular CLI / [@angular/build]
[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.