3. Componentes
3.1. Exemplo 10: Componentes e suas props
Um componente é um pedaço reutilizável da interface do usuário. Este exemplo cria um, [DoctorCard], e o utiliza várias vezes.
3.1.1. Tipo de dados
| // o tipo dos dados compartilhados pelo pai (App) e pelo filho (DoctorCard)
export interface Doctor {
id: number;
title: string;
firstName: string;
lastName: string;
specialty: string;
available: boolean;
}
|
O tipo [Doctor] é compartilhado pelo pai e pelo filho: ele fica em um módulo separado.
3.1.2. O filho
| // =========================================================================
// 10-components/src/DoctorCard.tsx - um componente FILHO
// -------------------------------------------------------------------------
// Ele recebe seus dados do pai por meio de PROPS (propriedades): os
// atributos escritos pelo pai em <DoctorCard ... />, reunidos pelo
// React em UM objeto, primeiro parâmetro da função. Seu tipo é
// verificado em tempo de compilação: <DoctorCard doctor={42} /> seria rejeitado.
//
// Regra de ouro: um componente NUNCA MODIFICA suas props. Os dados
// fluem do pai para o filho; para pedir uma mudança,
// o filho chama uma função que o pai lhe passou (cf. exemplo 11).
// =========================================================================
import type { Doctor } from './doctor';
// styles: um objeto { initials: '_initials_x7f3a_1' } - o nome real de cada classe
import styles from './DoctorCard.module.css';
// o tipo das props: o que o pai PODE (?) ou DEVE fornecer
interface Props {
doctor: Doctor;
rank: number;
compact?: boolean; // opcional
}
// o objeto props é "desestruturado"; compact = false: seu valor padrão
export default function DoctorCard({ doctor, rank, compact = false }: Props) {
// um valor calculado a partir das props: recalculado se o pai as mudar
const initials = `${doctor.firstName[0]}${doctor.lastName[0]}`;
return (
<div className={`card h-100 ${doctor.available ? 'border-success' : ''}`}>
<div className="card-body d-flex gap-3 align-items-center">
<div className={styles.initials}>{initials}</div>
<div>
<h2 className="h6 mb-1">{rank}. {doctor.title} {doctor.firstName} {doctor.lastName}</h2>
{!compact && <p className="mb-0 text-muted small">{doctor.specialty}</p>}
</div>
</div>
</div>
);
}
|
- linha 14: uma importação somente de tipo;
- linha 16: uma importação do módulo CSS (veja abaixo);
- linhas 19–23: os tipos das props do componente — os atributos que o pai escreve em [<DoctorCard ... />]. [compact?] é opcional;
- linha 26: o [React] combina as props em UM objeto, que passa como primeiro parâmetro da função. Ele é imediatamente “desempacotado”: [{ doctor, rank, compact = false }] gera três variáveis, com [compact] igual a [false] se o pai não o fornecer. O tipo das props é verificado em tempo de compilação: [<DoctorCard doctor={42} />] seria rejeitado, assim como a omissão de [rank];
- linha 28: um valor calculado a partir das props: se o pai mudar as props, o componente é reexecutado e o valor é recalculado;
- linha 33: a classe CSS, lida do módulo CSS;
- linha 36: a especialidade é exibida apenas no modo normal.
Regra de ouro: um componente nunca modifica suas próprias props. Os dados fluem do pai para o filho; para solicitar uma mudança, o filho chama uma função que o pai lhe passou (veja o Exemplo 11).
3.1.3. Um módulo CSS
| /* um "módulo CSS" (arquivo *.module.css): o Vite renomeia cada classe
(.initials -> ._initials_x7f3a_1); ela só pode, portanto, se aplicar aos
elementos do componente que o importa */
.initials {
width: 2.5rem;
height: 2.5rem;
border-radius: 50%;
display: flex;
align-items: center;
justify-content: center;
background: #087ea4;
color: white;
font-weight: bold;
}
|
Um arquivo cujo nome termina em [.module.css] é um módulo CSS: o [Vite] renomeia cada uma de suas classes ([.initials] torna-se, por exemplo, [._initials_x7f3a_1]) e, na importação, fornece um objeto que associa o nome original ao nome real: [styles.initials]. A classe só pode, portanto, ser aplicada a elementos do componente que a importa: isso equivale ao encapsulamento de estilos do [Angular]. As classes do [Bootstrap], que são globais, continuam utilizáveis em qualquer lugar.
3.1.4. O pai
| // =========================================================================
// 10-components/src/App.tsx - o componente PAI
// -------------------------------------------------------------------------
// Ele importa o componente DoctorCard e o usa como uma nova
// tag, <DoctorCard />, quantas vezes for preciso: um componente é
// um pedaço REUTILIZÁVEL de interface, com seus próprios dados, seu JSX e
// seu estilo. Uma tag que começa com letra MAIÚSCULA é um componente;
// em minúscula (<div>, <p>), é um elemento HTML.
// =========================================================================
import { useState } from 'react';
import DoctorCard from './DoctorCard';
import type { Doctor } from './doctor';
export default function App() {
const [doctors, setDoctors] = useState<Doctor[]>([
{ id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner', available: true },
{ id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician', available: false },
{ id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner', available: true },
]);
const [compact, setCompact] = useState(false);
// o pai modifica SEUS dados: o React chama o pai de novo, depois os
// filhos, com suas novas props
function toggleAvailability() {
setDoctors((list) => list.map((m) => ({ ...m, available: !m.available })));
}
return (
<div className="container py-4">
<h1 className="h3 mb-3">Example 10 - components and their props</h1>
<div className="d-flex gap-3 mb-3">
<label className="form-check-label">
<input type="checkbox" className="form-check-input" checked={compact}
onChange={(e) => setCompact(e.target.checked)} /> compact display
</label>
<button className="btn btn-sm btn-outline-primary" onClick={toggleAvailability}>Toggle availabilities</button>
</div>
<div className="row g-3">
{doctors.map((m, i) => (
<div key={m.id} className="col-md-4">
{/* doctor={m} passa o OBJETO m (uma expressão);
doctor="m", sem chaves, passaria a STRING "m" */}
<DoctorCard doctor={m} rank={i + 1} compact={compact} />
</div>
))}
</div>
<p className="mt-3 mb-1 small text-muted">The same card, in compact version, by an attribute without a value:</p>
<div className="w-50">
{/* compact, sem valor, é true */}
<DoctorCard doctor={doctors[0]} rank={1} compact />
</div>
</div>
);
}
|
- linha 12: o componente filho é importado como qualquer outro módulo;
- linhas 25–27: o pai modifica SEUS dados. O [React] o reexecuta e depois reexecuta os filhos com suas novas props: os cartões são atualizados;
- linha 44: o componente é usado como uma nova tag. [doctor={m}] passa o OBJETO [m] (uma expressão); [doctor="m"], sem chaves, passaria a STRING “m”;
- linha 51: um atributo sem valor ([compact]) é igual a [true].

Marcando “compact display” e depois invertendo as configurações de disponibilidade:

3.2. Exemplo 11: O filho notifica o pai
Os dados fluem para baixo pelas props. Para enviar informações de volta para cima, o pai passa funções ao filho, que as chama.
3.2.1. “Eventos” do filho
| // =========================================================================
// 11-lifting-state-up/src/Counter.tsx
// -------------------------------------------------------------------------
// Um filho que NOTIFICA seu pai: o pai lhe passa FUNÇÕES
// nas props (por convenção, seu nome começa com "on"), e o filho
// as chama quando algo acontece:
// <Counter label="Coffees" max={3} onIncrement={...} onLimit={...} />
// =========================================================================
import { useState } from 'react';
interface Props {
label: string;
max: number;
onIncrement: (value: number) => void; // com o novo valor
onLimit: () => void; // sem dados
}
export default function Counter({ label, max, onIncrement, onLimit }: Props) {
// o estado PRÓPRIO deste contador: cada <Counter> tem o seu
const [value, setValue] = useState(0);
function plus() {
if (value >= max) {
onLimit();
return;
}
setValue(value + 1);
// value ainda não foi modificado (será na próxima chamada do
// componente): value + 1 é passado
onIncrement(value + 1);
}
return (
<div className="d-flex align-items-center gap-2 mb-2">
<span className="w-25">{label}</span>
<button className="btn btn-sm btn-outline-primary" onClick={plus}>+1</button>
<span className="badge text-bg-secondary">{value} / {max}</span>
</div>
);
}
|
- Linhas 12–17: duas props são funções: [onIncrement] recebe o novo valor, enquanto [onLimit] não recebe nada. Por convenção, seus nomes começam com “on”, como [onClick];
- Linha 21: o estado PRÓPRIO deste contador: cada [<Counter>] da página tem o seu. O estado está associado à posição do componente na árvore da página;
- linhas 23–32: o pai é notificado. Atenção: [setValue(value + 1)] não altera a variável [value] (uma constante fixada para ESTA chamada do componente): ela será [value + 1] na PRÓXIMA chamada. Por isso, [value + 1] é passado ao pai.
3.2.2. Um componente controlado
| // =========================================================================
// 11-lifting-state-up/src/TextField.tsx - um componente CONTROLADO
// -------------------------------------------------------------------------
// Um campo de formulário "caseiro" (rótulo + campo + ajuda + contador de
// caracteres) usado como um <input> controlado (cf. exemplo 05):
// <TextField value={lastName} onChange={setLastName} label="Last name" max={20} />
// O componente NÃO tem estado: o valor pertence ao pai, que o passa
// (value) e que ele notifica a cada tecla digitada (onChange). É o
// pai que decide o novo valor.
// =========================================================================
import { useId } from 'react';
interface Props {
value: string;
onChange: (value: string) => void;
label: string;
max: number;
help?: string;
}
export default function TextField({ value, onChange, label, max, help = '' }: Props) {
// useId: um identificador ÚNICO, diferente para cada <TextField> da
// página, para ligar <label htmlFor> e <input id>
const id = useId();
return (
<div className="mb-3">
<label className="form-label" htmlFor={id}>{label}</label>
<input id={id} className={`form-control ${value.length === max ? 'is-invalid' : ''}`} value={value}
maxLength={max} onChange={(e) => onChange(e.target.value)} />
<div className="form-text">{help} ({value.length} / {max})</div>
</div>
);
}
|
Um campo de formulário “personalizado” (rótulo, campo, dica, contador de caracteres) usado como um [<input>] controlado (veja o Exemplo 05): o pai lhe passa o valor ([value]) e uma função chamada a cada tecla digitada ([onChange]).
- linhas 14–20: as props; [help] é opcional;
- linha 25: [useId()] fornece um identificador único, diferente para cada [<TextField>] da página, para vincular [<label htmlFor>] e [<input id>];
- linha 31: cada tecla digitada chama a função do pai com o novo texto.
O componente não tem estado: o valor pertence ao pai, que determina o novo valor. É o que se chama de “elevar o estado” (lifting state up): os dados compartilhados por vários componentes são armazenados no ancestral comum mais próximo.
3.2.3. O pai
| // =========================================================================
// 11-lifting-state-up/src/App.tsx - o pai escuta seus filhos
// -------------------------------------------------------------------------
// Os dados fluem para baixo (props); a informação sobe por meio de
// funções passadas nas props:
// 1. "eventos" do filho: onIncrement, onLimit;
// 2. um componente controlado: value + onChange, como um <input>. O estado
// continua sendo propriedade do pai, que pode modificá-lo ele mesmo (Clear).
// =========================================================================
import { useState } from 'react';
import Counter from './Counter';
import TextField from './TextField';
export default function App() {
const [total, setTotal] = useState(0);
const [message, setMessage] = useState('');
const [firstName, setFirstName] = useState('Marie');
const [lastName, setLastName] = useState('PELISSIER');
// a função chamada por um contador: ela recebe o valor que ele passa
function onIncrement(label: string, value: number) {
setTotal((t) => t + 1);
setMessage(`${label} is now ${value}`);
}
function clear() {
setFirstName('');
setLastName('');
}
return (
<div className="container py-4" style={{ maxWidth: 640 }}>
<h1 className="h3 mb-3">Example 11 - the child notifies its parent</h1>
<div className="card p-3 mb-4">
<h2 className="h6">1. Functions called by the children</h2>
<Counter label="Coffees" max={3} onIncrement={(v) => onIncrement('Coffees', v)}
onLimit={() => setMessage('No more than 3 coffees!')} />
<Counter label="Glasses of water" max={8} onIncrement={(v) => onIncrement('Glasses of water', v)}
onLimit={() => setMessage('Enough drinking.')} />
<p className="mb-0">Total of the clicks: {total} - <em>{message}</em></p>
</div>
<div className="card p-3">
<h2 className="h6">2. Controlled components</h2>
{/* onChange={setFirstName}: a função do estado, passada como está */}
<TextField value={firstName} onChange={setFirstName} label="First name" max={20} help="Required" />
<TextField value={lastName} onChange={setLastName} label="Last name" max={20} help="Displayed in upper case" />
<p className="mb-0">Data of the parent: <strong>{firstName} {lastName.toUpperCase()}</strong></p>
<button className="btn btn-sm btn-outline-secondary mt-2 align-self-start" onClick={clear}>Clear (from the parent)</button>
</div>
</div>
);
}
|
- linhas 22–25: a função chamada por um contador; ela recebe o valor que o contador lhe passa;
- linhas 38–39: o pai passa funções arrow, que acrescentam o rótulo do contador;
- linha 48: [onChange={setFirstName}]: a função de estado é passada como está; o filho a chama com o novo texto;
- linha 51: o próprio pai modifica os valores; os campos acompanham.
Clique duas vezes, depois quatro vezes no primeiro “+1”, uma vez no segundo e digite “Dupont” no campo Last name:

3.3. Exemplo 12: Composição
As props passam dados... mas também conteúdo: "JSX" é um valor como qualquer outro (como "[ReactNode]"), que pode ser passado a um componente, e o componente pode colocá-lo onde quiser.
3.3.1. Um cartão
| // =========================================================================
// 12-composition/src/Card.tsx - um TEMPLATE reutilizável
// -------------------------------------------------------------------------
// As props passam DADOS... mas também CONTEÚDO: o JSX é
// um valor como outro qualquer (do tipo ReactNode), que pode ser passado a um
// componente e que ele coloca onde quiser:
// - children: a prop especial que recebe o que o pai escreve ENTRE
// <Card> e </Card> - o conteúdo "principal";
// - header, footer: outros espaços reservados, fornecidos pelo pai na
// forma de props; header tem um conteúdo padrão.
// O card define a moldura (borda, cabeçalho, rodapé), o pai fornece o que
// está dentro. É o equivalente, no lado do cliente, do template layout.hbs
// e de seu {{{body}}} no curso de NestJS.
// =========================================================================
import type { ReactNode } from 'react';
interface Props {
color?: 'primary' | 'success' | 'danger';
header?: ReactNode;
footer?: ReactNode;
children: ReactNode;
}
export default function Card({ color, header = 'Untitled', footer, children }: Props) {
return (
<div className={`card mb-3 ${color ? `border-${color}` : ''}`}>
<div className={`card-header ${color ? `text-bg-${color}` : ''}`}>{header}</div>
<div className="card-body">{children}</div>
{/* nenhum footer fornecido: nenhum rodapé */}
{footer && <div className="card-footer text-muted small">{footer}</div>}
</div>
);
}
|
- linhas 18–23: [header], [footer] e [children] são [ReactNode]: JSX, texto, um número ou nada;
- linha 25: conteúdo padrão;
- linha 29: [children] é uma propriedade especial: ela recebe tudo o que o pai escreve ENTRE [<Card>] e [</Card>] — o conteúdo “principal”;
- linha 31: nenhum rodapé fornecido — nenhum rodapé é exibido.
O template define a moldura (borda, cabeçalho, rodapé); o pai fornece o conteúdo dentro dela: isso equivale à projeção de conteúdo do [Angular] ([<ng-content>]) e aos “slots” do [Vue.js]e, no lado do servidor, ao template [layout.hbs] e seu [{{{body}}}] no curso [NestJS].
3.3.2. Uma tabela genérica
| // =========================================================================
// 12-composition/src/DataTable.tsx - uma tabela GENÉRICA
// -------------------------------------------------------------------------
// DataTable<T> é um componente genérico: ele exibe linhas de
// qualquer tipo T. Sabe percorrer as linhas, mas não como
// exibir UMA linha: é o pai que lhe diz, passando-lhe uma
// FUNÇÃO, renderRow(row, index), que retorna o JSX das células.
// É o que se chama de "render prop": o conteúdo fornecido pelo
// pai usa dados que pertencem ao filho (a linha, sua
// posição).
// =========================================================================
import type { ReactNode } from 'react';
interface Props<T> {
rows: T[];
columns: string[];
renderRow: (row: T, index: number) => ReactNode;
empty?: ReactNode; // exibido quando não há nenhuma linha
}
// <T extends { id: number }>: cada linha deve ter um id (a key)
export default function DataTable<T extends { id: number }>({ rows, columns, renderRow, empty = 'No data.' }: Props<T>) {
return (
<table className="table table-sm align-middle mb-0">
<thead>
<tr>
{columns.map((c) => <th key={c}>{c}</th>)}
</tr>
</thead>
<tbody>
{rows.length === 0 ? (
<tr>
<td className="text-muted" colSpan={columns.length}>{empty}</td>
</tr>
) : (
rows.map((l, i) => <tr key={l.id}>{renderRow(l, i)}</tr>)
)}
</tbody>
</table>
);
}
|
- linhas 15–20: um tipo genérico: as props de um array de linhas do tipo [T], sejam elas quais forem;
- linha 18: uma prop que é uma função que retorna JSX: a tabela sabe percorrer as linhas, mas não sabe exibir UMA linha; o pai lhe diz como. Esse procedimento é chamado de “render prop”;
- linha 23: um componente genérico: [T] é inferido em tempo de execução a partir do tipo das linhas. Cada linha deve ter um [id], que serve como chave;
- linha 37: para cada linha, a tabela chama a função do pai, passando-lhe os dados que lhe pertencem (a linha, seu índice).
3.3.3. O pai
| // =========================================================================
// 12-composition/src/App.tsx - usando os templates Card e DataTable
// =========================================================================
import { useState } from 'react';
import Card from './Card';
import DataTable from './DataTable';
interface Slot {
id: number;
time: string;
patient: string | null;
}
export default function App() {
const [slots] = useState<Slot[]>([
{ id: 1, time: '8:00 - 8:20', patient: null },
{ id: 2, time: '8:20 - 8:40', patient: 'Mme Alice DURAND' },
{ id: 3, time: '8:40 - 9:00', patient: null },
]);
const free = slots.filter((c) => c.patient === null).length;
return (
<div className="container py-4" style={{ maxWidth: 720 }}>
<h1 className="h3 mb-3">Example 12 - composition</h1>
{/* header e footer: JSX passado nas props; entre as tags: children */}
<Card color="primary" header={<span>Schedule of Mme PELISSIER</span>} footer={`${free} free slot(s)`}>
{/* DataTable<Slot>: T é deduzido do tipo das linhas */}
<DataTable
rows={slots}
columns={['#', 'Slot', 'Status']}
// a "render prop": como exibir UMA linha; c recebe a linha, i sua posição
renderRow={(c, i) => (
<>
<td>{i + 1}</td>
<td>{c.time}</td>
<td>
{c.patient ? (
<span className="badge text-bg-secondary">{c.patient}</span>
) : (
<span className="badge text-bg-success">Free</span>
)}
</td>
</>
)}
/>
</Card>
<Card color="success" header="A card without a footer">
<p className="mb-0">The footer is not provided: the card does not display it.</p>
</Card>
{/* nenhum header fornecido: o conteúdo padrão, "Untitled" */}
<Card>
<DataTable<{ id: number; name: string }>
rows={[]}
columns={['Name']}
renderRow={(p) => <td>{p.name}</td>}
empty={<span>Nobody for now.</span>}
/>
</Card>
</div>
);
}
|
- Linha 28: [header] e [footer] recebem dados de JSX ou texto; o [<DataTable>] escrito entre as tags torna-se o [children] do cartão;
- Linhas 34–43: a render prop: como exibir UMA linha; [c] recebe a linha (do tipo [Slot], derivado de [rows]), com [i] como sua posição;
- Linha 56: com uma lista vazia, o [TypeScript] não consegue deduzir [T]: ele é fornecido explicitamente;
- linha 60: o conteúdo exibido quando não há linhas.

3.4. Exemplo 13: O ciclo de vida de um componente
3.4.1. Um relógio
| // =========================================================================
// 13-lifecycle/src/Clock.tsx - um componente que inicia e para
// -------------------------------------------------------------------------
// A vida de um componente:
// 1. ele é EXIBIDO (montado): o React chama a função e coloca seu
// resultado na página; depois executa seus efeitos (useEffect);
// 2. ele é ATUALIZADO, quantas vezes for preciso (seu estado ou suas
// props mudam);
// 3. ele é REMOVIDO da página (desmontado): o React executa a LIMPEZA de
// seus efeitos, a função que cada efeito retornou.
// Um relógio inicia um timer (setInterval) quando aparece... e
// deve obrigatoriamente pará-lo quando desaparece: caso contrário o timer
// continuaria rodando à toa (vazamento de memória).
// =========================================================================
import { useEffect, useEffectEvent, useState } from 'react';
interface Props {
onLog: (message: string) => void;
}
export default function Clock({ onLog }: Props) {
const [time, setTime] = useState(() => new Date().toLocaleTimeString());
// useEffectEvent: uma função chamada POR um efeito, que sempre lê
// as props mais recentes, sem ser uma dependência do efeito. Sem
// isso, onLog teria de ser colocada nas dependências [...] abaixo,
// e, como o pai passa uma função NOVA a cada exibição, o
// timer seria parado e reiniciado a cada segundo
const log = useEffectEvent((message: string) => onLog(message));
// []: nenhuma dependência. O efeito roda UMA vez, após a primeira
// exibição; a função que ele retorna, UMA vez, quando o componente é removido
useEffect(() => {
log('Clock: effect - starting the timer');
const timer = setInterval(() => setTime(new Date().toLocaleTimeString()), 1000);
// a LIMPEZA
return () => {
clearInterval(timer);
log('Clock: cleanup - timer stopped');
};
}, []);
return <div className="display-6 font-monospace">{time}</div>;
}
|
O ciclo de vida de um componente (linhas 4–10): ele é montado (exibido pela primeira vez), atualizado quantas vezes for necessário e, depois, desmontado (removido da página). O [React] não tem métodos separados para cada etapa: tudo passa por [useEffect].
- Linhas 34–42: [useEffect(effect, [])]: com um array de dependências VAZIO, o efeito é executado uma única vez, após a primeira exibição. A função que ele retorna (linhas 38–41) cuida da limpeza: o [React] a executa quando o componente é removido da página (e antes de cada nova execução do efeito, quando suas dependências mudam). Um relógio inicia um timer ([setInterval]) na inicialização... e deve pará-lo ([clearInterval]) quando desaparece: caso contrário, o timer continuaria rodando à toa e tentaria modificar o estado de um componente que não existe mais;
- Linha 30: o efeito chama a função [onLog] do pai. A rigor, ele deveria incluí-la em suas dependências: como o efeito usa uma prop, ele precisa ser reativado se a prop mudar. Porém, o pai cria uma função NOVA a cada exibição: o timer seria parado e reiniciado continuamente. [useEffectEvent] ([React] 19.2) cria uma função que sempre chama a versão mais recente de [onLog], sem ser uma dependência do efeito. Ela só pode ser chamada de dentro de um efeito.
3.4.2. O pai
| // =========================================================================
// 13-lifecycle/src/App.tsx
// -------------------------------------------------------------------------
// - {withClock && <Clock />}: marcar / desmarcar a caixa exibe /
// remove o componente (efeito, depois limpeza, cf. Clock.tsx);
// - useRef: uma referência ao elemento <input>, null enquanto ele não for
// exibido; um efeito lhe dá o foco assim que ele aparece;
// - um efeito que SINCRONIZA o título da aba com o input.
//
// Em desenvolvimento, o StrictMode (cf. main.tsx) monta cada componente,
// desmonta e em seguida remonta imediatamente: o log mostra, portanto, start,
// stop, start. É intencional: um efeito cuja limpeza está mal escrita
// (um timer nunca parado) se denuncia na hora. Em produção, o
// componente é montado apenas uma vez.
// =========================================================================
import { useEffect, useRef, useState } from 'react';
import Clock from './Clock';
export default function App() {
const [withClock, setWithClock] = useState(true);
const [log, setLog] = useState<string[]>([]);
const [search, setSearch] = useState('');
const [showSearch, setShowSearch] = useState(false);
const field = useRef<HTMLInputElement>(null);
function trace(message: string) {
setLog((j) => [...j, `${new Date().toLocaleTimeString()} ${message}`]);
}
// após a primeira exibição de App (duas vezes em desenvolvimento: StrictMode)
useEffect(() => {
trace('App: effect of the first display');
}, []);
// o campo acabou de aparecer: ele recebe o foco
useEffect(() => {
if (showSearch) {
field.current?.focus();
}
}, [showSearch]);
// o título da aba acompanha o input, desde o início
useEffect(() => {
document.title = search ? `Search: ${search}` : 'Example 13';
}, [search]);
return (
<div className="container py-4" style={{ maxWidth: 720 }}>
<h1 className="h3 mb-3">Example 13 - the lifecycle of a component</h1>
<div className="card p-3 mb-3">
<label className="form-check-label mb-2">
<input type="checkbox" className="form-check-input" checked={withClock}
onChange={(e) => setWithClock(e.target.checked)} /> show the clock
</label>
{withClock && <Clock onLog={trace} />}
</div>
<div className="card p-3 mb-3">
{!showSearch ? (
<button className="btn btn-outline-primary align-self-start" onClick={() => setShowSearch(true)}>Search...</button>
) : (
<input ref={field} className="form-control" placeholder="the title of the tab follows the input" value={search}
onChange={(e) => setSearch(e.target.value)} />
)}
</div>
<h2 className="h6">Log</h2>
<ol className="small">
{log.map((line, i) => <li key={i}>{line}</li>)}
</ol>
</div>
);
}
|
- linha 25: uma referência ao campo de busca, [null], enquanto ele não estiver exibido;
- linhas 32–34: o efeito da primeira exibição de [App];
- linhas 37–41: quando o campo aparece, ele recebe o foco: o efeito é executado DEPOIS da exibição, quando o elemento existe e a referência aponta para ele;
- linhas 44–46: um efeito que sincroniza o título da aba com o estado;
- linha 57: marcar/desmarcar a caixa exibe/oculta o relógio.
Na inicialização, o log é surpreendente: o relógio inicia, para e reinicia, e o efeito [App] é executado duas vezes. Isso é obra do [<StrictMode>] (veja [main.tsx]): apenas em desenvolvimento, o [React] monta cada componente, desmonta-o e o remonta imediatamente para verificar se seus efeitos sabem limpar após si mesmos. Um efeito mal escrito (como um timer que nunca para) é assim revelado de imediato: o relógio avançaria dois segundos por vez. Em produção, o componente é montado uma única vez. Observamos também que os efeitos dos filhos (o relógio) são executados ANTES dos do pai.
Depois, desmarque e marque a caixa novamente e digite “pediatrician” no campo de busca:

Os efeitos são a parte mais delicada do [React]. Uma regra orienta seu uso: um efeito sincroniza o componente com algo fora do [React] (o título da aba, um timer, um ouvinte de evento do documento, um servidor). Para calcular um valor a partir de outro, use uma variável (Exemplo 02), não um efeito. Para responder a uma ação do usuário, use um tratador de evento, não um efeito.
3.5. Exemplo 14: Contextos
Como compartilhar dados e funções entre componentes distantes sem passá-los de prop em prop por todos os intermediários? Com um contexto. É assim que o [React] compartilha o que o [Angular] guarda em seus serviços, fornecidos por injeção de dependência.
3.5.1. Um contexto para toda a aplicação
| // =========================================================================
// 14-contexts/src/contexts/log.tsx - um contexto para TODA a aplicação
// -------------------------------------------------------------------------
// Como compartilhar dados e funções entre componentes distantes,
// sem passá-los de props em props por todos os
// intermediários? Com um CONTEXTO:
// 1. createContext(defaultValue) cria o contexto;
// 2. um componente PROVIDER, <LogContext value={...}>, dá seu
// valor a TODOS os seus descendentes, em qualquer profundidade;
// 3. um descendente o LÊ com use(LogContext) (ou useContext).
// Quando o valor fornecido muda, todos os componentes que o leem são
// chamados de novo.
//
// O costume: um arquivo por contexto, que exporta o provider (um
// componente que guarda o estado) e um HOOK para lê-lo (useLog).
// É assim que o React compartilha o que o Angular guarda em seus serviços.
// =========================================================================
import { createContext, use, useCallback, useMemo, useState, type ReactNode } from 'react';
interface Log {
lines: string[];
trace: (message: string) => void;
}
// null: o valor lido se NENHUM provider envolver o componente
const LogContext = createContext<Log | null>(null);
// o provider: ele guarda o estado e o fornece a seus descendentes
export function LogProvider({ children }: { children: ReactNode }) {
const [lines, setLines] = useState<string[]>([]);
// useCallback: a MESMA função de uma exibição para a seguinte (e não
// uma nova a cada vez), para que os componentes que a recebem
// não pareçam ter mudado
const trace = useCallback((message: string) => {
setLines((l) => [`${new Date().toLocaleTimeString()} ${message}`, ...l].slice(0, 6));
}, []);
// useMemo: um novo objeto somente se lines mudou
const value = useMemo(() => ({ lines, trace }), [lines, trace]);
// React 19: o próprio contexto é o componente provider
return <LogContext value={value}>{children}</LogContext>;
}
// o hook de leitura: um nome que começa com "use"
export function useLog(): Log {
// use(context): o valor fornecido pelo provider MAIS PRÓXIMO
const log = use(LogContext);
if (log === null) {
throw new Error('useLog must be used inside a <LogProvider>');
}
return log;
}
|
- linhas 21–24: o que o contexto fornece: dados e uma função;
- linha 27: [createContext(defaultValue)] cria o contexto. [null]: o valor lido por um componente que não está envolvido por nenhum provider;
- linhas 30–45: o provider: um componente que contém o estado e o repassa a todos os seus descendentes, em qualquer profundidade:
- linha 36: [useCallback(fn, [dependencies])] passa a MESMA função de uma exibição para a seguinte (enquanto as dependências não mudarem), em vez de criar uma nova. Aqui, não há dependências: [setLines] nunca muda;
- linha 41: o objeto fornecido só é recriado se [lines] tiver mudado. Sem essas precauções, o provider forneceria um novo objeto a cada exibição, e todos os componentes que leem o contexto seriam chamados desnecessariamente;
- linha 44: a partir do [React] 19, o próprio contexto é o componente provider (antes, escrevia-se [<LogContext.Provider>]);
- Linhas 48–55: um hook de leitura. [use(context)] ([React] 19; antes [useContext]) retorna o valor do provider mais próximo. O hook verifica se há um: um erro claro é melhor do que um [null] inesperado.
3.5.2. Um contexto fornecido por um componente
| // =========================================================================
// 14-contexts/src/contexts/cart.tsx - um contexto fornecido por UM componente
// -------------------------------------------------------------------------
// O carrinho só é fornecido a uma parte da árvore de componentes: aqueles
// envolvidos por <CartProvider> (cf. App.tsx). Dois providers colocados em
// dois lugares da página dariam dois carrinhos independentes.
// Um provider pode ele mesmo ler outros contextos: o carrinho
// usa o log.
// =========================================================================
import { createContext, use, useMemo, useState, type ReactNode } from 'react';
import { useLog } from './log';
export interface Item {
label: string;
price: number;
}
interface Cart {
items: Item[];
total: number;
add: (item: Item) => void;
remove: (index: number) => void;
}
const CartContext = createContext<Cart | null>(null);
export function CartProvider({ children }: { children: ReactNode }) {
const { trace } = useLog();
const [items, setItems] = useState<Item[]>([]);
const value = useMemo<Cart>(
() => ({
items,
total: items.reduce((sum, a) => sum + a.price, 0),
add: (item) => {
setItems((a) => [...a, item]);
trace(`cart: + ${item.label}`);
},
remove: (index) => {
trace(`cart: - ${items[index].label}`);
setItems((a) => a.filter((_, i) => i !== index));
},
}),
[items, trace],
);
return <CartContext value={value}>{children}</CartContext>;
}
export function useCart(): Cart {
const cart = use(CartContext);
if (cart === null) {
throw new Error('useCart must be used inside a <CartProvider>');
}
return cart;
}
|
O carrinho de compras é fornecido apenas a uma parte da árvore de componentes: aqueles envolvidos por [<CartProvider>]. Dois providers colocados em locais diferentes da página resultariam em dois carrinhos independentes.
- Linha 29: um provider é um componente; ele mesmo pode ler outros contextos; o carrinho de compras usa o log;
- Linhas 32–46: os dados ([items], [total]) e as ações ([add], [remove]), que são recalculados quando os itens mudam.
3.5.3. Um contexto configurado
| // =========================================================================
// 14-contexts/src/contexts/clock.tsx - um contexto PARAMETRIZADO
// -------------------------------------------------------------------------
// Um relógio, cujo período de atualização é uma prop do
// provider: <ClockProvider period={5000}>. Dois providers
// aninhados: um componente lê o que estiver MAIS PRÓXIMO dele.
// O relógio para quando seu provider desaparece (limpeza do efeito).
// =========================================================================
import { createContext, use, useEffect, useState, type ReactNode } from 'react';
// o valor padrão: uma data congelada, lida por um componente sem provider
const ClockContext = createContext<Date>(new Date());
export function ClockProvider({ period = 1000, children }: { period?: number; children: ReactNode }) {
const [now, setNow] = useState(() => new Date());
// [period]: se o pai muda o período, o timer é reiniciado
useEffect(() => {
const timer = setInterval(() => setNow(new Date()), period);
return () => clearInterval(timer);
}, [period]);
return <ClockContext value={now}>{children}</ClockContext>;
}
export function useClock(): Date {
return use(ClockContext);
}
|
- linha 13: aqui, um verdadeiro valor padrão: uma data fixa;
- linha 15: o período de atualização é uma prop do provider;
- linhas 19–22: o timer; se o pai mudar o período, o efeito é limpo e depois reiniciado.
3.5.4. Os componentes
| // 14-contexts/src/Catalog.tsx - um descendente que ADICIONA ao carrinho
import { useCart, type Item } from './contexts/cart';
const CATALOG: Item[] = [
{ label: 'Consultation', price: 30 },
{ label: 'Vaccine', price: 12.5 },
{ label: 'Certificate', price: 5 },
];
export default function Catalog() {
// o carrinho fornecido por App (erro se ninguém o fornecer)
const cart = useCart();
return (
<ul className="list-group">
{CATALOG.map((a) => (
<li key={a.label} className="list-group-item d-flex justify-content-between align-items-center">
{a.label} (€{a.price})
<button className="btn btn-sm btn-outline-primary" onClick={() => cart.add(a)}>Add</button>
</li>
))}
</ul>
);
}
|
[useCart()]: o carrinho de compras fornecido por um pai (erro se nenhum pai o fornecer).
| // =========================================================================
// 14-contexts/src/CartSummary.tsx
// -------------------------------------------------------------------------
// Outro descendente: o MESMO carrinho de Catalog (fornecido por App), mas
// SEU PRÓPRIO relógio, atualizado a cada 5 segundos. Um componente só lê
// os providers colocados ACIMA dele: CartSummary, portanto, coloca
// um segundo <ClockProvider> em volta de seu conteúdo, que ele confia a um
// pequeno componente, Content.
// =========================================================================
import { ClockProvider, useClock } from './contexts/clock';
import { useCart } from './contexts/cart';
function Content() {
const cart = useCart();
const now = useClock(); // o relógio mais próximo: o de 5 s
return (
<div className="card p-3">
<h2 className="h6">
Cart ({cart.items.length} item(s)) - {now.toLocaleTimeString()}
</h2>
<ul className="mb-2">
{cart.items.map((a, i) => (
<li key={i}>
{a.label}{' '}
<button className="btn btn-link btn-sm p-0 align-baseline" onClick={() => cart.remove(i)}>remove</button>
</li>
))}
</ul>
<strong>Total: €{cart.total}</strong>
</div>
);
}
export default function CartSummary() {
return (
<ClockProvider period={5000}>
<Content />
</ClockProvider>
);
}
|
- linhas 14–34: o conteúdo do resumo lê o carrinho de compras E o relógio. O relógio mais próximo é o de 5 segundos;
- linhas 36–42: um componente lê apenas os providers colocados ACIMA dele: [CartSummary] coloca, portanto, seu próprio [<ClockProvider period={5000}>] em volta de um subcomponente, [Content].
| // =========================================================================
// 14-contexts/src/App.tsx - três níveis de contextos
// -------------------------------------------------------------------------
// - o log: fornecido bem no topo (main.tsx), para toda a aplicação;
// - o carrinho, fornecido por App: compartilhado por Catalog e CartSummary,
// que veem o MESMO carrinho;
// - o relógio, fornecido por App (período padrão, 1 s) E por
// CartSummary (5 s): cada um com o seu.
// =========================================================================
import Catalog from './Catalog';
import CartSummary from './CartSummary';
import { useLog } from './contexts/log';
import { ClockProvider, useClock } from './contexts/clock';
import { CartProvider } from './contexts/cart';
// a hora do relógio de App: um pequeno componente, colocado ABAIXO do provider
function AppTime() {
return <p className="text-muted">Clock of App: {useClock().toLocaleTimeString()}</p>;
}
export default function App() {
const log = useLog();
return (
<ClockProvider>
<CartProvider>
<div className="container py-4" style={{ maxWidth: 720 }}>
<h1 className="h3 mb-3">Example 14 - contexts</h1>
<AppTime />
<div className="row g-3">
<div className="col-md-6"><Catalog /></div>
<div className="col-md-6"><CartSummary /></div>
</div>
<h2 className="h6 mt-3">Log (root context)</h2>
<ul className="small">
{log.lines.map((line, i) => <li key={i}>{line}</li>)}
</ul>
</div>
</CartProvider>
</ClockProvider>
);
}
|
- linhas 18–20: [App] fornece o relógio; para lê-lo, é necessário um componente colocado ABAIXO dele: [AppTime];
- linha 23: [App] lê o log, fornecido acima;
- Linhas 26–27: [App] fornece o relógio (1 s) e o carrinho a seus descendentes.
E o provider do log, colocado no topo de tudo:
| // =========================================================================
// 14-contexts/src/main.tsx - o provider do log envolve App: ele
// fica, portanto, disponível em TODA a aplicação
// =========================================================================
import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App';
import { LogProvider } from './contexts/log';
createRoot(document.getElementById('root')!).render(
<StrictMode>
<LogProvider>
<App />
</LogProvider>
</StrictMode>,
);
|

O relógio do [App] avança a cada segundo, enquanto o relógio do carrinho de compras avança a cada cinco segundos. Os dois componentes enxergam o mesmo carrinho, e o log registra cada adição.
Um contexto é suficiente para dados que raramente mudam (o usuário logado, o idioma, um tema) ou que se aplicam apenas a parte da página. Quando um estado é compartilhado por toda a aplicação e muda com frequência, prefere-se um “store” (Exemplo 20).
3.6. Exemplo 15: Escrevendo seus próprios hooks
Um componente reutiliza a visão; um hook personalizado reutiliza um comportamento, junto com seu estado. É uma função cujo nome começa com [use] e que, por sua vez, chama hooks. Este exemplo escreve dois deles, para os dois comportamentos que o Exemplo 15 do curso [Angular] atribuía a diretivas.
3.6.1. Destacar um elemento ao passar o mouse
| // =========================================================================
// 15-custom-hooks/src/hooks/useHover.ts
// -------------------------------------------------------------------------
// Um HOOK PERSONALIZADO é uma função cujo nome começa com "use", e
// que ela mesma chama hooks (useState, useEffect, useRef...). Ele
// permite reutilizar um COMPORTAMENTO (com seu estado) em vários
// componentes, assim como um componente reutiliza a exibição.
//
// Este destaca um elemento sobre o qual o mouse passa. Ele retorna os atributos a colocar
// no elemento: <li {...useHover('#d1e7dd')}>. Cada chamada tem seu
// próprio estado: dois elementos destacados não interferem entre si.
// =========================================================================
import { useState } from 'react';
export function useHover(color = '#fff3cd') {
const [hovered, setHovered] = useState(false);
return {
style: { backgroundColor: hovered ? color : undefined, transition: 'background-color 0.2s' },
onMouseEnter: () => setHovered(true),
onMouseLeave: () => setHovered(false),
};
}
|
O hook tem seu próprio estado ([hovered]) e retorna os atributos a serem aplicados ao elemento: um estilo e dois tratadores de evento. Cada componente que o chama tem seu próprio estado: dois elementos destacados não interferem um no outro.
3.6.2. Clique longo
| // =========================================================================
// 15-custom-hooks/src/hooks/useLongPress.ts
// -------------------------------------------------------------------------
// const longPress = useLongPress(() => remove(m), 1000);
// <button {...longPress.handlers} className={longPress.pressing ? 'press' : ''}>
// A ação só é executada se o botão for mantido pressionado por um
// segundo: uma proteção contra cliques acidentais. pressing indica se um
// pressionamento está em andamento (para exibi-lo).
// O timer é parado se o componente desaparecer durante um pressionamento.
// =========================================================================
import { useEffect, useRef, useState } from 'react';
export function useLongPress(action: () => void, duration = 1000) {
const [pressing, setPressing] = useState(false);
// um valor que sobrevive às exibições SEM provocá-las: useRef
const timer = useRef<number | undefined>(undefined);
// quando o componente é removido: nenhum timer órfão
useEffect(() => () => clearTimeout(timer.current), []);
function start() {
setPressing(true);
timer.current = window.setTimeout(() => {
setPressing(false);
action();
}, duration);
}
function stop() {
clearTimeout(timer.current);
setPressing(false);
}
return {
pressing,
handlers: { onPointerDown: start, onPointerUp: stop, onPointerLeave: stop },
};
}
|
- linha 17: o identificador do timer — um valor que deve persistir entre as exibições, mas não é exibido — uma referência;
- linha 20: um efeito sem ação, que apenas faz a limpeza: se o componente desaparecer enquanto o botão estiver pressionado, o timer é interrompido;
- linhas 22–28: a ação só é executada se o botão for mantido pressionado por um segundo: uma proteção contra cliques acidentais;
- linhas 35–38: o hook retorna o estado ([pressing], para exibi-lo) e os tratadores de evento do ponteiro (mouse, dedo ou caneta).
3.6.3. Dar o foco
| // =========================================================================
// 15-custom-hooks/src/hooks/autofocus.ts - um "ref callback"
// -------------------------------------------------------------------------
// ref={function}: o React chama a função com o elemento HTML assim que ele
// é colocado na página (e, no React 19, chama a função que ela
// eventualmente retornar quando ele é removido). Não é um hook:
// é uma função simples, reutilizável em qualquer lugar:
// <input ref={autofocus} />
// (O React também trata o atributo autoFocus, que faz a mesma coisa.)
// =========================================================================
export function autofocus(element: HTMLElement | null): void {
element?.focus();
}
|
Uma ref callback: você pode atribuir uma função ao atributo [ref], que o [React] chama com o elemento HTML assim que ele é colocado na página. Isso não é um hook, mas uma simples função.
3.6.4. Uso
| // =========================================================================
// 15-custom-hooks/src/App.tsx - reutilizando comportamentos
// -------------------------------------------------------------------------
// Os hooks só são chamados no NÍVEL SUPERIOR de um componente (nunca em
// um laço, uma condição ou uma função aninhada): o React
// os reconhece pela ORDEM de chamada. Para um comportamento por linha de
// uma lista, escrevemos portanto um pequeno componente por linha, que chama seus hooks.
// =========================================================================
import { useState } from 'react';
import { useHover } from './hooks/useHover';
import { useLongPress } from './hooks/useLongPress';
import { autofocus } from './hooks/autofocus';
// o estilo do botão durante um pressionamento longo
const pressStyle = { outline: '4px solid #dc3545' };
// uma linha da lista: ela chama SEUS hooks
function DoctorRow({ name, even, onRemove }: { name: string; even: boolean; onRemove: () => void }) {
// uma linha em duas: a cor padrão; as demais, verde
const hover = useHover(even ? undefined : '#d1e7dd');
const longPress = useLongPress(onRemove, 1000);
return (
<li className="list-group-item d-flex justify-content-between align-items-center" {...hover}>
{name}
<button className="btn btn-sm btn-outline-danger" style={longPress.pressing ? pressStyle : undefined}
{...longPress.handlers}>
Delete (long press)
</button>
</li>
);
}
export default function App() {
const [doctors, setDoctors] = useState(['Mme Marie PELISSIER', 'Mr Paul TATOU', 'Melle Sophie DUPONT']);
const [message, setMessage] = useState('');
function remove(name: string) {
setDoctors((m) => m.filter((x) => x !== name));
setMessage(`${name} has been deleted.`);
}
return (
<div className="container py-4" style={{ maxWidth: 640 }}>
<h1 className="h3 mb-3">Example 15 - writing your own hooks</h1>
<input ref={autofocus} className="form-control mb-3" placeholder="this field received the focus on its own" />
<p className="small text-muted">Hover over the rows; hold a button down for one second to delete.</p>
<ul className="list-group mb-3">
{doctors.map((m, i) => (
<DoctorRow key={m} name={m} even={i % 2 === 0} onRemove={() => remove(m)} />
))}
</ul>
{message && <p className="alert alert-info">{message}</p>}
</div>
);
}
|
Os hooks seguem uma regra estrita: eles só são chamados no nível superior de um componente ou de outro hook, nunca dentro de um laço, de uma condição ou de uma função aninhada. O [React] identifica cada [useState] por sua ordem de chamada: se a ordem mudasse de uma exibição para outra, os estados se misturariam.
- Linhas 19–33: para um comportamento linha a linha em uma lista, não é possível chamar os hooks diretamente dentro de [map]; em vez disso, escreva um pequeno componente para cada linha, que chama SEUS hooks;
- Linha 25: os atributos do tooltip, espalhados pela linha;
- linha 28: os tratadores de clique longo do botão e seu estilo enquanto pressionado;
- linha 47: a referência de callback;
- Linha 52: uma linha por médico.
Na inicialização, o campo tem o foco. Mantendo pressionado o segundo botão:

Depois, quando um segundo tiver transcorrido:

Os hooks personalizados são a principal forma de reutilizar código no [React]. As bibliotecas fornecem muitos deles: [useForm] (exemplo 08), [useNavigate] (exemplo 17), [useTranslation] (exemplo 21), [useQuery] (exemplo 24)...
3.7. Exemplo 16: uma janela de confirmação reutilizável
“Tem certeza?”: [window.confirm()] existe, mas seus botões não podem ser formatados nem traduzidos. Ele é substituído por uma janela [Bootstrap] controlada por um contexto.
3.7.1. O contexto
| // =========================================================================
// 16-confirmation/src/confirmation/confirmation.tsx
// -------------------------------------------------------------------------
// "Tem certeza?": window.confirm() existe, mas não pode nem ser
// estilizado, nem ter seus botões traduzidos. Ele é substituído por um
// diálogo do Bootstrap, controlado por um contexto (cf. exemplo 14).
//
// O truque: confirm(message) retorna uma PROMISE, resolvida com true (Sim)
// ou false (Não) quando o usuário responde. O código chamador é então escrito
// tão simplesmente quanto com window.confirm:
//
// const confirm = useConfirmation();
// if (await confirm('Delete this doctor?')) { ... }
//
// O provider exibe o próprio diálogo: ele só precisa ser colocado
// uma vez, em volta de toda a aplicação (cf. main.tsx).
// =========================================================================
import { createContext, use, useCallback, useRef, useState, type ReactNode } from 'react';
import ConfirmDialog from './ConfirmDialog';
type Confirm = (message: string) => Promise<boolean>;
const ConfirmationContext = createContext<Confirm | null>(null);
export function ConfirmationProvider({ children }: { children: ReactNode }) {
const [message, setMessage] = useState<string | null>(null); // null: diálogo fechado
// a função que resolverá a promise atual: ela não é exibida,
// é portanto uma referência e não um estado
const answer = useRef<((yes: boolean) => void) | null>(null);
const confirm = useCallback<Confirm>((text) => {
answer.current?.(false); // uma pergunta ainda em aberto? isso significa "não"
setMessage(text);
return new Promise<boolean>((resolve) => {
answer.current = resolve;
});
}, []);
function respond(yes: boolean) {
setMessage(null);
const r = answer.current;
answer.current = null;
r?.(yes);
}
return (
<ConfirmationContext value={confirm}>
{children}
{message !== null && <ConfirmDialog message={message} onAnswer={respond} />}
</ConfirmationContext>
);
}
export function useConfirmation(): Confirm {
const confirm = use(ConfirmationContext);
if (confirm === null) {
throw new Error('useConfirmation must be used inside a <ConfirmationProvider>');
}
return confirm;
}
|
Dica: [confirm(message)] retorna uma promise, que é resolvida com [true] (Sim) ou [false] (Não) quando o usuário responde. O código chamador fica então tão simples quanto com [window.confirm]: [if (await confirm('Delete this doctor?')) {...}].
- Linha 22: o que o contexto fornece: uma função;
- linha 27: a mensagem exibida; [null]: a janela está fechada;
- linha 30: a função que resolverá a promise atual. Ela não é exibida: é uma referência, não um estado;
- Linhas 32–38: abrem a janela e retornam uma promise cuja função é mantida em [resolve]. Uma pergunta sem resposta é tratada como “não”;
- linhas 40–45: a resposta: fecha a janela e resolve a promise;
- linha 50: o provider exibe a própria janela quando há uma pergunta.
3.7.2. A janela
| // =========================================================================
// 16-confirmation/src/confirmation/ConfirmDialog.tsx
// -------------------------------------------------------------------------
// O diálogo modal:
// - mesmas classes do Bootstrap de um modal de verdade (.modal, .modal-backdrop),
// exibido "fixo no código" (show d-block): sem necessidade do
// JavaScript do Bootstrap;
// - createPortal: o diálogo é colocado no final de <body>, e não onde o
// componente está escrito. Assim ele escapa dos estilos de seus
// ancestrais (overflow, z-index...), continuando a ser um componente
// React comum (props, eventos);
// - teclado: Escape = Não; o foco é colocado no botão "Não" (a escolha
// menos perigosa) ao abrir.
// =========================================================================
import { useEffect } from 'react';
import { createPortal } from 'react-dom';
interface Props {
message: string;
onAnswer: (yes: boolean) => void;
}
export default function ConfirmDialog({ message, onAnswer }: Props) {
// Escape, em qualquer lugar da página: um listener colocado no DOCUMENT
// ao abrir, removido ao fechar (limpeza do efeito)
useEffect(() => {
const onKeydown = (e: KeyboardEvent) => {
if (e.key === 'Escape') onAnswer(false);
};
document.addEventListener('keydown', onKeydown);
return () => document.removeEventListener('keydown', onKeydown);
}, [onAnswer]);
return createPortal(
<>
<div className="modal-backdrop fade show"></div>
{/* um clique no fundo (e não no diálogo) significa "não" */}
<div className="modal fade show d-block" tabIndex={-1} role="alertdialog" aria-modal="true"
onClick={(e) => e.target === e.currentTarget && onAnswer(false)}>
<div className="modal-dialog modal-dialog-centered">
<div className="modal-content">
<div className="modal-header">
<h5 className="modal-title">Confirmation</h5>
<button type="button" className="btn-close" aria-label="Close" onClick={() => onAnswer(false)}></button>
</div>
<div className="modal-body">
<p className="mb-0">{message}</p>
</div>
<div className="modal-footer">
{/* autoFocus: o React dá o foco a este botão quando ele aparece */}
<button type="button" className="btn btn-secondary" autoFocus onClick={() => onAnswer(false)}>No, go back</button>
<button type="button" className="btn btn-danger" onClick={() => onAnswer(true)}>Yes, confirm</button>
</div>
</div>
</div>
</div>
</>,
document.body,
);
}
|
- linhas 27–33: a tecla Esc, em qualquer lugar da página: um listener anexado a DOCUMENT quando a janela abre e removido quando ela fecha (limpeza). Essa é tipicamente a função de um efeito: conectar-se a algo externo ao [React];
- linha 35: [createPortal(jsx, element)] exibe JSX em um lugar diferente de onde o componente é escrito: aqui, no final de [<body>]. A janela escapa assim dos estilos de seus ancestrais ([overflow], [z-index]...), continuando a ser um componente [React] comum (props, eventos);
- linhas 37–39: as classes [Bootstrap] de uma verdadeira janela modal, escritas diretamente ([show d-block]): não há necessidade do [JavaScript] do [Bootstrap];
- linha 40: um clique no fundo (fora da janela) conta como “Não”;
- linha 52: [React] dá o foco ao botão “Não” — a escolha mais segura — quando a janela aparece.
3.7.3. Uso
| // =========================================================================
// 16-confirmation/src/App.tsx - usando o diálogo de confirmação
// -------------------------------------------------------------------------
// Mesma página do exemplo 21 do curso de NestJS (links, botões, confirmação),
// mas sem nenhuma ida e volta a um servidor.
// =========================================================================
import { useState } from 'react';
import { useConfirmation } from './confirmation/confirmation';
interface Contact {
id: number;
name: string;
}
export default function App() {
const confirm = useConfirmation();
const [contacts, setContacts] = useState<Contact[]>([
{ id: 1, name: 'Jean MARTIN' },
{ id: 2, name: 'Alice DURAND' },
{ id: 3, name: 'Luc GERMAN' },
]);
const [message, setMessage] = useState('');
// uma função async: ela "espera" a resposta do usuário
async function remove(c: Contact) {
if (!(await confirm(`Delete the contact ${c.name}?`))) {
setMessage('Deletion cancelled.');
return;
}
setContacts((list) => list.filter((x) => x.id !== c.id));
setMessage(`${c.name} has been deleted.`);
}
async function removeAll() {
if (await confirm(`Delete the ${contacts.length} contacts?`)) {
setContacts([]);
setMessage('All the contacts have been deleted.');
}
}
return (
<div className="container py-4" style={{ maxWidth: 640 }}>
<h1 className="h3 mb-3">Example 16 - a confirmation dialog</h1>
<ul className="list-group mb-3">
{contacts.map((c) => (
<li key={c.id} className="list-group-item d-flex justify-content-between align-items-center">
{c.name}
<button className="btn btn-sm btn-outline-danger" onClick={() => remove(c)}>Delete</button>
</li>
))}
{contacts.length === 0 && <li className="list-group-item text-muted">No contacts.</li>}
</ul>
<button className="btn btn-danger" disabled={contacts.length === 0} onClick={removeAll}>Delete all</button>
{message && <p className="alert alert-info mt-3">{message}</p>}
</div>
);
}
|
- linha 17: a função de confirmação;
- linhas 26–33: uma função [async]: ela “espera” ([await]) a resposta do usuário sem bloquear a página.
| import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App';
import { ConfirmationProvider } from './confirmation/confirmation';
// o diálogo de confirmação, UMA vez para toda a aplicação
createRoot(document.getElementById('root')!).render(
<StrictMode>
<ConfirmationProvider>
<App />
</ConfirmationProvider>
</StrictMode>,
);
|
UMA ÚNICA janela é usada para toda a aplicação: seu provider envolve [App].

Confirme, depois solicite outra exclusão e pressione Esc:
