3. Komponenten
3.1. Beispiel 10: Komponenten und ihre Props
Eine Komponente ist ein wiederverwendbarer Teil der Benutzeroberfläche. Dieses Beispiel erstellt eine solche Komponente, [DoctorCard], und verwendet sie mehrfach.
3.1.1. Datentyp
| // der Typ der Daten, die vom Elternteil (App) und vom Kind (DoctorCard) gemeinsam genutzt werden
export interface Doctor {
id: number;
title: string;
firstName: string;
lastName: string;
specialty: string;
available: boolean;
}
|
Der Typ [Doctor] wird von der Eltern- und der Kindkomponente gemeinsam genutzt: Er liegt daher in einem eigenen Modul.
3.1.2. Die Kindkomponente
| // =========================================================================
// 10-components/src/DoctorCard.tsx - eine KIND-Komponente
// -------------------------------------------------------------------------
// Sie erhält ihre Daten von ihrem Elternteil über PROPS (Eigenschaften): die
// Attribute, die der Elternteil auf <DoctorCard ... /> schreibt und die React
// in EINEM Objekt bündelt, dem ersten Parameter der Funktion. Ihr Typ wird
// zur Kompilierzeit geprüft: <DoctorCard doctor={42} /> würde abgelehnt.
//
// Goldene Regel: Eine Komponente ändert ihre Props NIEMALS. Die Daten
// fließen vom Elternteil zum Kind; um eine Änderung anzufordern,
// ruft das Kind eine Funktion auf, die der Elternteil ihm übergeben hat (vgl. Beispiel 11).
// =========================================================================
import type { Doctor } from './doctor';
// styles: ein Objekt { initials: '_initials_x7f3a_1' } - der tatsächliche Name jeder Klasse
import styles from './DoctorCard.module.css';
// der Typ der Props: was der Elternteil liefern KANN (?) oder MUSS
interface Props {
doctor: Doctor;
rank: number;
compact?: boolean; // optional
}
// das Props-Objekt wird „destrukturiert“; compact = false: sein Standardwert
export default function DoctorCard({ doctor, rank, compact = false }: Props) {
// ein aus den Props berechneter Wert: wird neu berechnet, wenn der Elternteil sie ändert
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>
);
}
|
- Zeile 14: ein reiner Typ-Import;
- Zeile 16: ein Import des CSS-Moduls (siehe unten);
- Zeilen 19–23: die Typen der Props der Komponente – der Attribute, die die Elternkomponente in [<DoctorCard ... />] schreibt. [compact?] ist optional;
- Zeile 26: [React] fasst die Props zu EINEM Objekt zusammen, das es der Funktion als ersten Parameter übergibt. Dieses wird sofort „entpackt“: [{ doctor, rank, compact = false }] ergibt drei Variablen, wobei [compact] den Wert [false] hat, wenn die Elternkomponente es nicht angibt. Der Typ der Props wird zur Kompilierzeit geprüft: [<DoctorCard doctor={42} />] würde abgelehnt, ebenso das Weglassen von [rank];
- Zeile 28: ein aus den Props berechneter Wert: Ändert die Elternkomponente die Props, wird die Komponente erneut aufgerufen und der Wert neu berechnet;
- Zeile 33: die CSS-Klasse, gelesen aus dem CSS-Modul;
- Zeile 36: Die Fachrichtung wird nur im normalen Modus angezeigt.
Goldene Regel: Eine Komponente ändert niemals ihre eigenen Props. Die Daten fließen von der Eltern- zur Kindkomponente; um eine Änderung anzufordern, ruft die Kindkomponente eine Funktion auf, die ihr die Elternkomponente übergeben hat (siehe Beispiel 11).
3.1.3. Ein CSS-Modul
| /* ein „CSS-Modul“ (Datei *.module.css): Vite benennt jede Klasse um
(.initials -> ._initials_x7f3a_1); sie kann daher nur auf die
Elemente der Komponente wirken, die es importiert */
.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;
}
|
Eine Datei, deren Name auf [.module.css] endet, ist ein CSS-Modul: [Vite] benennt jede ihrer Klassen um ([.initials] wird zum Beispiel zu [._initials_x7f3a_1]) und stellt beim Import ein Objekt bereit, das den ursprünglichen Namen dem tatsächlichen Namen zuordnet: [styles.initials]. Die Klasse kann somit nur auf Elemente der Komponente angewendet werden, die das Modul importiert: Das entspricht der Style-Kapselung in [Angular]. Die Klassen von [Bootstrap], die global sind, bleiben überall verwendbar.
3.1.4. Die Elternkomponente
| // =========================================================================
// 10-components/src/App.tsx - die ELTERN-Komponente
// -------------------------------------------------------------------------
// Sie importiert die Komponente DoctorCard und verwendet sie als neues
// Tag, <DoctorCard />, so oft wie nötig: Eine Komponente ist
// ein WIEDERVERWENDBARES Stück Oberfläche mit eigenen Daten, eigenem JSX und
// eigenem Stil. Ein Tag, das mit einem GROSSBUCHSTABEN beginnt, ist eine Komponente;
// in Kleinbuchstaben (<div>, <p>) ist es ein HTML-Element.
// =========================================================================
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);
// der Elternteil ändert SEINE Daten: React ruft den Elternteil erneut auf, dann die
// Kinder, mit ihren neuen 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} übergibt das OBJEKT m (einen Ausdruck);
doctor="m" ohne geschweifte Klammern würde die ZEICHENKETTE "m" übergeben */}
<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 ohne Wert ist true */}
<DoctorCard doctor={doctors[0]} rank={1} compact />
</div>
</div>
);
}
|
- Zeile 12: Die Kindkomponente wird wie jedes andere Modul importiert;
- Zeilen 25–27: Die Elternkomponente ändert IHRE Daten. [React] rendert sie neu und rendert dann die Kindkomponenten mit ihren neuen Props neu: Die Karten werden aktualisiert;
- Zeile 44: Die Komponente wird als neues Tag verwendet. [doctor={m}] übergibt das OBJEKT [m] (ein Ausdruck); [doctor="m"] würde ohne geschweifte Klammern die ZEICHENKETTE „m“ übergeben;
- Zeile 51: Ein Attribut ohne Wert ([compact]) entspricht [true].

Wenn Sie „Kompaktansicht“ anhaken und anschließend die Verfügbarkeiten umkehren:

3.2. Beispiel 11: Die Kindkomponente benachrichtigt ihre Elternkomponente
Die Daten fließen über die Props nach unten. Um Informationen nach oben zurückzusenden, übergibt die Elternkomponente der Kindkomponente Funktionen, die diese dann aufruft.
3.2.1. „Ereignisse“ der Kindkomponente
| // =========================================================================
// 11-lifting-state-up/src/Counter.tsx
// -------------------------------------------------------------------------
// Ein Kind, das seinen Elternteil BENACHRICHTIGT: Der Elternteil übergibt ihm FUNKTIONEN
// in seinen Props (ihr Name beginnt per Konvention mit „on“), und das Kind
// ruft sie auf, wenn etwas geschieht:
// <Counter label="Coffees" max={3} onIncrement={...} onLimit={...} />
// =========================================================================
import { useState } from 'react';
interface Props {
label: string;
max: number;
onIncrement: (value: number) => void; // mit dem neuen Wert
onLimit: () => void; // ohne Daten
}
export default function Counter({ label, max, onIncrement, onLimit }: Props) {
// der EIGENE Zustand dieses Zählers: Jeder <Counter> hat seinen eigenen
const [value, setValue] = useState(0);
function plus() {
if (value >= max) {
onLimit();
return;
}
setValue(value + 1);
// value ist noch nicht geändert (das geschieht beim nächsten Aufruf der
// Komponente): value + 1 wird übergeben
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>
);
}
|
- Zeilen 12–17: Zwei Props sind Funktionen: [onIncrement] erhält den neuen Wert, während [onLimit] nichts erhält. Ihre Namen beginnen per Konvention mit „on“, wie bei [onClick];
- Zeile 21: der EIGENE Zustand dieses Zählers: Jeder [<Counter>] auf der Seite hat seinen eigenen. Der Zustand ist an die Position der Komponente im Seitenbaum gebunden;
- Zeilen 23–32: Die Elternkomponente wird benachrichtigt. Achtung: [setValue(value + 1)] ändert die Variable [value] nicht (eine Konstante, die für DIESEN Aufruf der Komponente festgelegt ist): Sie lautet beim NÄCHSTEN Aufruf [value + 1]. Daher wird [value + 1] an die Elternkomponente übergeben.
3.2.2. Eine kontrollierte Komponente
| // =========================================================================
// 11-lifting-state-up/src/TextField.tsx - eine KONTROLLIERTE Komponente
// -------------------------------------------------------------------------
// Ein „selbstgebautes“ Formularfeld (Label + Feld + Hilfe +
// Zeichenzähler), das wie ein kontrolliertes <input> verwendet wird (vgl. Beispiel 05):
// <TextField value={lastName} onChange={setLastName} label="Last name" max={20} />
// Die Komponente hat KEINEN Zustand: Der Wert gehört dem Elternteil, der
// ihn übergibt (value) und den sie über jeden Tastenanschlag benachrichtigt (onChange). Es ist
// der Elternteil, der über den neuen Wert entscheidet.
// =========================================================================
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: ein EINDEUTIGER Bezeichner, verschieden für jedes <TextField> der
// Seite, um <label htmlFor> und <input id> zu verknüpfen
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>
);
}
|
Ein „benutzerdefiniertes“ Formularfeld (Label, Feld, Tooltip, Zeichenzähler), das als kontrolliertes [<input>] verwendet wird (siehe Beispiel 05): Die Elternkomponente übergibt ihm den Wert ([value]) und eine Funktion, die bei jedem Tastenanschlag aufgerufen wird ([onChange]).
- Zeilen 14–20: die Props; [help] ist optional;
- Zeile 25: [useId()] liefert einen eindeutigen Bezeichner, der für jedes [<TextField>] auf der Seite verschieden ist, um [<label htmlFor>] und [<input id>] zu verknüpfen;
- Zeile 31: Jeder Tastenanschlag ruft die Funktion der Elternkomponente mit dem neuen Text auf.
Die Komponente hat keinen Zustand: Der Wert gehört der Elternkomponente, die den neuen Wert festlegt. Man spricht von „Lifting State Up“: Daten, die von mehreren Komponenten gemeinsam genutzt werden, liegen in ihrem nächsten gemeinsamen Vorfahren.
3.2.3. Die Elternkomponente
| // =========================================================================
// 11-lifting-state-up/src/App.tsx - der Elternteil hört auf seine Kinder
// -------------------------------------------------------------------------
// Daten fließen nach unten (Props); Informationen fließen über
// in den Props übergebene Funktionen nach oben:
// 1. „Ereignisse“ des Kindes: onIncrement, onLimit;
// 2. eine kontrollierte Komponente: value + onChange, wie ein <input>. Der Zustand
// bleibt Eigentum des Elternteils, der ihn selbst ändern kann (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');
// die von einem Zähler aufgerufene Funktion: Sie erhält den Wert, den er übergibt
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}: die Funktion des Zustands, unverändert übergeben */}
<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>
);
}
|
- Zeilen 22–25: die Funktion, die von einem Zähler aufgerufen wird; sie erhält den Wert, den der Zähler ihr übergibt;
- Zeilen 38–39: Die Elternkomponente übergibt Pfeilfunktionen, die das Label des Zählers ergänzen;
- Zeile 48: [onChange={setFirstName}]: Die Zustandsfunktion wird unverändert übergeben; die Kindkomponente ruft sie mit dem neuen Text auf;
- Zeile 51: Die Elternkomponente ändert die Werte selbst; die Felder folgen.
Klicken Sie zweimal, dann viermal auf das erste „+1“, einmal auf das zweite und geben Sie „Dupont“ in das Feld „Nachname“ ein:

3.3. Beispiel 12: Komposition
Props übergeben Daten ... aber auch Inhalt: „JSX“ ist ein Wert wie jeder andere (etwa „[ReactNode]“), der einer Komponente übergeben werden kann, und die Komponente kann ihn platzieren, wo sie will.
3.3.1. Eine Karte
| // =========================================================================
// 12-composition/src/Card.tsx - ein wiederverwendbares TEMPLATE
// -------------------------------------------------------------------------
// Props übergeben DATEN... aber auch INHALT: JSX ist
// ein Wert wie jeder andere (vom Typ ReactNode), der an eine
// Komponente übergeben werden kann und den sie platziert, wo sie will:
// - children: die besondere Prop, die erhält, was der Elternteil ZWISCHEN
// <Card> und </Card> schreibt - den „Haupt“-Inhalt;
// - header, footer: weitere Platzhalter, die der Elternteil in Form
// von Props liefert; header hat einen Standardinhalt.
// Die Karte legt den Rahmen fest (Rand, Kopfbereich, Fußbereich), der Elternteil liefert, was
// darin steht. Es ist das clientseitige Gegenstück zum Template layout.hbs
// und seinem {{{body}}} im NestJS-Kurs.
// =========================================================================
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>
{/* kein Footer angegeben: überhaupt kein Footer */}
{footer && <div className="card-footer text-muted small">{footer}</div>}
</div>
);
}
|
- Zeilen 18–23: [header], [footer] und [children] sind [ReactNode]: JSX, Text, eine Zahl oder nichts;
- Zeile 25: Standardinhalt;
- Zeile 29: [children] ist eine besondere Property: Sie erhält alles, was die Elternkomponente ZWISCHEN [<Card>] und [</Card>] schreibt – den „Haupt“-Inhalt;
- Zeile 31: kein Footer angegeben – also überhaupt kein Footer.
Das Template legt den Rahmen fest (Rand, Header, Footer); die Elternkomponente liefert den Inhalt darin: Das entspricht der Inhaltsprojektion von [Angular] ([<ng-content>]) und den „Slots“ von [Vue.js] sowie, serverseitig, dem Template [layout.hbs] und seinem [{{{body}}}] im Kurs [NestJS].
3.3.2. Eine generische Tabelle
| // =========================================================================
// 12-composition/src/DataTable.tsx - eine GENERISCHE Tabelle
// -------------------------------------------------------------------------
// DataTable<T> ist eine generische Komponente: Sie zeigt Zeilen
// beliebigen Typs T an. Sie weiß, wie man die Zeilen durchläuft, aber nicht, wie man
// EINE Zeile anzeigt: Das sagt ihr der Elternteil, indem er ihr eine
// FUNKTION übergibt, renderRow(row, index), die das JSX der Zellen liefert.
// Das nennt man eine „Render Prop“: Der vom
// Elternteil gelieferte Inhalt verwendet Daten, die dem Kind gehören (die Zeile, ihr
// Rang).
// =========================================================================
import type { ReactNode } from 'react';
interface Props<T> {
rows: T[];
columns: string[];
renderRow: (row: T, index: number) => ReactNode;
empty?: ReactNode; // angezeigt, wenn es keine Zeile gibt
}
// <T extends { id: number }>: jede Zeile muss eine id haben (den 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>
);
}
|
- Zeilen 15–20: ein generischer Typ: die Props einer Tabelle mit Zeilen vom Typ [T], welcher auch immer;
- Zeile 18: eine Prop, die eine Funktion ist, die JSX zurückgibt: Die Tabelle weiß, wie sie die Zeilen durchläuft, aber nicht, wie EINE Zeile darzustellen ist; die Elternkomponente sagt es ihr. Dieses Vorgehen nennt man „Render Prop“;
- Zeile 23: eine generische Komponente: [T] wird zur Laufzeit aus dem Typ der Zeilen abgeleitet. Jede Zeile muss eine [id] haben, die als Schlüssel dient;
- Zeile 37: Für jede Zeile ruft die Tabelle die Funktion der Elternkomponente auf und übergibt ihr die Daten, die zu dieser Zeile gehören (die Zeile, ihren Index).
3.3.3. Die Elternkomponente
| // =========================================================================
// 12-composition/src/App.tsx - die Templates Card und DataTable verwenden
// =========================================================================
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 und footer: in Props übergebenes JSX; zwischen den Tags: children */}
<Card color="primary" header={<span>Schedule of Mme PELISSIER</span>} footer={`${free} free slot(s)`}>
{/* DataTable<Slot>: T wird aus dem Typ der Zeilen abgeleitet */}
<DataTable
rows={slots}
columns={['#', 'Slot', 'Status']}
// die „Render Prop“: wie EINE Zeile angezeigt wird; c erhält die Zeile, i ihren Rang
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>
{/* kein Header angegeben: der Standardinhalt, "Untitled" */}
<Card>
<DataTable<{ id: number; name: string }>
rows={[]}
columns={['Name']}
renderRow={(p) => <td>{p.name}</td>}
empty={<span>Nobody for now.</span>}
/>
</Card>
</div>
);
}
|
- Zeile 28: [header] und [footer] erhalten JSX oder Text; die zwischen den Tags geschriebene [<DataTable>] wird zu den [children] der Karte;
- Zeilen 34–43: die Render Prop: wie EINE Zeile darzustellen ist; [c] erhält die Zeile (vom Typ [Slot], abgeleitet aus [rows]) mit [i] als ihrem Rang;
- Zeile 56: Bei einer leeren Liste kann [TypeScript] [T] nicht ableiten: Es wird explizit angegeben;
- Zeile 60: der Inhalt, der angezeigt wird, wenn es keine Zeilen gibt.

3.4. Beispiel 13: Der Lebenszyklus einer Komponente
3.4.1. Eine Uhr
| // =========================================================================
// 13-lifecycle/src/Clock.tsx - eine Komponente, die startet und stoppt
// -------------------------------------------------------------------------
// Das Leben einer Komponente:
// 1. Sie wird ANGEZEIGT (gemountet): React ruft die Funktion auf und platziert ihr
// Ergebnis in der Seite; dann führt es ihre Effekte aus (useEffect);
// 2. Sie wird AKTUALISIERT, so oft wie nötig (ihr Zustand oder ihre
// Props ändern sich);
// 3. Sie wird aus der Seite ENTFERNT (unmountet): React führt das AUFRÄUMEN
// (Cleanup) ihrer Effekte aus, die Funktion, die jeder Effekt zurückgegeben hat.
// Eine Uhr startet einen Timer (setInterval), wenn sie erscheint... und
// muss ihn unbedingt stoppen, wenn sie verschwindet: Sonst
// würde der Timer nutzlos weiterlaufen (Speicherleck).
// =========================================================================
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: eine Funktion, die VON einem Effekt aufgerufen wird und stets
// die aktuellsten Props liest, ohne eine Abhängigkeit des Effekts zu sein. Ohne
// sie müsste onLog unten in die Abhängigkeiten [...] aufgenommen werden,
// und da der Elternteil bei jeder Anzeige eine NEUE Funktion übergibt, würde der
// Timer jede Sekunde gestoppt und neu gestartet
const log = useEffectEvent((message: string) => onLog(message));
// []: keine Abhängigkeit. Der Effekt läuft EINMAL, nach der ersten
// Anzeige; die Funktion, die er zurückgibt, EINMAL, wenn die Komponente entfernt wird
useEffect(() => {
log('Clock: effect - starting the timer');
const timer = setInterval(() => setTime(new Date().toLocaleTimeString()), 1000);
// das AUFRÄUMEN (Cleanup)
return () => {
clearInterval(timer);
log('Clock: cleanup - timer stopped');
};
}, []);
return <div className="display-6 font-monospace">{time}</div>;
}
|
Der Lebenszyklus einer Komponente (Zeilen 4–10): Sie wird gemountet (zum ersten Mal angezeigt), aktualisiert so oft wie nötig und schließlich unmountet (von der Seite entfernt). [React] kennt keine eigenen Methoden für die einzelnen Phasen: Alles läuft über [useEffect].
- Zeilen 34–42: [useEffect(effect, [])]: Bei einem LEEREN Abhängigkeits-Array wird der Effekt nur einmal ausgeführt, nach der ersten Anzeige. Die Funktion, die er zurückgibt (Zeilen 38–41), übernimmt die Bereinigung: [React] führt sie aus, wenn die Komponente von der Seite entfernt wird (und vor jeder erneuten Ausführung des Effekts, wenn sich seine Abhängigkeiten ändern). Eine Uhr startet beim Start einen Timer ([setInterval]) ... und muss ihn beenden ([clearInterval]), wenn sie verschwindet: Andernfalls würde der Timer grundlos weiterlaufen und versuchen, den Zustand einer Komponente zu ändern, die nicht mehr existiert;
- Zeile 30: Der Effekt ruft die Funktion [onLog] der Elternkomponente auf. Streng genommen müsste er sie in seine Abhängigkeiten aufnehmen: Da der Effekt eine Prop verwendet, muss er erneut ausgelöst werden, wenn sich die Prop ändert. Die Elternkomponente erzeugt jedoch bei jeder Anzeige eine NEUE Funktion: Der Timer würde ständig gestoppt und neu gestartet. [useEffectEvent] ([React] 19.2) erzeugt eine Funktion, die immer die jeweils aktuellste Version von [onLog] aufruft, ohne eine Abhängigkeit des Effekts zu sein. Sie wird nur innerhalb eines Effekts aufgerufen.
3.4.2. Die Elternkomponente
| // =========================================================================
// 13-lifecycle/src/App.tsx
// -------------------------------------------------------------------------
// - {withClock && <Clock />}: Das Aktivieren / Deaktivieren des Kästchens zeigt die Komponente an /
// entfernt sie (Effekt, dann Cleanup, vgl. Clock.tsx);
// - useRef: eine Referenz auf das Element <input>, null, solange es nicht
// angezeigt wird; ein Effekt gibt ihm den Fokus, sobald es erscheint;
// - ein Effekt, der den Titel des Tabs mit der Eingabe SYNCHRONISIERT.
//
// In der Entwicklung mountet StrictMode (vgl. main.tsx) jede Komponente,
// unmountet sie und mountet sie sofort erneut: Das Log zeigt daher start,
// stop, start. Das ist beabsichtigt: Ein Effekt, dessen Cleanup schlecht geschrieben ist
// (ein nie gestoppter Timer), verrät sich sofort. In der Produktion wird die
// Komponente nur einmal gemountet.
// =========================================================================
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}`]);
}
// nach der ersten Anzeige von App (in der Entwicklung zweimal: StrictMode)
useEffect(() => {
trace('App: effect of the first display');
}, []);
// das Feld ist gerade erschienen: Es erhält den Fokus
useEffect(() => {
if (showSearch) {
field.current?.focus();
}
}, [showSearch]);
// der Titel des Tabs folgt der Eingabe, von Anfang an
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>
);
}
|
- Zeile 25: eine Referenz auf das Suchfeld, [null], solange es nicht angezeigt wird;
- Zeilen 32–34: der Effekt für die erste Anzeige von [App];
- Zeilen 37–41: Wenn das Feld erscheint, erhält es den Fokus: Der Effekt wird NACH der Anzeige ausgeführt, wenn das Element existiert und die Referenz auf es zeigt;
- Zeilen 44–46: ein Effekt, der den Titel des Tabs mit dem Zustand synchronisiert;
- Zeile 57: Das Anhaken/Abhaken des Kontrollkästchens blendet die Uhr ein/aus.
Beim Start ist das Protokoll überraschend: Die Uhr startet, stoppt und startet erneut, und der Effekt [App] wird zweimal ausgeführt. Das liegt am [<StrictMode>] (siehe [main.tsx]): nur in der Entwicklung mountet [React] jede Komponente, unmountet sie und mountet sie sofort wieder, um zu prüfen, dass ihre Effekte hinter sich aufräumen können. Ein schlecht geschriebener Effekt (etwa ein Timer, der nie stoppt) fällt so sofort auf: Die Uhr würde jeweils um zwei Sekunden vorrücken. In der Produktion wird die Komponente nur einmal gemountet. Außerdem fällt auf, dass die Effekte der Kindkomponenten (der Uhr) VOR denen der Elternkomponente ausgeführt werden.
Haken Sie das Kontrollkästchen anschließend ab und wieder an und geben Sie „Kinderarzt“ in das Suchfeld ein:

Effekte sind der heikelste Teil von [React]. Eine Regel leitet ihren Einsatz: Ein Effekt synchronisiert die Komponente mit etwas außerhalb von [React] (dem Tab-Titel, einem Timer, einem Ereignis-Listener des Dokuments, einem Server). Um einen Wert aus einem anderen zu berechnen, verwenden Sie eine Variable (Beispiel 02), keinen Effekt. Um auf eine Benutzeraktion zu reagieren, verwenden Sie einen Ereignishandler, keinen Effekt.
3.5. Beispiel 14: Kontexte
Wie lassen sich Daten und Funktionen zwischen weit voneinander entfernten Komponenten teilen, ohne sie über alle Zwischenstationen von Props zu Props durchzureichen? Mit einem Kontext. So teilt [React] das, was [Angular] in seinen Services ablegt, die per Dependency Injection bereitgestellt werden.
3.5.1. Ein Kontext für die gesamte Anwendung
| // =========================================================================
// 14-contexts/src/contexts/log.tsx - ein Kontext für die GESAMTE Anwendung
// -------------------------------------------------------------------------
// Wie teilt man Daten und Funktionen zwischen entfernten Komponenten,
// ohne sie von Props zu Props durch alle
// Zwischenstationen zu reichen? Mit einem KONTEXT:
// 1. createContext(defaultValue) erstellt den Kontext;
// 2. eine PROVIDER-Komponente, <LogContext value={...}>, gibt ihren
// Wert an ALLE ihre Nachkommen weiter, in beliebiger Tiefe;
// 3. ein Nachkomme LIEST ihn mit use(LogContext) (oder useContext).
// Wenn sich der bereitgestellte Wert ändert, werden alle Komponenten, die ihn lesen,
// erneut aufgerufen.
//
// Die Konvention: eine Datei pro Kontext, die den Provider (eine
// Komponente, die den Zustand hält) und einen HOOK zum Lesen (useLog) exportiert.
// So teilt React, was Angular in seinen Services ablegt.
// =========================================================================
import { createContext, use, useCallback, useMemo, useState, type ReactNode } from 'react';
interface Log {
lines: string[];
trace: (message: string) => void;
}
// null: der gelesene Wert, wenn KEIN Provider die Komponente umschließt
const LogContext = createContext<Log | null>(null);
// der Provider: Er hält den Zustand und stellt ihn seinen Nachkommen bereit
export function LogProvider({ children }: { children: ReactNode }) {
const [lines, setLines] = useState<string[]>([]);
// useCallback: dieselbe Funktion von einer Anzeige zur nächsten (und nicht
// jedes Mal eine neue), damit die Komponenten, die sie erhalten,
// nicht verändert erscheinen
const trace = useCallback((message: string) => {
setLines((l) => [`${new Date().toLocaleTimeString()} ${message}`, ...l].slice(0, 6));
}, []);
// useMemo: nur dann ein neues Objekt, wenn sich lines geändert hat
const value = useMemo(() => ({ lines, trace }), [lines, trace]);
// React 19: der Kontext selbst ist die Provider-Komponente
return <LogContext value={value}>{children}</LogContext>;
}
// der Lese-Hook: ein Name, der mit „use“ beginnt
export function useLog(): Log {
// use(context): der Wert des NÄCHSTGELEGENEN Providers
const log = use(LogContext);
if (log === null) {
throw new Error('useLog must be used inside a <LogProvider>');
}
return log;
}
|
- Zeilen 21–24: was der Kontext bereitstellt: Daten und eine Funktion;
- Zeile 27: [createContext(defaultValue)] erzeugt den Kontext. [null]: der Wert, den eine Komponente liest, die von keinem Provider umschlossen wird;
- Zeilen 30–45: der Provider: eine Komponente, die den Zustand enthält und ihn an alle ihre Nachkommen weitergibt, in beliebiger Tiefe:
- Zeile 36: [useCallback(fn, [dependencies])] übergibt von einer Anzeige zur nächsten DIESELBE Funktion (solange sich die Abhängigkeiten nicht ändern), statt eine neue zu erzeugen. Hier gibt es keine Abhängigkeiten: [setLines] ändert sich nie;
- Zeile 41: Das bereitgestellte Objekt wird nur neu erzeugt, wenn sich [lines] geändert hat. Ohne diese Vorkehrungen würde der Provider bei jeder Anzeige ein neues Objekt liefern, und alle Komponenten, die den Kontext lesen, würden unnötig aufgerufen;
- Zeile 44: Ab [React] 19 ist der Kontext selbst die Provider-Komponente (früher schrieb man [<LogContext.Provider>]);
- Zeilen 48–55: ein Hook zum Lesen. [use(context)] ([React] 19; früher [useContext]) liefert den Wert des nächstgelegenen Providers. Der Hook prüft, ob es einen gibt: Ein klarer Fehler ist besser als ein unerwartetes [null].
3.5.2. Ein Kontext, der von einer Komponente bereitgestellt wird
| // =========================================================================
// 14-contexts/src/contexts/cart.tsx - ein von EINER Komponente bereitgestellter Kontext
// -------------------------------------------------------------------------
// Der Warenkorb wird nur einem Teil des Komponentenbaums bereitgestellt: den
// von <CartProvider> umschlossenen (vgl. App.tsx). Zwei Provider, die an
// zwei Stellen der Seite platziert sind, ergäben zwei unabhängige Warenkörbe.
// Ein Provider kann selbst andere Kontexte lesen: Der Warenkorb
// verwendet das 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;
}
|
Der Warenkorb wird nur einem Teil des Komponentenbaums bereitgestellt: den Komponenten, die von [<CartProvider>] umschlossen werden. Zwei an verschiedenen Stellen der Seite platzierte Provider ergäben zwei voneinander unabhängige Warenkörbe.
- Zeile 29: Ein Provider ist eine Komponente; er kann selbst andere Kontexte lesen; der Warenkorb verwendet das Protokoll;
- Zeilen 32–46: die Daten ([items], [total]) und die Aktionen ([add], [remove]), die neu berechnet werden, wenn sich die Artikel ändern.
3.5.3. Ein konfigurierter Kontext
| // =========================================================================
// 14-contexts/src/contexts/clock.tsx - ein PARAMETRISIERTER Kontext
// -------------------------------------------------------------------------
// Eine Uhr, deren Aktualisierungsintervall eine Prop des
// Providers ist: <ClockProvider period={5000}>. Bei zwei verschachtelten
// Providern liest eine Komponente den, der ihr am NÄCHSTEN liegt.
// Die Uhr stoppt, wenn ihr Provider verschwindet (Cleanup des Effekts).
// =========================================================================
import { createContext, use, useEffect, useState, type ReactNode } from 'react';
// der Standardwert: ein eingefrorenes Datum, gelesen von einer Komponente ohne Provider
const ClockContext = createContext<Date>(new Date());
export function ClockProvider({ period = 1000, children }: { period?: number; children: ReactNode }) {
const [now, setNow] = useState(() => new Date());
// [period]: Ändert der Elternteil das Intervall, wird der Timer neu gestartet
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);
}
|
- Zeile 13: hier ein echter Standardwert: ein festes Datum;
- Zeile 15: Die Aktualisierungsperiode ist eine Prop des Providers;
- Zeilen 19–22: der Timer; Ändert die Elternkomponente die Periode, wird der Effekt bereinigt und anschließend neu gestartet.
3.5.4. Die Komponenten
| // 14-contexts/src/Catalog.tsx - ein Nachkomme, der dem Warenkorb etwas HINZUFÜGT
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() {
// der von App bereitgestellte Warenkorb (Fehler, wenn ihn niemand bereitstellt)
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()]: der Warenkorb, der von einer Elternkomponente bereitgestellt wird (Fehler, wenn keine Elternkomponente ihn bereitstellt).
| // =========================================================================
// 14-contexts/src/CartSummary.tsx
// -------------------------------------------------------------------------
// Ein weiterer Nachkomme: DERSELBE Warenkorb wie bei Catalog (von App bereitgestellt), aber
// SEINE EIGENE Uhr, die alle 5 Sekunden aktualisiert wird. Eine Komponente liest nur die
// Provider, die ÜBER ihr liegen: CartSummary platziert daher
// einen zweiten <ClockProvider> um seinen Inhalt, den es einer
// kleinen Komponente, Content, anvertraut.
// =========================================================================
import { ClockProvider, useClock } from './contexts/clock';
import { useCart } from './contexts/cart';
function Content() {
const cart = useCart();
const now = useClock(); // die nächstgelegene Uhr: die mit 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>
);
}
|
- Zeilen 14–34: Der Inhalt der Zusammenfassung liest den Warenkorb UND die Uhr. Die nächstgelegene Uhr ist die 5-Sekunden-Uhr;
- Zeilen 36–42: Eine Komponente liest nur die Provider, die OBERHALB von ihr platziert sind: [CartSummary] platziert daher seinen eigenen [<ClockProvider period={5000}>] um eine Unterkomponente, [Content].
| // =========================================================================
// 14-contexts/src/App.tsx - drei Ebenen von Kontexten
// -------------------------------------------------------------------------
// - das Log: ganz oben bereitgestellt (main.tsx), für die gesamte Anwendung;
// - der Warenkorb, von App bereitgestellt: geteilt von Catalog und CartSummary,
// die DENSELBEN Warenkorb sehen;
// - die Uhr, bereitgestellt von App (Standardintervall, 1 s) UND von
// CartSummary (5 s): jeweils eine eigene.
// =========================================================================
import Catalog from './Catalog';
import CartSummary from './CartSummary';
import { useLog } from './contexts/log';
import { ClockProvider, useClock } from './contexts/clock';
import { CartProvider } from './contexts/cart';
// die Zeit der Uhr von App: eine kleine Komponente, UNTER dem Provider platziert
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>
);
}
|
- Zeilen 18–20: [App] stellt die Uhr bereit; um sie zu lesen, ist eine Komponente erforderlich, die UNTERHALB von ihr platziert ist: [AppTime];
- Zeile 23: [App] liest das weiter oben bereitgestellte Protokoll;
- Zeilen 26–27: [App] stellt seinen Nachkommen die Uhr (1 s) und den Warenkorb bereit.
Und der Provider des Protokolls, ganz oben platziert:
| // =========================================================================
// 14-contexts/src/main.tsx - der Provider des Logs umschließt App: Es
// ist daher in der GESAMTEN Anwendung verfügbar
// =========================================================================
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>,
);
|

Die Uhr von [App] rückt jede Sekunde vor, während die Uhr des Warenkorbs alle fünf Sekunden vorrückt. Beide Komponenten sehen denselben Warenkorb, und das Protokoll erfasst jede Hinzufügung.
Ein Kontext genügt für Daten, die sich selten ändern (der angemeldete Benutzer, die Sprache, ein Theme) oder die nur einen Teil der Seite betreffen. Wird ein Zustand von der gesamten Anwendung gemeinsam genutzt und ändert er sich häufig, ist ein „Store“ vorzuziehen (Beispiel 20).
3.6. Beispiel 15: Eigene Hooks schreiben
Eine Komponente verwendet die Ansicht wieder; ein eigener Hook verwendet ein Verhalten samt seinem Zustand wieder. Er ist eine Funktion, deren Name mit [use] beginnt und die selbst Hooks aufruft. Dieses Beispiel schreibt zwei davon, für die beiden Verhaltensweisen, die Beispiel 15 des Kurses [Angular] den Direktiven zugewiesen hat.
3.6.1. Ein Element beim Überfahren hervorheben
| // =========================================================================
// 15-custom-hooks/src/hooks/useHover.ts
// -------------------------------------------------------------------------
// Ein EIGENER HOOK (Custom Hook) ist eine Funktion, deren Name mit „use“ beginnt und
// die selbst Hooks aufruft (useState, useEffect, useRef...). Er
// erlaubt es, ein VERHALTEN (mit seinem Zustand) in mehreren
// Komponenten wiederzuverwenden, so wie eine Komponente die Anzeige wiederverwendet.
//
// Dieser hebt ein Element hervor, über dem sich die Maus befindet. Er liefert die
// Attribute, die auf das Element zu setzen sind: <li {...useHover('#d1e7dd')}>. Jeder Aufruf hat
// seinen eigenen Zustand: Zwei hervorgehobene Elemente stören sich nicht gegenseitig.
// =========================================================================
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),
};
}
|
Der Hook hat seinen eigenen Zustand ([hovered]) und liefert die Attribute, die auf das Element anzuwenden sind: einen Stil und zwei Ereignishandler. Jede Komponente, die ihn aufruft, hat ihren eigenen Zustand: Zwei hervorgehobene Elemente beeinflussen sich nicht gegenseitig.
3.6.2. Langer Klick
| // =========================================================================
// 15-custom-hooks/src/hooks/useLongPress.ts
// -------------------------------------------------------------------------
// const longPress = useLongPress(() => remove(m), 1000);
// <button {...longPress.handlers} className={longPress.pressing ? 'press' : ''}>
// Die Aktion wird nur ausgeführt, wenn die Schaltfläche eine
// Sekunde lang gedrückt gehalten wird: ein Schutz vor versehentlichen Klicks. pressing gibt an, ob ein
// Drücken im Gange ist (um es anzuzeigen).
// Der Timer wird gestoppt, wenn die Komponente während eines Drückens verschwindet.
// =========================================================================
import { useEffect, useRef, useState } from 'react';
export function useLongPress(action: () => void, duration = 1000) {
const [pressing, setPressing] = useState(false);
// ein Wert, der die Anzeigen überdauert, OHNE eine auszulösen: useRef
const timer = useRef<number | undefined>(undefined);
// wenn die Komponente entfernt wird: kein verwaister Timer
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 },
};
}
|
- Zeile 17: der Bezeichner des Timers – ein Wert, der über mehrere Anzeigen hinweg erhalten bleiben muss, aber nicht angezeigt wird – eine Referenz;
- Zeile 20: ein Effekt ohne Aktion, der lediglich aufräumt: Verschwindet die Komponente, während die Schaltfläche gedrückt gehalten wird, wird der Timer gestoppt;
- Zeilen 22–28: Die Aktion wird nur ausgeführt, wenn die Schaltfläche eine Sekunde lang gedrückt gehalten wird: ein Schutz vor versehentlichen Klicks;
- Zeilen 35–38: Der Hook liefert den Zustand ([pressing], um ihn anzuzeigen) und die Ereignishandler für den Zeiger (Maus, Finger oder Stift).
3.6.3. Den Fokus setzen
| // =========================================================================
// 15-custom-hooks/src/hooks/autofocus.ts - ein „Ref-Callback“
// -------------------------------------------------------------------------
// ref={function}: React ruft die Funktion mit dem HTML-Element auf, sobald es
// in der Seite platziert ist (und ruft in React 19 die Funktion auf, die sie
// zurückgeben kann, wenn es aus ihr entfernt wird). Es ist kein Hook:
// eine einfache Funktion, überall wiederverwendbar:
// <input ref={autofocus} />
// (React unterstützt auch das Attribut autoFocus, das dasselbe bewirkt.)
// =========================================================================
export function autofocus(element: HTMLElement | null): void {
element?.focus();
}
|
Ein Ref-Callback: Dem Attribut [ref] kann man eine Funktion zuweisen, die [React] mit dem HTML-Element aufruft, sobald es auf der Seite platziert ist. Das ist kein Hook, sondern eine einfache Funktion.
3.6.4. Verwendung
| // =========================================================================
// 15-custom-hooks/src/App.tsx - Verhalten wiederverwenden
// -------------------------------------------------------------------------
// Hooks werden nur auf der OBERSTEN Ebene einer Komponente aufgerufen (nie in
// einer Schleife, einer Bedingung oder einer verschachtelten Funktion): React
// erkennt sie an der REIHENFOLGE ihres Aufrufs. Für ein Verhalten pro Zeile einer
// Liste schreiben wir daher eine kleine Komponente pro Zeile, die ihre Hooks aufruft.
// =========================================================================
import { useState } from 'react';
import { useHover } from './hooks/useHover';
import { useLongPress } from './hooks/useLongPress';
import { autofocus } from './hooks/autofocus';
// der Stil der Schaltfläche bei langem Drücken
const pressStyle = { outline: '4px solid #dc3545' };
// eine Zeile der Liste: Sie ruft IHRE Hooks auf
function DoctorRow({ name, even, onRemove }: { name: string; even: boolean; onRemove: () => void }) {
// jede zweite Zeile: die Standardfarbe; die anderen grün
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>
);
}
|
Für Hooks gilt eine strikte Regel: Sie werden nur auf der obersten Ebene einer Komponente oder eines anderen Hooks aufgerufen, nie innerhalb einer Schleife, einer Bedingung oder einer verschachtelten Funktion. [React] erkennt jeden [useState] an der Reihenfolge seiner Aufrufe: Änderte sich die Reihenfolge von einer Anzeige zur nächsten, würden die Zustände durcheinandergeraten.
- Zeilen 19–33: Für ein Verhalten pro Zeile in einer Liste können Sie die Hooks nicht direkt in [map] aufrufen; schreiben Sie stattdessen für jede Zeile eine kleine Komponente, die IHRE Hooks aufruft;
- Zeile 25: Die Tooltip-Attribute, auf die Zeile verteilt;
- Zeile 28: die Handler für den langen Druck auf die Schaltfläche und ihr Stil, solange sie gedrückt ist;
- Zeile 47: der Ref-Callback;
- Zeile 52: eine Zeile pro Arzt.
Beim Start hat das Feld den Fokus. Während Sie die zweite Schaltfläche gedrückt halten:

Dann, nachdem eine Sekunde vergangen ist:

Eigene Hooks sind in [React] der wichtigste Weg, Code wiederzuverwenden. Die Bibliotheken stellen viele davon bereit: [useForm] (Beispiel 08), [useNavigate] (Beispiel 17), [useTranslation] (Beispiel 21), [useQuery] (Beispiel 24) ...
3.7. Beispiel 16: Ein wiederverwendbares Bestätigungsfenster
„Sind Sie sicher?“: [window.confirm()] existiert zwar, aber seine Schaltflächen lassen sich weder formatieren noch übersetzen. Es wird durch ein [Bootstrap]-Fenster ersetzt, das über einen Kontext gesteuert wird.
3.7.1. Der Kontext
| // =========================================================================
// 16-confirmation/src/confirmation/confirmation.tsx
// -------------------------------------------------------------------------
// "Are you sure?": window.confirm() gibt es zwar, aber es lässt sich weder
// gestalten, noch lassen sich seine Schaltflächen übersetzen. Es wird durch einen
// Bootstrap-Dialog ersetzt, gesteuert über einen Kontext (vgl. Beispiel 14).
//
// Der Trick: confirm(message) gibt ein PROMISE zurück, aufgelöst mit true (Ja)
// oder false (Nein), sobald der Benutzer antwortet. Der aufrufende Code wird dann
// so einfach geschrieben wie mit window.confirm:
//
// const confirm = useConfirmation();
// if (await confirm('Delete this doctor?')) { ... }
//
// Der Provider zeigt den Dialog selbst an: Er muss nur
// einmal um die gesamte Anwendung herum platziert werden (vgl. 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: Dialog geschlossen
// die Funktion, die das aktuelle Promise auflöst: Sie wird nicht angezeigt,
// ist daher eine Referenz und kein Zustand
const answer = useRef<((yes: boolean) => void) | null>(null);
const confirm = useCallback<Confirm>((text) => {
answer.current?.(false); // eine noch offene Frage? Das bedeutet „Nein“
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;
}
|
Tipp: [confirm(message)] gibt ein Promise zurück, das mit [true] (Ja) oder [false] (Nein) aufgelöst wird, sobald der Benutzer antwortet. Der aufrufende Code ist dann genauso einfach wie mit [window.confirm]: [if (await confirm('Delete this doctor?')) {...}].
- Zeile 22: was der Kontext bereitstellt: eine Funktion;
- Zeile 27: die angezeigte Nachricht; [null]: Das Fenster ist geschlossen;
- Zeile 30: die Funktion, die das aktuelle Promise auflöst. Sie wird nicht angezeigt: Es ist eine Referenz, kein Zustand;
- Zeilen 32–38: Das Fenster öffnen und ein Promise zurückgeben, dessen Funktion als [resolve] gespeichert wird. Eine unbeantwortete Frage wird als „Nein“ gewertet;
- Zeilen 40–45: die Antwort: das Fenster schließen und das Promise auflösen;
- Zeile 50: Der Provider zeigt das Fenster selbst an, wenn eine Frage vorliegt.
3.7.2. Das Fenster
| // =========================================================================
// 16-confirmation/src/confirmation/ConfirmDialog.tsx
// -------------------------------------------------------------------------
// Der modale Dialog:
// - dieselben Bootstrap-Klassen wie bei einem echten Modal (.modal, .modal-backdrop),
// „hartkodiert“ angezeigt (show d-block): Das JavaScript von Bootstrap
// ist nicht nötig;
// - createPortal: Der Dialog wird am Ende von <body> platziert und nicht dort, wo
// die Komponente geschrieben steht. So entgeht er den Stilen seiner
// Vorfahren (overflow, z-index...), bleibt aber eine gewöhnliche
// React-Komponente (Props, Ereignisse);
// - Tastatur: Escape = Nein; der Fokus wird beim Öffnen auf die Schaltfläche „No“ gesetzt (die
// am wenigsten gefährliche Wahl).
// =========================================================================
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, an beliebiger Stelle der Seite: ein Listener, der beim Öffnen auf das DOCUMENT gesetzt
// und beim Schließen entfernt wird (Cleanup des Effekts)
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>
{/* ein Klick auf den Hintergrund (und nicht in den Dialog) bedeutet „Nein“ */}
<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: React gibt dieser Schaltfläche den Fokus, wenn sie erscheint */}
<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,
);
}
|
- Zeilen 27–33: die Esc-Taste, an beliebiger Stelle der Seite: ein Listener, der beim Öffnen des Fensters an DOCUMENT angehängt und beim Schließen wieder entfernt wird (Cleanup). Das ist typischerweise die Aufgabe eines Effekts: die Verbindung mit etwas, das außerhalb von [React] liegt;
- Zeile 35: [createPortal(jsx, element)] zeigt JSX an einer anderen Stelle an als der, an der die Komponente geschrieben ist: hier am Ende von [<body>]. Das Fenster umgeht so die Stile seiner Vorfahren ([overflow], [z-index] ...) und bleibt dennoch eine gewöhnliche [React]-Komponente (Props, Ereignisse);
- Zeilen 37–39: die [Bootstrap]-Klassen eines echten modalen Fensters, fest im Code verankert ([show d-block]): Das [JavaScript] von [Bootstrap] wird dafür nicht benötigt;
- Zeile 40: Ein Klick auf den Hintergrund (nicht in das Fenster) zählt als „Nein“;
- Zeile 52: [React] setzt den Fokus auf die Schaltfläche „Nein“ – die sicherste Wahl –, sobald sie erscheint.
3.7.3. Verwendung
| // =========================================================================
// 16-confirmation/src/App.tsx - den Bestätigungsdialog verwenden
// -------------------------------------------------------------------------
// Dieselbe Seite wie Beispiel 21 des NestJS-Kurses (Links, Schaltflächen, Bestätigung),
// aber ohne jedes Hin und Zurück zu einem Server.
// =========================================================================
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('');
// eine async-Funktion: Sie „wartet“ auf die Antwort des Benutzers
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>
);
}
|
- Zeile 17: die Bestätigungsfunktion;
- Zeilen 26–33: eine [async]-Funktion: Sie „wartet“ ([await]) auf die Antwort des Benutzers, ohne die Seite zu blockieren.
| 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';
// der Bestätigungsdialog, EINMAL für die gesamte Anwendung
createRoot(document.getElementById('root')!).render(
<StrictMode>
<ConfirmationProvider>
<App />
</ConfirmationProvider>
</StrictMode>,
);
|
Für die gesamte Anwendung wird EIN EINZIGES Fenster verwendet: Sein Provider umschließt [App].

Bestätigen Sie, fordern Sie dann eine weitere Löschung an und drücken Sie Esc:
