2. Erste Schritte mit React
2.1. Beispiel 01: Der Aufbau einer React-Anwendung
2.1.1. Die Datei package.json
Die Datei [package.json] im Ordner examples deklariert die verwendeten Bibliotheken und die Projektbefehle:
| {
"name": "examples-react",
"private": true,
"version": "1.0.0",
"type": "module",
"scripts": {
"start": "vite --config vite.config.ts",
"build": "vite build --config vite.config.ts",
"check": "tsc --noEmit"
},
"dependencies": {
"@tanstack/react-query": "^5.104.0",
"bootstrap": "^5.3.8",
"i18next": "^26.4.2",
"react": "^19.3.0",
"react-dom": "^19.3.0",
"react-hook-form": "^7.89.0",
"react-i18next": "^17.0.15",
"react-router": "^8.4.0",
"zustand": "^5.0.15"
},
"devDependencies": {
"@types/react": "^19.2.18",
"@types/react-dom": "^19.2.7",
"@vitejs/plugin-react": "^6.1.1",
"typescript": "~6.0.2",
"vite": "^8.3.0"
}
}
|
Gehen wir diese Datei Schritt für Schritt durch:
- Zeile 5: Die [JavaScript]-Dateien des Projekts sind ES-Module ([import] / [export]), was dem aktuellen Sprachstandard entspricht;
- Zeilen 6–10: Die Projektbefehle, die mit [npm run <name>] (oder [npm start] für den Befehl [start]) gestartet werden:
- [npm start 05-controlled-fields] startet [vite --config vite.config.ts 05-controlled-fields]: den Entwicklungsserver für Beispiel 05;
- [npm run build 05-controlled-fields] startet [vite build ...]: die Produktionsversion von Beispiel 05, die im Ordner [05-controlled-fields/dist/] liegt;
- [npm run check] startet den [TypeScript]-Compiler ([tsc]), der die Typen ALLER Beispiele prüft, ohne etwas zu erzeugen ([--noEmit]);
- Zeilen 11–21: die Bibliotheken, die die Anwendung im Browser benötigt: [react] (der Kern: Komponenten, Zustand, Hooks) und [react-dom] (Darstellung auf einer Webseite), [react-router] (der Router, Beispiele 17 und 18), [react-hook-form] (Beispiel 08), [zustand] (Beispiel 20), [i18next] und [react-i18next] (Sprachen, Beispiel 21), [@tanstack/react-query] (Lesen von Serverdaten, Beispiel 24) und [Bootstrap] für die Formatierung;
- Zeilen 22–28: Entwicklungswerkzeuge: [Vite] ([vite]), sein Plugin für [React] ([@vitejs/plugin-react]), der [TypeScript]-Compiler und die Typbeschreibungen von [React] für [TypeScript] ([@types/react], [@types/react-dom]). Sie gehören nicht zu der Anwendung, die an die Benutzer ausgeliefert wird.
Das Präfix [^] vor einer Version ([^19.3.0]) erlaubt [npm] , eine neuere Version derselben Hauptversion (19.x.y) zu installieren; das Präfix [~] ([~6.0.2]) erlaubt nur Hotfixes (6.0.x).
In einem Standardprojekt wird diese Datei mit dem Befehl [npm create vite@latest project-name -- --template react-ts] erzeugt, der eine vollständige, sofort lauffähige [React]-Anwendung generiert. Die Beispiele dieses Kurses wurden von Hand geschrieben, damit fünfundzwanzig davon in einem einzigen Ordner Platz finden.
2.1.2. Die Datei vite.config.ts
[Vite] ist das empfohlene Build-Werkzeug für eine [React]-Anwendung: ein sehr schneller Entwicklungsserver und ein Produktionscompiler. Seine Konfiguration, die allen Beispielen gemeinsam ist:
| // =========================================================================
// vite.config.ts - die Konfiguration von Vite, gemeinsam für alle Beispiele
// -------------------------------------------------------------------------
// Vite ist das Build-Tool von React: ein Entwicklungsserver
// (npm start) und ein Produktions-Compiler (npm run build). Jedes
// Beispiel ist ein Ordner mit eigener Seite index.html; sein
// Name wird an Vite übergeben, das ihn zum ROOT der Anwendung macht:
//
// npm start 05-controlled-fields -> vite --config vite.config.ts 05-controlled-fields
// npm run build 05-controlled-fields -> das Ergebnis in 05-controlled-fields/dist/
// =========================================================================
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
export default defineConfig({
// das React-Plugin: die JSX-Syntax und das „Hot“-Reloading (eine
// Codeänderung aktualisiert die Seite, ohne den angezeigten Zustand zu verlieren)
plugins: [react()],
server: {
port: 5173,
// der PROXY: jede Anfrage des Browsers an /api/... wird an den
// JSON-Server von RdvMedecins (Port 8080) weitergeleitet. Er wird erst ab
// Beispiel 22 verwendet (vgl. Kapitel „Mit dem Server sprechen“).
proxy: {
'/api': 'http://localhost:8080',
},
},
});
|
- Zeilen 9–10 (Kommentar): Der Name des Beispiels, der dem Befehl übergeben wird, wird zum Wurzelverzeichnis ([root]) der Anwendung: [Vite] sucht dort die Seite [index.html] und den Ordner [public/] und legt dort das Ergebnis des Builds ([dist/]) ab;
- Zeile 19: das [React]-Plugin: Es kompiliert die JSX-Syntax (siehe unten) und aktiviert das Hot Reloading: Eine Änderung am Code einer Komponente wird auf die Seite angewendet, ohne sie neu zu laden, wobei der angezeigte Zustand so weit wie möglich erhalten bleibt;
- Zeile 21: der Port des Entwicklungsservers;
- Zeilen 25–27: der Proxy, der erst ab Beispiel 22 verwendet wird: Jede Anfrage des Browsers an eine Adresse, die mit [/api] beginnt, wird an den JSON-Server [RdvMedecins] weitergeleitet. Wir kommen später darauf zurück.
2.1.3. Die Datei tsconfig.json
Die für alle Beispiele gemeinsame [TypeScript]-Konfiguration:
| {
"compilerOptions": {
"target": "ES2023",
"lib": ["ES2023", "DOM", "DOM.Iterable"],
"module": "ESNext",
"moduleResolution": "bundler",
"types": ["vite/client"],
"jsx": "react-jsx",
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"noFallthroughCasesInSwitch": true,
"noImplicitReturns": true,
"verbatimModuleSyntax": true,
"erasableSyntaxOnly": true,
"resolveJsonModule": true,
"skipLibCheck": true,
"noEmit": true
},
"include": ["*/src", "common", "vite.config.ts"]
}
|
- Zeilen 3–6: moderner [JavaScript]-Code (ES2023), Browserdefinitionen ([DOM]) und Module, die so aufgelöst werden, wie es das Build-Werkzeug tut;
- Zeile 7: für [Vite] spezifische Definitionen (zum Beispiel ist das Importieren eines Stylesheets, [import './App.css'], erlaubt);
- Zeile 8: Die JSX-Syntax wird akzeptiert und für [React] kompiliert;
- Zeilen 9–13: der strikte Modus von [TypeScript] (streng geprüfte Typen, einschließlich [null] und [undefined]) sowie zusätzliche Prüfungen: Eine ungenutzte Variable oder ein ungenutzter Parameter wird als Fehler gemeldet;
- Zeile 14: Ein Import, der nur Typen betrifft, wird als [import type { ... }] (oder [import { type X }]) geschrieben: Das teilt dem Build-Werkzeug mit, dass er in der erzeugten [JavaScript] -Datei nicht mehr existiert;
- Zeile 16: Eine Datei namens JSON kann als Modul importiert werden (Beispiel 21);
- Zeile 18: [tsc] prüft nur die Typen; es ist [Vite], das den Code tatsächlich kompiliert (es entfernt die Typen einfach, ohne sie zu prüfen: daher der Befehl [npm run check]);
- Zeile 20: die Dateien, die geprüft werden: die aller Beispiele.
Der Editor [VS Code] verwendet diese Konfiguration: Ein Tippfehler in einer Komponente ([{titl}] statt [{title}]) wird rot unterstrichen, sobald er getippt wird.
2.1.4. Die Seite index.html
Jedes Beispiel hat seine eigene HTML-Seite. Die Seite für Beispiel 01:
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Example 01 - a first application</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
<!-- die React-Anwendung wird in diesem Element angezeigt (vgl. src/main.tsx) -->
<div id="root"></div>
<!-- der Einstiegspunkt: ein JavaScript-Modul, das Vite im laufenden Betrieb kompiliert -->
<script type="module" src="/src/main.tsx"></script>
</body>
</html>
|
Dies ist die einzige Seite, die der Browser lädt. Sie ist fast leer:
- Zeile 10: das Element, in dem [React] die Anwendung anzeigt;
- Zeile 12: der Einstiegspunkt der Anwendung, ein [TypeScript]-Modul. Der Browser versteht [TypeScript] nicht: Es ist [Vite], das diese Datei – und die Dateien, die sie importiert – kompiliert, wenn der Browser sie anfordert.
Hier gibt es keine [<link>]-Tags: Die Stylesheets werden vom Code importiert (siehe [main.tsx]), und [Vite] fügt sie der Seite selbst hinzu.
2.1.5. Der Einstiegspunkt: main.tsx
| // =========================================================================
// 01-first-application/src/main.tsx - der Einstiegspunkt der Anwendung
// -------------------------------------------------------------------------
// index.html lädt diese Datei. Sie startet die React-Anwendung:
// 1. createRoot(element): React übernimmt das Element <div id="root">
// der Seite;
// 2. root.render(<App />): darin wird die WURZEL-Komponente App angezeigt.
// Stylesheets sind Module wie alle anderen: Sie werden importiert.
// =========================================================================
import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App';
// das „!“ sagt TypeScript: Dieses Element existiert (es steht in index.html)
createRoot(document.getElementById('root')!).render(
// StrictMode: nur in der Entwicklung führt React zusätzliche
// Prüfungen durch (vgl. Beispiel 13). Er zeigt selbst nichts an.
<StrictMode>
<App />
</StrictMode>,
);
|
Eine [.tsx]-Datei ist eine [TypeScript]-Datei, die JSX enthält.
- Zeile 12: die Funktion aus [react-dom], die eine Anwendung innerhalb einer Webseite startet;
- Zeile 13: das Stylesheet von [Bootstrap]: ein unbenannter Import, der nur dazu dient, es der Seite hinzuzufügen;
- Zeile 14: die Wurzelkomponente der Anwendung, die von [App.tsx] exportierte Funktion;
- Zeile 17: [React] übernimmt die Kontrolle über das Element [<div id="root">]. [document.getElementById('root')] kann für [null] zurückgeben [TypeScript]: [!] sichert zu, dass es existiert;
- Zeilen 20–22: [render(...)] zeigt die Komponente [App] in diesem Element an. [<App />] ist Teil von JSX: die Verwendung der Komponente [App] als Tag. [<StrictMode>] ist eine Komponente von [React], die selbst nichts anzeigt, aber während der Entwicklung zusätzliche Prüfungen aktiviert (Beispiel 13).
2.1.6. Die Wurzelkomponenten: App.tsx und App.css
Eine [React] -Komponente ist eine Funktion:
| // =========================================================================
// 01-first-application/src/App.tsx - eine erste Komponente
// -------------------------------------------------------------------------
// Eine React-Komponente ist eine FUNKTION, deren Name mit einem Großbuchstaben
// beginnt und die das, was angezeigt werden soll, ZURÜCKGIBT, geschrieben in JSX: HTML
// innerhalb des TypeScript-Codes. React ruft diese Funktion auf, um die
// Seite aufzubauen; es ruft sie bei jeder Änderung des Zustands der Komponente ERNEUT auf
// und aktualisiert die Seite mit dem neuen Ergebnis.
// =========================================================================
import { useState } from 'react';
// ein Stylesheet, importiert von der Komponente, die es verwendet
import './App.css';
// „gewöhnliche“ Daten außerhalb der Komponente: Sie ändern sich nie
const title = 'Welcome to React';
const languages = ['TypeScript', 'HTML', 'CSS'];
export default function App() {
// useState(0): ein ZUSTAND mit dem Anfangswert 0. Wir erhalten seinen
// AKTUELLEN Wert (counter) und die Funktion, die ihn ändert (setCounter).
// Der Aufruf von setCounter veranlasst React, App ERNEUT aufzurufen, um
// die Seite zu aktualisieren. Wir ändern die Seite nie selbst.
const [counter, setCounter] = useState(0);
const [time, setTime] = useState(() => new Date().toLocaleTimeString());
// eine Funktion, die von der Schaltfläche aufgerufen wird
function increment() {
setCounter((n) => n + 1);
setTime(new Date().toLocaleTimeString());
}
// das zurückgegebene JSX: { Ausdruck } fügt den Wert eines Ausdrucks ein;
// className ersetzt das HTML-Attribut class (ein reserviertes Wort in JavaScript)
return (
<div className="container py-4">
<h1 className="h3">{title}</h1>
<p>This page is built in the browser, by React, from index.html, main.tsx and the App component.</p>
<p>
It is written in {languages.join(', ')} ({languages.length} languages).
</p>
{/* onClick: die Funktion, die beim Klicken aufgerufen wird (vgl. Beispiel 04) */}
<button className="btn btn-primary" onClick={increment}>
Click me
</button>
<p className="mt-3 counter">
You clicked {counter} times (last click: {time}).
</p>
</div>
);
}
|
- Zeile 11: der Hook [useState], bereitgestellt von [React];
- Zeile 13: das Stylesheet der Komponente;
- Zeilen 16–17: zwei gewöhnliche Daten, die außerhalb der Komponente deklariert sind: Sie ändern sich nie;
- Zeile 19: die Komponente: eine Funktion, deren Name mit einem Großbuchstaben beginnt (so unterscheidet JSX eine Komponente, [<App />], von einem HTML-Element, [<div>]). [export default]: Das exportiert das Modul standardmäßig; es wird in [main.tsx] mit [import App from './App'] importiert;
- Zeile 24: [useState(0)] erzeugt eine Zustandsvariable mit dem Anfangswert 0. Es gibt ein Array mit zwei Elementen zurück, das wir „entpacken“: den aktuellen Wert ([counter]) und die Funktion, die ihn ändert ([setCounter]). Der Zustand wird von [React] gespeichert: Er bleibt von einem Funktionsaufruf zum nächsten erhalten;
- Zeile 25: Sie können eine Funktion an [useState] übergeben, die den Anfangswert berechnet; sie wird nur beim ersten Anzeigen der Seite aufgerufen;
- Zeilen 28–30: Eine Funktion, die vom Button aufgerufen wird. Sie ändert nicht die Seite, sondern den Zustand. [setCounter((n) => n + 1)] berechnet den neuen Wert anhand des alten. Jeder Aufruf der Funktion [setXxx] weist [React] an, [App] aufzurufen; [React] vergleicht das neue Ergebnis mit dem alten und aktualisiert nur die Teile der Seite, die sich geändert haben;
- Zeilen 35–51: das zurückgegebene JSX, also das, was angezeigt werden soll:
- JSX ähnelt HTML, mit einigen Unterschieden: Das Attribut [class] wird als [className] geschrieben ([class] ist ein reserviertes Wort in [JavaScript]), jedes Tag muss geschlossen werden ([<br />], [<input />]), und die gesamte Struktur muss EIN Wurzelelement haben;
- Zeile 37: [{ expression }] fügt den Wert eines [TypeScript]-Ausdrucks ein. Er wird maskiert: Wenn [title] den Text [<b>] enthielte, würde [<b>] angezeigt, ohne dass das Tag interpretiert würde;
- Zeile 40: Der Ausdruck kann beliebig sein: ein Methodenaufruf, eine Berechnung;
- Zeile 43: Ein Kommentar in JSX wird als [{/* ... */}] geschrieben;
- Zeile 44: Ein Klick auf den Button ruft die Funktion [increment] auf (siehe Beispiel 04). Die Funktion selbst wird ohne Klammern übergeben: [onClick={increment()}] würde sie sofort aufrufen, noch während der Anzeige;
- Zeile 48: der aktuelle Wert des Zustands. Ändert sich der Zustand, wird [App] erneut aufgerufen, und dieser Text ändert sich.
JSX ist nicht dasselbe wie HTML: Es ist eine bequeme Schreibweise für Funktionsaufrufe. Der Compiler wandelt [<h1 className="h3">{title}</h1>] in einen Aufruf der Form [jsx('h1', { className: 'h3', children: title })] um, der ein Objekt erzeugt, das das Element beschreibt. Die Komponente gibt also einen Baum von Objekten zurück (das „virtuelle DOM“), den [React] mit dem vorherigen Baum vergleicht, um zu bestimmen, was auf der tatsächlichen Seite geändert werden muss.
Und sein Stylesheet:
| /* ein von App.tsx importiertes Stylesheet; ACHTUNG: es gilt für das gesamte
Seite und nicht nur für die Komponente App (vgl. Beispiel 10) */
.counter {
font-weight: bold;
color: #087ea4;
}
|
Anders als [Angular] oder [Vue.js] kapselt [React] die Stile einer Komponente nicht: Ein importiertes Stylesheet gilt für die gesamte Seite. Beispiel 10 zeigt die „CSS-Module“, die eine Klasse auf eine einzige Komponente beschränken.
2.1.7. Ausführung
In der Konsole, die im Ordner [examples-react] geöffnet ist:
npm start 01-first-application
Die Konsole zeigt:
| > examples-react@1.0.0 start
> vite --config vite.config.ts 01-first-application
VITE v8.3.1 ready in 264 ms
➜ Local: http://localhost:5173/
➜ Network: use --host to expose
|
Öffnen Sie die URL http://localhost:5173/ und klicken Sie dreimal auf den Button:

Zwei Experimente zum Ausprobieren:
- Ändern Sie den Titeltext in [App.tsx] und speichern Sie die Datei: Die Seite aktualisiert sich sofort, ohne dass sie neu geladen werden muss, und der Zähler behält seinen Wert. Der Entwicklungsserver überwacht die Dateien, kompiliert die Änderungen neu und benachrichtigt den Browser;
- Sehen Sie sich den Quelltext der Seite an (Strg-U): Sie finden dort nur die fast leere Seite [index.html]. Die angezeigte HTML-Seite wurde von [React] im Browser erzeugt. Um sie zu sehen, verwenden Sie den Inspektor der Entwicklertools (F12, Registerkarte Elemente) oder die Erweiterung [React Developer Tools], die außerdem die Komponenten und ihren Zustand anzeigt.
2.2. Beispiel 02: Zustand und berechnete Werte
Der Zustand steht im Mittelpunkt von [React]. Dieses Beispiel berechnet den Preis eines Artikels einschließlich Mehrwertsteuer:
| // =========================================================================
// 02-state/src/App.tsx - Zustand, berechnete Werte, useEffect
// -------------------------------------------------------------------------
// Ein kleiner Preisrechner einschließlich Mehrwertsteuer:
// - useState : ein ZUSTANDSwert; seine Änderung (setXxx) ruft die
// Komponente erneut auf, die die Seite mit dem neuen Wert aufbaut;
// - ein aus dem Zustand BERECHNETER Wert ist KEIN Zustand: Er ist eine
// einfache Variable, die bei jedem Aufruf der Komponente neu berechnet wird;
// - useMemo : dasselbe, aber die Berechnung wird nur wiederholt, wenn sich
// ihre Abhängigkeiten geändert haben (nützlich für aufwendige Berechnungen);
// - useEffect : Code, der NACH der Anzeige ausgeführt wird, wenn sich einige
// Werte geändert haben: ein „Seiteneffekt“ (eine Einwirkung auf etwas
// anderes als die Seite: hier der Titel des Tabs).
// =========================================================================
import { useEffect, useMemo, useState } from 'react';
// ein Formatierer für Eurobeträge nach englischer Schreibweise (€1,234.50)
const euros = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' });
export default function App() {
const [label, setLabel] = useState('Pen');
const [priceExclVat, setPriceExclVat] = useState(2.5);
const [quantity, setQuantity] = useState(1);
const [vatRate, setVatRate] = useState(20); // in %
// BERECHNETE Werte: einfache Konstanten, die bei jedem
// Aufruf der Komponente neu berechnet werden. Sie sind immer aktuell, nichts muss synchronisiert werden
const totalExclVat = quantity * priceExclVat;
const vatAmount = (totalExclVat * vatRate) / 100;
// useMemo(Berechnung, [Abhängigkeiten]): dasselbe Ergebnis, aber React wiederholt die
// Berechnung nur, wenn sich seit dem vorherigen Aufruf eine der Abhängigkeiten geändert hat
const totalInclVat = useMemo(() => totalExclVat + vatAmount, [totalExclVat, vatAmount]);
// der Verlauf der Summen inkl. MwSt.: Er hängt von den AUFEINANDERFOLGENDEN Werten der
// Summe ab. Die alte Summe wird im Zustand gehalten; weicht sie von der
// neuen ab, wird der Zustand WÄHREND des Aufrufs der Komponente angepasst (React
// startet den Aufruf dann sofort neu, bevor irgendetwas angezeigt wird)
const [history, setHistory] = useState<{ id: number; text: string }[]>([]);
const [oldTotal, setOldTotal] = useState(totalInclVat);
if (totalInclVat !== oldTotal) {
setOldTotal(totalInclVat);
const text = `${euros.format(oldTotal)} -> ${euros.format(totalInclVat)}`;
// jede Zeile hat eine eindeutige Nummer (id), die sie identifiziert (vgl. key, Beispiel 03)
setHistory((h) => [{ id: (h[0]?.id ?? 0) + 1, text }, ...h].slice(0, 5));
}
// useEffect(Effekt, [Abhängigkeiten]): der Effekt wird NACH der ersten
// Anzeige ausgeführt, dann nach jeder Anzeige, bei der sich totalInclVat geändert hat
useEffect(() => {
document.title = `Incl. VAT: ${euros.format(totalInclVat)}`;
}, [totalInclVat]);
// Das Ändern des Artikels setzt die Menge auf 1 zurück: Das geschieht im
// Ereignishandler, wo wir wissen, WARUM sich der Zustand ändert
function changeLabel(newValue: string) {
setLabel(newValue);
setQuantity(1);
}
function reset() {
setLabel('Pen');
setPriceExclVat(2.5);
setQuantity(1);
setVatRate(20);
}
return (
<div className="container py-4">
<h1 className="h3 mb-3">Example 02 - state and computed values</h1>
<div className="row g-4">
<div className="col-md-6">
<div className="card p-3">
{/* value + onChange: das Feld zeigt den Zustand an, und jeder Tastenanschlag ändert ihn (vgl. Beispiel 05) */}
<label className="form-label" htmlFor="label">Item</label>
<input id="label" className="form-control mb-2" value={label}
onChange={(e) => changeLabel(e.target.value)} />
<label className="form-label" htmlFor="price">Unit price excl. VAT</label>
{/* valueAsNumber: der Wert des Feldes als Zahl (NaN, wenn es leer ist) */}
<input id="price" type="number" step="0.1" min="0" className="form-control mb-2" value={priceExclVat}
onChange={(e) => setPriceExclVat(e.target.valueAsNumber || 0)} />
<label className="form-label" htmlFor="quantity">Quantity (back to 1 if the item changes)</label>
<input id="quantity" type="number" min="0" className="form-control mb-2" value={quantity}
onChange={(e) => setQuantity(e.target.valueAsNumber || 0)} />
<label className="form-label" htmlFor="vat">VAT rate</label>
{/* der Wert eines <select> ist ein STRING: Number(...) wandelt ihn um */}
<select id="vat" className="form-select mb-3" value={vatRate}
onChange={(e) => setVatRate(Number(e.target.value))}>
<option value={5.5}>5.5 %</option>
<option value={10}>10 %</option>
<option value={20}>20 %</option>
</select>
<button className="btn btn-outline-secondary" onClick={reset}>Reset</button>
</div>
</div>
<div className="col-md-6">
<div className="card p-3">
<h2 className="h5">{quantity} x {label}</h2>
<table className="table mb-0">
<tbody>
<tr><td>Total excl. VAT</td><td className="text-end">{euros.format(totalExclVat)}</td></tr>
<tr><td>VAT ({vatRate} %)</td><td className="text-end">{euros.format(vatAmount)}</td></tr>
<tr className="fw-bold"><td>Total incl. VAT</td><td className="text-end">{euros.format(totalInclVat)}</td></tr>
</tbody>
</table>
</div>
<div className="card p-3 mt-3">
<h2 className="h6">History of the total incl. VAT</h2>
<ul className="mb-0">
{history.map((line) => (
<li key={line.id}>{line.text}</li>
))}
</ul>
</div>
</div>
</div>
</div>
);
}
|
Die Datei [main.tsx] dieses Beispiels – und der meisten folgenden Beispiele – entspricht der aus Beispiel 01, ohne ihre Kommentare. Es werden nur die Dateien [main.tsx] gezeigt, die davon abweichen.
- Zeile 16: die verwendeten Hooks, alle bereitgestellt von [React];
- Zeile 19: ein Formatierer für Beträge im englischen Stil (€1,234.50), der einmalig außerhalb der Komponente erzeugt wird. Beispiel 09 stellt die API und die [Intl]-Objekte vor;
- Zeilen 22–25: vier Zustandswerte. Ihr Typ wird aus dem Anfangswert abgeleitet: [useState('Pen')] ist ein Zustand vom Typ [string], und [useState(2.5)] ist ein Zustand vom Typ [number];
- Zeilen 29–30: zwei aus dem Zustand berechnete Werte. Dies sind KEINE Zustände: Es sind einfache Konstanten, die bei jedem Aufruf der Komponente neu berechnet werden. Sie sind daher immer aktuell. Das ist eine wichtige Regel in [React]: Speichern Sie im Zustand nur, was sich nicht berechnen lässt; alles andere wird bei der Anzeige berechnet;
- Zeile 33: [useMemo(computation, [dependencies])] liefert dasselbe Ergebnis, aber [React] speichert den Wert und berechnet ihn nur neu, wenn sich eine der Abhängigkeiten seit dem vorherigen Aufruf geändert hat. Für eine Addition ist das unnötig; es dient für rechenintensive Operationen (Sortieren einer langen Liste ...). Wir haben es hier eingefügt, um seine Syntax zu zeigen;
- Zeilen 39–45: Der Verlauf der Summen inkl. MwSt. hängt von aufeinanderfolgenden Werten der Summe ab, was ein berechneter Wert nicht ausdrücken kann. Wir speichern die alte Summe im Zustand ([oldTotal]); unterscheidet sie sich bei der Anzeige von der neuen, aktualisieren wir den Zustand, während die Komponente aufgerufen wird. [React] erlaubt das: Es verwirft dann das aktuelle Ergebnis und ruft die Komponente sofort erneut mit dem neuen Zustand auf, bevor irgendetwas angezeigt wird. Jeder Zeile des Verlaufs wird eine eindeutige Nummer zugewiesen, [id], deren Verwendung in Beispiel 03 erklärt wird;
- Zeilen 50–52: [useEffect(effect, [dependencies])]: Die Funktion [effect] wird nach der Anzeige ausgeführt: einmal zu Beginn, danach jedes Mal, wenn sich eine der Abhängigkeiten (hier [totalInclVat]) ändert. Das dient für Seiteneffekte: um etwas anderes zu beeinflussen als das, was die Komponente anzeigt (hier den Titel des Browser-Tabs; anderswo einen Timer, eine HTTP-Anfrage);
- Zeilen 56–58: Ein Wechsel des Artikels setzt die Menge auf 1 zurück. Das geschieht in der Funktion, die die Feldänderung behandelt, wo wir wissen, warum sich der Zustand ändert. Das ist die von [React] empfohlene Methode: Statt eines Effekts, der die Bezeichnung „überwacht“, wird die Aktion im Ereignishandler ausgeführt;
- Zeilen 61–65: mehrere Zustandsänderungen hintereinander. [React] fasst sie zusammen: Die Komponente wird nur einmal aufgerufen, am Ende des Handlers.
JSX:
- Zeilen 76–77: ein kontrolliertes Feld (siehe Beispiel 05): [value] zeigt den Zustand an; [onChange] wird bei jedem Tastendruck über das Ereignis [e] aufgerufen; [e.target.value] ist der Text des Felds. In JSX wird das Attribut [for] eines Labels als [htmlFor] geschrieben;
- Zeilen 80–81: Bei einem numerischen Feld gibt [e.target.valueAsNumber] den Wert als Zahl zurück ([NaN] , wenn das Feld leer ist, daher [|| 0]);
- Zeilen 87–92: Der Wert eines [<select>] ist immer eine Zeichenkette: [Number(...)] wandelt ihn um;
- Zeile 110: [map] erzeugt pro Zeile des Verlaufs ein [<li>]-Element (siehe Beispiel 03).
Bei laufendem Entwicklungsserver ([npm start 02-state]) ändern wir Artikel, Preis, Menge und Satz:

Jedes Mal, wenn sich die Summe inkl. MwSt. ändert, wird dem Verlauf eine Zeile hinzugefügt, und der Titel des Tabs ändert sich. Ein Wechsel des Artikels setzt die Menge auf 1 zurück.
Der Unterschied zu [Angular] und [Vue.js] ist grundlegend. In diesen Frameworks sind die Daten reaktiv (Signals, [ref]): Das Framework weiß, welche Daten ein Abschnitt der Seite verwendet, und aktualisiert nur diesen Abschnitt. [React] verfolgt einen einfacheren Ansatz: Bei jeder Zustandsänderung führt es die gesamte Komponentenfunktion (und die ihrer Kinder) erneut aus und vergleicht dann das Ergebnis mit dem vorherigen. Der Code liest sich dann wie eine gewöhnliche Funktion: Die berechneten Werte sind Variablen, und die Bedingungen sind das [if]. Der Preis dafür: Man muss einige Regeln beachten (den Zustand nie direkt ändern, die Hooks stets in derselben Reihenfolge aufrufen) und die Effekte samt ihren Abhängigkeiten bedenken.
2.3. Beispiel 03: Die JSX-Syntax
JSX ist HTML, das im [TypeScript]-Code geschrieben wird, wobei alles in geschweiften Klammern ein Ausdruck ist. Dieses Beispiel zeigt eine Liste von Ärzten an, die gefiltert werden kann:
| // =========================================================================
// 03-jsx/src/App.tsx - die JSX-Syntax
// -------------------------------------------------------------------------
// JSX ist HTML, das INNERHALB des TypeScript-Codes geschrieben wird. Jedes Tag wird zu
// einem Funktionsaufruf, und alles zwischen geschweiften Klammern ist ein gewöhnlicher
// TypeScript-Ausdruck:
// - attribute={expression} : der Wert eines Attributs (src, disabled...);
// - className={...} : die CSS-Klassen, ein String, den wir berechnen;
// - style={{ prop: value }} : ein OBJEKT mit CSS-Eigenschaften (camelCase);
// - {condition && <p/>} : ein Element, das nur existiert, wenn die
// Bedingung wahr ist;
// - {c ? <A/> : <B/>} : das eine ODER das andere;
// - {list.map((x) => <li key={x.id}/>)} : ein Element pro Element der
// Liste; key gibt jedem die IDENTITÄT.
// Keine besondere Syntax für Bedingungen und Schleifen: Es ist gewöhnliches
// TypeScript. Alles vor dem return ist gewöhnlicher Code.
// =========================================================================
import { useState } from 'react';
// ein TypeScript-Interface beschreibt die Form der Objekte der Liste
interface Doctor {
id: number;
title: string;
firstName: string;
lastName: string;
specialty: 'general practitioner' | 'pediatrician' | 'cardiologist';
available: boolean;
}
const DOCTORS: 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: 'cardiologist', available: true },
];
// „ein Block von mehreren, abhängig von einem Wert“: ein switch in einer Funktion
function icon(specialty: Doctor['specialty']) {
switch (specialty) {
case 'pediatrician':
return <span title="children">🧸</span>;
case 'cardiologist':
return <span title="heart">❤️</span>;
default:
return <span title="all patients">🩺</span>;
}
}
export default function App() {
const [doctors] = useState(DOCTORS);
const [filter, setFilter] = useState(''); // gesuchter Text
const [onlyAvailable, setOnlyAvailable] = useState(false);
const [showHelp, setShowHelp] = useState(true);
// die angezeigte Liste: eine gewöhnliche Variable, bei jedem Aufruf neu berechnet
const text = filter.trim().toLowerCase();
const displayed = doctors.filter(
(m) => (!onlyAvailable || m.available) && `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(text),
);
// „einer der drei Blöcke“: er wird VOR dem return mit ifs berechnet
let content;
if (doctors.length === 0) {
content = <p className="text-muted">No doctor.</p>;
} else if (displayed.length === 0) {
content = <p className="text-warning">No doctor matches "{filter}".</p>;
} else {
content = (
<table className="table">
<thead>
<tr><th>#</th><th>Doctor</th><th>Specialty</th><th>Status</th></tr>
</thead>
<tbody>
{/* eine Zeile pro Arzt; key: die Identität jeder Zeile, damit
React weiß, welche Zeile hinzuzufügen, zu verschieben oder zu entfernen ist */}
{displayed.map((m, i) => (
<tr key={m.id} className={m.available ? '' : 'opacity-50'}>
<td>{i + 1}</td>
<td>{m.title} {m.firstName} {m.lastName}</td>
<td>{icon(m.specialty)} {m.specialty}</td>
<td>
{/* ein String mit Klassen, berechnet durch einen Template-String */}
<span className={`badge ${m.available ? 'text-bg-success' : 'text-bg-secondary'}`}>
{m.available ? 'available' : 'unavailable'}
</span>
</td>
</tr>
))}
</tbody>
</table>
);
}
return (
// <> ... </>: ein „Fragment“, um mehrere Elemente zurückzugeben, ohne sie
// in ein zusätzliches HTML-Element zu verpacken
<>
<div className="container py-4">
<h1 className="h3 mb-3">
{/* das Bild liegt im Ordner public/ des Beispiels: wird unverändert ausgeliefert */}
<img src="/doctor.svg" alt="logo" width={32} height={32} /> Example 03 - the JSX syntax
</h1>
<div className="d-flex flex-wrap gap-3 align-items-center mb-3">
<input className="form-control w-auto" placeholder="search..." value={filter}
onChange={(e) => setFilter(e.target.value)} />
<label className="form-check-label">
<input type="checkbox" className="form-check-input" checked={onlyAvailable}
onChange={(e) => setOnlyAvailable(e.target.checked)} /> available only
</label>
<button className="btn btn-sm btn-outline-secondary" onClick={() => setShowHelp((a) => !a)}>
{showHelp ? 'Hide help' : 'Show help'}
</button>
</div>
{/* &&: der Absatz EXISTIERT nur, wenn showHelp wahr ist */}
{showHelp && (
<p className="alert alert-info">Type a name or a specialty. Unavailable doctors are greyed out.</p>
)}
{content}
{/* style: ein Objekt; eine einzelne Zahl wird als Pixel verstanden */}
<p style={{ fontSize: 12 + displayed.length * 2 }}>
{displayed.length} doctor(s) displayed - the size of this text depends on it.
</p>
</div>
</>
);
}
|
- Zeilen 22–27: Eine [TypeScript]-Schnittstelle beschreibt das Format der Objekte in der Liste; [specialty] kann nur drei Werte annehmen;
- Zeilen 38–47: „ein Block von mehreren, je nach Wert“. JSX hat dafür keine Syntax: Es ist eine gewöhnliche Funktion mit einem [switch], die JSX zurückgibt. [Doctor['specialty']] ist der Typ der Eigenschaft [specialty]. [🧸] ist eine HTML-Entität (ein Emoji), die in JSX erlaubt ist;
- Zeilen 50–53: der Zustand der Seite. Nur der Wert von [useState(DOCTORS)] wird beibehalten; er wird hier nie geändert;
- Zeilen 56–59: die angezeigte Liste: eine Variable, die bei jedem Aufruf der Komponente neu berechnet wird;
- Zeilen 62–68: einer von drei möglichen Inhalten, ausgewählt mit [if] vor [return]. Ein JSX-Abschnitt ist ein Wert wie jeder andere: Er kann in einer Variablen gespeichert werden;
- Zeilen 76–88: die Liste: [map] wandelt jeden Arzt in eine Zeile [<tr>] um. [i] ist die Position des Arztes in der Liste;
- Zeile 77: Das Attribut [key] identifiziert jede Zeile. Wenn sich die Liste ändert, ermittelt [React] anhand dessen, welche Zeile hinzuzufügen, zu verschieben oder zu löschen ist, statt die gesamte Liste neu aufzubauen. Der Schlüssel muss unter den Elementen der Liste eindeutig und stabil sein (von einer Anzeige zur nächsten derselbe): ein Bezeichner, nicht die Position. [React] meldet in der Konsole, dass die Liste keine Schlüssel hat;
- Zeile 77: Die CSS-Klassen sind eine berechnete Zeichenkette, hier mit dem Operator [? :];
- Zeile 80: das JSX, das von der Funktion [icon] zurückgegeben wird;
- Zeile 83: Ein Template-String ([
badge ${...}]) erzeugt die Liste der Klassen: [badge] und eine berechnete Klasse.
Das [return]:
- Zeile 97: Ein Fragment, [<>...</>], erlaubt es, mehrere Elemente zurückzugeben, ohne sie in ein zusätzliches HTML-Element zu verpacken (hier gibt es nur eines – das dient lediglich dem Beispiel);
- Zeile 101: Das Bild liegt im Ordner [public/] des Beispiels: [Vite] liefert es unverändert im Stammverzeichnis der Website aus. [width={32}]: ein numerischer Wert in geschweiften Klammern;
- Zeilen 105–106: das Suchfeld, das kontrolliert ist; bei einer Checkbox werden [checked] gelesen und geschrieben;
- Zeile 111: Eine „Pfeilfunktion“, die direkt im Attribut geschrieben ist: Sie schaltet den Zustand um;
- Zeilen 117–119: [condition && <p>...</p>]: Der Absatz existiert nur, wenn die Bedingung wahr ist (ist sie falsch, zeigt [React] für [false], [null] oder [undefined] nichts an). Achten Sie auf diese Falle: [{list.length && <p/>}] würde bei einer leeren Liste „0“ anzeigen; schreiben Sie stattdessen [list.length > 0 && ...];
- Zeile 121: der oben ausgewählte Inhalt;
- Zeile 124: Das Attribut [style] erhält ein Objekt (daher die doppelten geschweiften Klammern: der Ausdruck, dann das Objekt), dessen CSS-Eigenschaften in „camelCase“ geschrieben werden ([fontSize] für [font-size]). Eine einzelne Zahl wird als Pixel interpretiert.

Geben Sie „gen“ ein und aktivieren Sie „nur verfügbare“, geben Sie dann „zzz“ ein:

2.4. Beispiel 04: Ereignisse
| // =========================================================================
// 04-events/src/App.tsx - auf Aktionen des Benutzers reagieren
// -------------------------------------------------------------------------
// onEvent={function}: die Funktion wird aufgerufen, wenn das Element dieses
// Ereignis auslöst:
// - onClick={f} ruft f(event) auf;
// - onClick={() => remove(t)} eine Pfeilfunktion, um eigene
// Argumente zu übergeben;
// - das empfangene Ereignis ist ein „synthetisches Ereignis“ von React, das dieselbe
// Schnittstelle hat wie das Ereignis des Browsers (preventDefault(),
// target, key...); event.nativeEvent liefert das ursprüngliche Ereignis;
// - useRef: eine REFERENZ auf ein HTML-Element (ref={field}), um das Element
// selbst zu lesen oder zu steuern (field.current.value, .focus()...).
// Hier gibt es keinen Zustand für das Eingabefeld: Wir lesen es selbst aus.
// =========================================================================
import { useRef, useState, type FormEvent, type KeyboardEvent, type MouseEvent } from 'react';
interface Task {
id: number;
label: string;
done: boolean;
}
// der Stil des anklickbaren Bereichs: ein Objekt, wie beim Attribut style
const areaStyle = { background: '#e7f5ff', height: 80, cursor: 'crosshair' };
export default function App() {
const [tasks, setTasks] = useState<Task[]>([
{ id: 1, label: 'Install Node.js', done: true },
{ id: 2, label: 'Read the chapter on events', done: false },
]);
const [log, setLog] = useState<string[]>([]);
// eine Referenz auf das <input> der neuen Aufgabe (null, solange es nicht angezeigt wird)
const field = useRef<HTMLInputElement>(null);
// eine Referenz kann auch einen Wert halten, der NICHT angezeigt wird: Ihn zu
// ändern ruft die Komponente nicht erneut auf
const nextId = useRef(3);
function trace(message: string) {
setLog((j) => [`${new Date().toLocaleTimeString()} ${message}`, ...j]);
}
// onSubmit: Eingabetaste im Feld ODER Klick auf die Schaltfläche. preventDefault()
// verhindert, dass der Browser das Formular sendet (und die Seite neu lädt)
function add(event: FormEvent<HTMLFormElement>) {
event.preventDefault();
const input = field.current!;
const label = input.value.trim();
if (label === '') {
return;
}
// ein Zustand, der ein Array enthält: Er wird durch ein neues Array ERSETZT
// (das alte wird nie verändert: React würde die Änderung nicht bemerken)
setTasks((t) => [...t, { id: nextId.current++, label, done: false }]);
trace(`added "${label}"`);
input.value = '';
input.focus();
}
// eine Taste: event.key liefert ihren Namen
function onKeyDown(event: KeyboardEvent<HTMLInputElement>) {
if (event.key === 'Escape') {
event.currentTarget.value = '';
}
}
function toggle(task: Task, done: boolean) {
setTasks((t) => t.map((x) => (x.id === task.id ? { ...x, done } : x)));
trace(`"${task.label}": ${done ? 'done' : 'to do'}`);
}
function remove(task: Task) {
setTasks((t) => t.filter((x) => x.id !== task.id));
trace(`removed "${task.label}"`);
}
// das ursprüngliche Ereignis (nativeEvent) enthält die Koordinaten relativ zum Bereich
function position(event: MouseEvent<HTMLDivElement>) {
trace(`click at (${event.nativeEvent.offsetX}, ${event.nativeEvent.offsetY})`);
}
return (
<div className="container py-4">
<h1 className="h3 mb-3">Example 04 - events</h1>
<form className="d-flex gap-2 mb-3" onSubmit={add}>
<input ref={field} className="form-control" placeholder="new task (Esc to clear)" onKeyDown={onKeyDown} />
<button type="submit" className="btn btn-primary">Add</button>
</form>
<ul className="list-group mb-3">
{tasks.map((t) => (
<li key={t.id} className="list-group-item d-flex align-items-center gap-2">
{/* e.target: die Checkbox DIESER Zeile; checked: ihr Zustand */}
<input type="checkbox" className="form-check-input" checked={t.done}
onChange={(e) => toggle(t, e.target.checked)} />
<span className={`flex-grow-1 ${t.done ? 'text-decoration-line-through text-muted' : ''}`}>{t.label}</span>
{/* eine Pfeilfunktion: die Aufgabe DIESER Zeile als Argument */}
<button className="btn btn-sm btn-outline-danger" onClick={() => remove(t)}>Delete</button>
</li>
))}
</ul>
<div className="p-3 mb-3 rounded" style={areaStyle} onClick={position}>Click in this area</div>
<h2 className="h6">Log</h2>
<ul className="small">
{log.map((line, i) => (
// key: der Rang der Zeile, gezählt ab der ERSTEN hinzugefügten (die
// immer den key 1 hat): Jede Zeile behält denselben key, wenn andere
// oben in der Liste hinzukommen
<li key={log.length - i}>{line}</li>
))}
</ul>
</div>
);
}
|
- Zeile 17: [FormEvent], [KeyboardEvent], [MouseEvent] sind Ereignistypen von [React] (daher der Begriff [type]);
- Zeile 26: der Stil des anklickbaren Bereichs, ein Objekt;
- Zeile 35: [useRef] erzeugt eine Referenz: ein Objekt [{ current: ... }] , das [React] von einer Anzeige zur nächsten beibehält. Wird sie dem Attribut [ref] eines Elements zugewiesen (Zeile 88), verweist sie nach der Anzeige auf das HTML-Element selbst: [field.current.value], [field.current.focus()] ...;
- Zeile 38: Eine Referenz kann auch einen beliebigen Wert speichern, der nicht angezeigt wird. Ihre Änderung ([nextId.current++]) lädt die Komponente im Gegensatz zu einem Zustand nicht neu;
- Zeilen 46–59: wird vom Ereignis [onSubmit] des Formulars aufgerufen, das ausgelöst wird, wenn Sie im Feld die Eingabetaste drücken ODER auf den Button [submit] klicken:
- Zeile 47: verhindert, dass der Browser das Formular an den Server sendet, was die Seite neu laden würde;
- Zeile 48: das Element [<input>]; das Zeichen [!] bestätigt, dass es existiert (es ist angezeigt);
- Zeile 55: ein Zustand, der ein Array enthält: Er wird durch ein neues Array ersetzt ([[...t, newTask]]: die Elemente von [t], gefolgt von der neuen Aufgabe). Wir ändern NIEMALS den Zustand selbst ([t.push(...)]): [React] vergleicht den alten und den neuen Wert; handelt es sich um dasselbe Array, schließt es daraus, dass sich nichts geändert hat, und zeigt nichts an;
- Zeilen 57–58: Das Feld wird geleert und erhält wieder den Fokus, direkt am HTML-Element;
- Zeilen 62–66: [event.key] gibt den Namen der Taste zurück. [currentTarget] ist das Element, das den Handler besitzt (hier das Feld);
- Zeile 69: ein Array-Element ändern: ein neues Array, in dem das betreffende Element durch eine geänderte Kopie ersetzt wird ([{ ...x, done }]);
- Zeile 74: ein Element löschen: ein neues Array ohne dieses Element;
- Zeilen 79–81: Das Ereignis von [React] ist ein „synthetisches“ Ereignis, das dieselbe Schnittstelle wie das Ereignis des Browsers hat; [nativeEvent] liefert das ursprüngliche Ereignis, hier mit den Klickkoordinaten relativ zum Bereich ([offsetX]).
JSX:
- Zeile 87: der Handler des Formulars;
- Zeile 88: die Referenz und ein Tastenhandler. Dieses Feld ist nicht kontrolliert (kein [value]): Der Browser verwaltet seinen Wert, der bei Bedarf gelesen wird;
- Zeilen 96–97: Ein Handler wird an Ort und Stelle geschrieben: eine Pfeilfunktion, die [toggle] mit der Aufgabe DIESER Zeile aufruft;
- Zeile 100: dasselbe Prinzip: [onClick={remove(t)}] würde [remove] sofort aufrufen, noch während der Anzeige;
- Zeile 113: der Schlüssel für die Zeilen des Protokolls.
Fügen Sie eine Aufgabe hinzu, haken Sie die zweite ab, löschen Sie die erste und klicken Sie dann in das Feld:

2.5. Beispiel 05: Kontrollierte Felder
Ein Formular mit allen Feldtypen, die an den Zustand gebunden sind:
| // =========================================================================
// 05-controlled-fields/src/App.tsx - alle Feldtypen, „kontrolliert“
// -------------------------------------------------------------------------
// Ein KONTROLLIERTES Feld zeigt einen Wert des Zustands an (value={...}) und meldet
// der Komponente jede Änderung (onChange={...}), die den
// Zustand aktualisiert. Der Zustand ist die einzige Quelle der Wahrheit: Eine Eingabe im Feld ändert
// den Zustand, und eine Änderung des Zustands (per Code) ändert das Feld.
// Es ist das „Two-Way“-Binding, von Hand geschrieben. Was im Ereignis gelesen
// wird, hängt vom Feld ab:
// - text input, textarea -> e.target.value (String)
// - input type="number" -> e.target.valueAsNumber (NaN, wenn leer)
// - checkbox -> e.target.checked (boolean)
// - radio buttons -> e.target.value der gewählten Schaltfläche
// - select -> e.target.value
// - select multiple -> e.target.selectedOptions (mehrere)
// - input type="date" -> e.target.value, "yyyy-MM-dd"
// Dasselbe Formular wie Beispiel 18 des NestJS-Kurses; aber hier gibt es keinen
// Server: Alles geschieht im Browser.
// =========================================================================
import { useState, type FormEvent } from 'react';
const TITLES = ['Mr', 'Mme', 'Melle'];
const HOBBIES = ['sport', 'music', 'reading', 'cinema'];
const COUNTRIES = [
{ code: 'fr', label: 'France' },
{ code: 'be', label: 'Belgium' },
{ code: 'ch', label: 'Switzerland' },
];
export default function App() {
// ein Zustand pro Feld des Formulars
const [title, setTitle] = useState('Mme');
const [name, setName] = useState('');
const [age, setAge] = useState<number | null>(30);
const [presentation, setPresentation] = useState('');
const [newsletter, setNewsletter] = useState(false);
const [hobbies, setHobbies] = useState<string[]>(['reading']);
const [country, setCountry] = useState('fr');
const [languages, setLanguages] = useState<string[]>([]);
const [birthDate, setBirthDate] = useState('');
const [sent, setSent] = useState<string | null>(null);
// alle Werte, in einem Objekt zusammengefasst (was an einen Server gesendet würde)
const model = { title, name: name.trim(), age, presentation, newsletter, hobbies, country, languages, birthDate };
// mehrere Kästchen für EIN Array: Der Wert wird hinzugefügt oder entfernt
function toggleHobby(hobby: string, checked: boolean) {
setHobbies((l) => (checked ? [...l, hobby] : l.filter((x) => x !== hobby)));
}
function send(event: FormEvent<HTMLFormElement>) {
event.preventDefault(); // kein Senden an den Server, kein Neuladen
setSent(JSON.stringify(model));
}
return (
<div className="container py-4">
<h1 className="h3 mb-3">Example 05 - controlled fields</h1>
<div className="row g-4">
<form className="col-md-7" onSubmit={send}>
<div className="mb-3">
<span className="form-label d-block">Title</span>
{/* Radiobuttons: derselbe Zustand; checked gibt an, welcher ausgewählt ist */}
{TITLES.map((t) => (
<div key={t} className="form-check form-check-inline">
<input type="radio" className="form-check-input" name="title" id={`title-${t}`} value={t}
checked={title === t} onChange={(e) => setTitle(e.target.value)} />
<label className="form-check-label" htmlFor={`title-${t}`}>{t}</label>
</div>
))}
</div>
<div className="row g-3 mb-3">
<div className="col-8">
<label className="form-label" htmlFor="name">Name</label>
<input id="name" className="form-control" value={name} onChange={(e) => setName(e.target.value)} />
</div>
<div className="col-4">
<label className="form-label" htmlFor="age">Age</label>
{/* ein leeres Feld liefert NaN: Im Zustand wird null gespeichert, im Feld '' */}
<input id="age" type="number" className="form-control" value={age ?? ''}
onChange={(e) => setAge(Number.isNaN(e.target.valueAsNumber) ? null : e.target.valueAsNumber)} />
</div>
</div>
<div className="mb-3">
<label className="form-label" htmlFor="presentation">About you (updated when leaving the field)</label>
{/* ein UNkontrolliertes Feld: defaultValue ist sein Anfangswert, dann
verwaltet der Browser es allein; onBlur benachrichtigt nur beim Verlassen */}
<textarea id="presentation" rows={2} className="form-control" defaultValue={presentation}
onBlur={(e) => setPresentation(e.target.value)} />
</div>
<div className="mb-3 form-check">
{/* ein einzelnes Kästchen: true / false */}
<input id="newsletter" type="checkbox" className="form-check-input" checked={newsletter}
onChange={(e) => setNewsletter(e.target.checked)} />
<label htmlFor="newsletter" className="form-check-label">Receive the newsletter</label>
</div>
<div className="mb-3">
<span className="form-label d-block">Hobbies</span>
{HOBBIES.map((l) => (
<div key={l} className="form-check form-check-inline">
<input type="checkbox" className="form-check-input" id={`hobby-${l}`} checked={hobbies.includes(l)}
onChange={(e) => toggleHobby(l, e.target.checked)} />
<label className="form-check-label" htmlFor={`hobby-${l}`}>{l}</label>
</div>
))}
</div>
<div className="row g-3 mb-3">
<div className="col-6">
<label className="form-label" htmlFor="country">Country</label>
{/* value am <select> (und nicht selected an den <option>s) */}
<select id="country" className="form-select" value={country} onChange={(e) => setCountry(e.target.value)}>
{COUNTRIES.map((p) => (
<option key={p.code} value={p.code}>{p.label}</option>
))}
</select>
</div>
<div className="col-6">
<label className="form-label" htmlFor="languages">Spoken languages</label>
{/* multiple: value ist ein ARRAY; selectedOptions, die gewählten Optionen */}
<select id="languages" multiple size={3} className="form-select" value={languages}
onChange={(e) => setLanguages([...e.target.selectedOptions].map((o) => o.value))}>
<option value="fr">French</option>
<option value="en">English</option>
<option value="es">Spanish</option>
</select>
</div>
</div>
<div className="mb-3">
<label className="form-label" htmlFor="birthDate">Date of birth</label>
<input id="birthDate" type="date" className="form-control w-auto" value={birthDate}
onChange={(e) => setBirthDate(e.target.value)} />
</div>
<button type="submit" className="btn btn-primary">Send</button>
</form>
<div className="col-md-5">
<h2 className="h6">The model, live</h2>
{/* JSON.stringify(object, null, 2): das JSON, mit 2 Leerzeichen eingerückt */}
<pre className="bg-light p-2 rounded small">{JSON.stringify(model, null, 2)}</pre>
{sent !== null && (
<>
<h2 className="h6">Last sending</h2>
<pre className="bg-success-subtle p-2 rounded small text-wrap">{sent}</pre>
</>
)}
</div>
</div>
</div>
);
}
|
Das Prinzip (Zeilen 4–6): Ein kontrolliertes Feld zeigt einen Wert aus dem Zustand an ([value={...}]) und benachrichtigt die Komponente über jede Änderung ([onChange={...}]), die dann den Zustand aktualisiert. Der Zustand ist die einzige Quelle der Wahrheit: Das Feld zeigt lediglich an, was der Zustand vorgibt. Würde der [onChange]-Handler den Zustand nicht aktualisieren, würde das Feld keine Benutzereingaben annehmen.
- Zeilen 33–41: ein Zustand pro Feld;
- Zeile 45: alle Werte in einem einzigen Objekt zusammengefasst – das, was an einen Server gesendet würde. Das ist ein berechneter Wert; [name.trim()] entfernt führende und nachgestellte Leerzeichen;
- Zeilen 48–50: mehrere Checkboxen für EIN Array: Der Wert wird hinzugefügt oder entfernt;
- Zeilen 52–55: das Formular absenden, ohne die Seite neu zu laden.
JSX, Feld für Feld:
- Zeilen 65–68: Radiobuttons: Sie teilen sich denselben Zustand; [checked] gibt an, welcher ausgewählt ist. [key={t}]: der Schlüssel jedes Buttons;
- Zeile 76: ein Textfeld;
- Zeilen 81–82: ein numerisches Feld: Ein leeres Feld liefert [NaN]; wir speichern dann [null] im Zustand und zeigen [''] an ([age ?? '']: [''] , wenn [age] gleich [null] oder [undefined] ist);
- Zeilen 89–90: ein nicht kontrolliertes Feld: [defaultValue] ist sein Anfangswert, danach kümmert sich der Browser selbst darum; [onBlur] benachrichtigt die Komponente, wenn das Feld verlassen wird. Der Zustand wird daher erst beim Verlassen des Felds aktualisiert;
- Zeile 94: eine einzelne Checkbox: [checked] und [e.target.checked];
- Zeilen 100–103: die Checkboxen für die Hobbys;
- Zeile 112: eine Liste: [value] an [<select>], nicht [selected] an [<option>];
- Zeilen 121–122: eine Liste mit Mehrfachauswahl: [value] ist ein Array; [e.target.selectedOptions] liefert die ausgewählten Optionen, die in ein Array von Werten umgewandelt werden ([[...list]] wandelt eine Sammlung in ein Array um);
- Zeile 131: ein Datum in Form einer Zeichenkette [yyyy-MM-dd];
- Zeile 140: das Template im JSON-Format, mit 2 Leerzeichen eingerückt.

Das Schreiben von [value] und [onChange] in jedem Feld ist repetitiv: Das ist der Preis für die Einfachheit von [React], das kein Pendant zu [v-model] bei [Vue.js] oder zu [[(ngModel)]] bei [Angular] hat. Die folgenden Beispiele zeigen, wie sich diese Wiederholung verringern lässt: ein einziges Zustandsobjekt (Beispiel 06), eine Funktion, die die Attribute eines Felds erzeugt (Beispiele 06 und 07), und eine Bibliothek (Beispiel 08).
| // =========================================================================
// 06-use-reducer/src/App.tsx - ein Formular, ein Objekt, ein Reducer
// -------------------------------------------------------------------------
// Beispiel 05 hatte ein useState pro Feld. Für ein echtes Formular
// bevorzugen wir EIN Objekt, das alle Werte enthält, das MODELL, und
// beschreiben seine Änderungen in einer einzigen Funktion, dem REDUCER:
//
// reducer(currentState, action) -> newState
//
// useReducer(reducer, initialState) liefert den Zustand und eine Funktion
// dispatch(action): Die Komponente ändert den Zustand nicht mehr selbst, sie BESCHREIBT, was
// geschehen ist ({ type: 'edit', field: 'lastName', value: 'Dupont' }), und der
// Reducer leitet daraus den neuen Zustand ab. Die gesamte Logik steht an einer Stelle,
// und es ist eine REINE Funktion (gleiche Eingabe, gleiche Ausgabe, kein
// Seiteneffekt), leicht zu testen.
//
// Der Zustand merkt sich außerdem für jedes Feld, ob es „berührt“ wurde (mindestens
// einmal verlassen); daraus leiten wir ab, ob es „geändert“ ist (sein Wert weicht vom
// Anfangswert ab) und ob es deaktiviert ist.
// =========================================================================
import { useReducer, type ChangeEvent } from 'react';
// die Form der Daten des Formulars
interface Profile {
title: string;
firstName: string;
lastName: string;
age: number;
newsletter: boolean;
email: string;
country: string;
birthDate: string;
presentation: string;
}
const INITIAL: Profile = {
title: 'Mme',
firstName: 'Marie',
lastName: 'PELISSIER',
age: 30,
newsletter: false,
email: '',
country: 'fr',
birthDate: '',
presentation: '',
};
type Field = keyof Profile; // 'title' | 'firstName' | ...: der Name eines Feldes
interface State {
values: Profile;
touched: Partial<Record<Field, boolean>>; // die bereits verlassenen Felder
}
// die möglichen Aktionen: eine „diskriminierte Union“ über die Eigenschaft type
type Action =
| { type: 'edit'; field: Field; value: Profile[Field] }
| { type: 'leave'; field: Field }
| { type: 'uppercase' }
| { type: 'reset' };
// der Reducer: Er verändert den erhaltenen Zustand NIE, er gibt einen neuen zurück
function reducer(state: State, action: Action): State {
switch (action.type) {
case 'edit':
return { ...state, values: { ...state.values, [action.field]: action.value } };
case 'leave':
return { ...state, touched: { ...state.touched, [action.field]: true } };
case 'uppercase': {
const { firstName, lastName } = state.values;
return { ...state, values: { ...state.values, firstName: firstName.toUpperCase(), lastName: lastName.toUpperCase() } };
}
case 'reset':
return { values: { ...INITIAL }, touched: {} };
}
}
const TITLES = ['Mr', 'Mme', 'Melle'];
const TRACKED_FIELDS: Field[] = ['firstName', 'lastName', 'age', 'email'];
export default function App() {
const [state, dispatch] = useReducer(reducer, { values: { ...INITIAL }, touched: {} });
const v = state.values;
// aus dem Zustand ABGELEITETE Werte
const modified = (c: Field) => v[c] !== INITIAL[c];
const disabled = (c: Field) => c === 'email' && !v.newsletter; // die E-Mail setzt den Newsletter voraus
const formModified = (Object.keys(INITIAL) as Field[]).some(modified);
// die für ein Textfeld gemeinsamen Attribute: eine Funktion, die sie aufbaut
// (id, value, onChange, onBlur, disabled), um sie auf das Element zu „spreaden“: {...bind('lastName')}
function bind(field: 'firstName' | 'lastName' | 'email' | 'birthDate' | 'presentation' | 'country') {
return {
id: field,
value: v[field],
disabled: disabled(field),
onChange: (e: ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) =>
dispatch({ type: 'edit', field, value: e.target.value }),
onBlur: () => dispatch({ type: 'leave', field }),
};
}
return (
<div className="container py-4">
<h1 className="h3 mb-3">Example 06 - a form, an object, a reducer</h1>
<div className="row g-4">
<form className="col-md-7" onSubmit={(e) => e.preventDefault()}>
<div className="mb-3">
<span className="form-label d-block">Title</span>
{TITLES.map((t) => (
<div key={t} className="form-check form-check-inline">
<input type="radio" className="form-check-input" id={`title-${t}`} name="title" value={t}
checked={v.title === t} onChange={() => dispatch({ type: 'edit', field: 'title', value: t })} />
<label className="form-check-label" htmlFor={`title-${t}`}>{t}</label>
</div>
))}
</div>
<div className="row g-3 mb-3">
<div className="col-5">
<label className="form-label" htmlFor="firstName">First name</label>
{/* {...object}: jede Eigenschaft des Objekts wird zu einem Attribut */}
<input className="form-control" {...bind('firstName')} />
</div>
<div className="col-5">
<label className="form-label" htmlFor="lastName">Last name</label>
<input className="form-control" {...bind('lastName')} />
</div>
<div className="col-2">
<label className="form-label" htmlFor="age">Age</label>
<input id="age" type="number" className="form-control" value={v.age}
onChange={(e) => dispatch({ type: 'edit', field: 'age', value: e.target.valueAsNumber || 0 })}
onBlur={() => dispatch({ type: 'leave', field: 'age' })} />
</div>
</div>
<div className="row g-3 mb-3 align-items-end">
<div className="col-5">
<div className="form-check">
<input id="newsletter" type="checkbox" className="form-check-input" checked={v.newsletter}
onChange={(e) => dispatch({ type: 'edit', field: 'newsletter', value: e.target.checked })} />
<label htmlFor="newsletter" className="form-check-label">Receive the newsletter</label>
</div>
</div>
<div className="col-7">
<label className="form-label" htmlFor="email">E-mail (if newsletter)</label>
<input type="email" className="form-control" {...bind('email')} />
</div>
</div>
<div className="row g-3 mb-3">
<div className="col-6">
<label className="form-label" htmlFor="country">Country</label>
<select className="form-select" {...bind('country')}>
<option value="fr">France</option>
<option value="be">Belgium</option>
<option value="ch">Switzerland</option>
</select>
</div>
<div className="col-6">
<label className="form-label" htmlFor="birthDate">Date of birth</label>
<input type="date" className="form-control" {...bind('birthDate')} />
</div>
</div>
<div className="mb-3">
<label className="form-label" htmlFor="presentation">About you</label>
<textarea rows={2} className="form-control" {...bind('presentation')} />
</div>
<div className="d-flex gap-2">
<button type="button" className="btn btn-outline-primary" onClick={() => dispatch({ type: 'uppercase' })}>
Name in uppercase
</button>
<button type="button" className="btn btn-outline-secondary" onClick={() => dispatch({ type: 'reset' })}>
Reset
</button>
</div>
</form>
<div className="col-md-5">
<h2 className="h6">The model, live</h2>
<pre className="bg-light p-2 rounded small">{JSON.stringify(v, null, 2)}</pre>
<h2 className="h6">The state of the fields</h2>
<table className="table table-sm small">
<thead><tr><th>field</th><th>touched</th><th>modified</th><th>disabled</th></tr></thead>
<tbody>
{TRACKED_FIELDS.map((c) => (
<tr key={c}>
<td>{c}</td>
<td>{String(state.touched[c] ?? false)}</td>
<td>{String(modified(c))}</td>
<td>{String(disabled(c))}</td>
</tr>
))}
</tbody>
</table>
<p className="small mb-0">form modified: <strong>{String(formModified)}</strong></p>
</div>
</div>
</div>
);
}
|
- Zeilen 25–35: die Datenstruktur des Formulars; [INITIAL] (Zeilen 37–47), ihre Anfangswerte;
- Zeile 49: [keyof Profile] ist der Typ der Eigenschaftsnamen von [Profile]: ['title' | 'firstName' | ...];
- Zeilen 51–54: der vollständige Zustand: die Werte und die Felder, die bereits „besucht“ wurden (mindestens einmal verlassen). [Partial<Record<Field, boolean>>]: ein Objekt, dessen Schlüssel Feldnamen sind, die alle optional sind;
- Zeilen 57–61: die möglichen Aktionen in Form einer „diskriminierten Union“: Jede Aktion hat eine Eigenschaft [type], die angibt, um welche Aktion es sich handelt, sowie ihre eigenen Daten;
- Zeilen 64–77: der Reducer: eine Funktion, die den aktuellen Zustand und eine Aktion entgegennimmt und den NEUEN Zustand zurückgibt. Sie ändert nie den erhaltenen Zustand (sie erzeugt eine geänderte Kopie, [{ ...state, ... }]) und tut sonst nichts: Es ist eine reine Funktion, leicht zu verstehen und zu testen. [[action.field]: action.value]: eine Eigenschaft, deren Name berechnet wird;
- Zeile 83: [useReducer(reducer, initialState)] gibt den Zustand und eine Funktion [dispatch(action)] zurück: Die Komponente ändert den Zustand nicht mehr, sondern beschreibt, was geschehen ist ([dispatch({ type: 'leave', field: 'lastName' })]), und [React] ruft den Reducer auf, um den neuen Zustand abzuleiten;
- Zeilen 87–89: aus dem Zustand abgeleitete Werte: Ein Feld ist „geändert“, wenn sich sein Wert vom Anfangswert unterscheidet; die E-Mail-Adresse ist deaktiviert, solange die Checkbox „Newsletter“ nicht angehakt ist;
- Zeilen 93–102: eine Funktion, die die gemeinsamen Attribute eines Felds erzeugt: [id], [value], [disabled], [onChange], [onBlur]. Diese werden mit der Syntax [{...object}] (Zeile 123) auf das Element „angewendet“: Jede Eigenschaft des Objekts wird zu einem Attribut. Eine einzige Zeile genügt dann, um ein Feld mit dem Formular zu verbinden.
In JSX rufen bestimmte Felder (Radiobuttons, Alter, Checkbox) [dispatch] direkt auf; die Buttons „Name in Großbuchstaben“ und „Zurücksetzen“ lösen die entsprechenden Aktionen aus. Rechts sehen Sie das Live-Template und den Zustand der Felder.
Geben Sie einen Vornamen ein, geben Sie einen Nachnamen ein, haken Sie das Newsletter-Kästchen an, geben Sie eine E-Mail-Adresse ein und klicken Sie dann auf „Name in Großbuchstaben“:

[useState] eignet sich für unabhängige Daten; [useReducer] ist für einen zusammengesetzten Zustand gedacht, bei dem Änderungen Regeln folgen: Die gesamte Logik steht an einer Stelle, außerhalb der Komponente. Es ist dasselbe Konzept wie die „Stores“ von [Redux] oder [Vuex], aber auf Komponentenebene.
| // =========================================================================
// 07-validation/src/App.tsx - ein Formular im Browser validieren
// -------------------------------------------------------------------------
// React hat kein Validierungssystem: Es ist gewöhnlicher Code. Eine
// REINE Funktion, validate(account), liefert die Fehler der Felder; sie wird
// bei jeder Anzeige aufgerufen, die Fehler sind also immer aktuell.
// Sie werden nicht sofort angezeigt (ein komplett rot markiertes leeres Formular
// ist unangenehm): nur für ein bereits verlassenes („berührtes“) Feld. Das Absenden
// markiert alle Felder als berührt und handelt dann nur, wenn das Formular
// gültig ist.
//
// Dieselben Regeln wie beim RdvMedecins-Server (Formular „Konto erstellen“).
// ACHTUNG: Diese Validierung ist nur eine ERLEICHTERUNG für den Benutzer (eine
// sofortige Antwort, ohne Hin und Zurück zum Server). Sie schützt
// nichts: Jeder kann dem Server eine von Hand gebaute Anfrage
// senden (curl...). Der Server validiert daher IMMER alles erneut (vgl. Beispiel 25).
// =========================================================================
import { useState, type FormEvent } from 'react';
interface Account {
title: string;
firstName: string;
lastName: string;
login: string;
password: string;
confirmation: string;
}
type Field = keyof Account;
// höchstens eine Fehlermeldung pro Feld
type Errors = Partial<Record<Field, string>>;
const TITLES = ['Mr', 'Mme', 'Melle'];
const LOGIN_FORMAT = /^[a-z0-9._-]{1,30}$/;
const PASSWORD_MIN = 6;
// die Regeln: eine reine Funktion, die nur von ihren Argumenten abhängt
function validate(c: Account): Errors {
const errors: Errors = {};
if (!TITLES.includes(c.title)) errors.title = 'Choose a title from the list.';
if (c.firstName.trim() === '') errors.firstName = 'The first name is required.';
else if (c.firstName.length > 20) errors.firstName = 'The first name must not exceed 20 characters.';
if (c.lastName.trim() === '') errors.lastName = 'The last name is required.';
else if (c.lastName.length > 20) errors.lastName = 'The last name must not exceed 20 characters.';
if (c.login === '') errors.login = 'The login is required.';
else if (!LOGIN_FORMAT.test(c.login)) errors.login = 'Unaccented lower-case letters, digits, dot, hyphen, underscore.';
if (c.password === '') errors.password = 'The password is required.';
else if (c.password.length < PASSWORD_MIN) errors.password = `At least ${PASSWORD_MIN} characters.`;
// eine Regel, die ZWEI Felder vergleicht
if (c.confirmation !== c.password) errors.confirmation = 'The confirmation does not match the password.';
return errors;
}
const EMPTY: Account = { title: 'Mr', firstName: '', lastName: '', login: '', password: '', confirmation: '' };
const ALL: Record<Field, boolean> = { title: true, firstName: true, lastName: true, login: true, password: true, confirmation: true };
export default function App() {
const [account, setAccount] = useState<Account>(EMPTY);
const [touched, setTouched] = useState<Partial<Record<Field, boolean>>>({});
const [submitAttempted, setSubmitAttempted] = useState(false);
const [success, setSuccess] = useState(false);
// die Fehler: bei jeder Anzeige neu berechnet, nie im Zustand gespeichert
const errors = validate(account);
const errorCount = Object.keys(errors).length;
// die Bootstrap-Klasse eines Feldes: rot (is-invalid) oder grün (is-valid),
// erst nachdem es berührt wurde
function cssClass(field: Field, base = 'form-control'): string {
if (!touched[field]) return base;
return `${base} ${errors[field] ? 'is-invalid' : 'is-valid'}`;
}
// die allen Feldern gemeinsamen Attribute
function bind(field: Field) {
return {
id: field,
value: account[field],
onChange: (e: { target: { value: string } }) => {
setAccount((c) => ({ ...c, [field]: e.target.value }));
setSuccess(false);
},
onBlur: () => setTouched((t) => ({ ...t, [field]: true })),
};
}
function send(event: FormEvent<HTMLFormElement>) {
event.preventDefault();
setSubmitAttempted(true);
setTouched(ALL); // alle Fehler erscheinen
// hier, das Konto würde an den Server gesendet (vgl. Beispiel 25)
setSuccess(errorCount === 0);
}
return (
<div className="container py-4" style={{ maxWidth: 640 }}>
<h1 className="h3 mb-3">Example 07 - the validation of a form</h1>
{/* noValidate: die eigene Validierung des Browsers ist deaktiviert, um
UNSERE Meldungen in UNSEREM Stil anzuzeigen */}
<form className="card p-4" noValidate onSubmit={send}>
<div className="mb-3">
<label className="form-label" htmlFor="title">Title</label>
<select className={cssClass('title', 'form-select')} {...bind('title')}>
{TITLES.map((t) => <option key={t}>{t}</option>)}
</select>
<div className="invalid-feedback">{errors.title}</div>
</div>
<div className="row g-3 mb-3">
<div className="col-sm-6">
<label className="form-label" htmlFor="firstName">First name</label>
{/* is-invalid umrandet das Feld rot UND zeigt die
darauffolgende .invalid-feedback an: dort steht der Fehler des Felds */}
<input className={cssClass('firstName')} {...bind('firstName')} />
<div className="invalid-feedback">{errors.firstName}</div>
</div>
<div className="col-sm-6">
<label className="form-label" htmlFor="lastName">Last name</label>
<input className={cssClass('lastName')} {...bind('lastName')} />
<div className="invalid-feedback">{errors.lastName}</div>
</div>
</div>
<div className="mb-3">
<label className="form-label" htmlFor="login">Login</label>
<input className={cssClass('login')} autoComplete="username" {...bind('login')} />
<div className="invalid-feedback">{errors.login}</div>
</div>
<div className="row g-3 mb-4">
<div className="col-sm-6">
<label className="form-label" htmlFor="password">Password</label>
<input type="password" className={cssClass('password')} autoComplete="new-password" {...bind('password')} />
<div className="invalid-feedback">{errors.password}</div>
</div>
<div className="col-sm-6">
<label className="form-label" htmlFor="confirmation">Confirmation</label>
<input type="password" className={cssClass('confirmation')} autoComplete="new-password" {...bind('confirmation')} />
<div className="invalid-feedback">{errors.confirmation}</div>
</div>
</div>
<button type="submit" className="btn btn-primary">Create the account</button>
{submitAttempted && errorCount > 0 && (
<div className="alert alert-danger mt-3 mb-0">The form contains {errorCount} error(s).</div>
)}
{success && <div className="alert alert-success mt-3 mb-0">Valid form: it could be sent to the server.</div>}
</form>
</div>
);
}
|
[React] hat kein Validierungssystem: Es ist ganz gewöhnlicher Code.
- Zeilen 30–32: höchstens eine Fehlermeldung pro Feld;
- Zeilen 39–53: die Regeln: eine reine Funktion, die die Feldfehler zurückgibt; es sind dieselben Regeln wie die des Servers [RdvMedecins] für die Kontoerstellung. Die letzte Regel vergleicht zwei Felder;
- Zeile 65: Die Fehler werden bei jeder Anzeige der Seite neu berechnet und nie zwischengespeichert; sie sind daher immer aktuell;
- Zeilen 70–73: die [Bootstrap]-Klasse für ein Feld – [is-invalid] (roter Rahmen) oder [is-valid] (grüner Rahmen) – erst nachdem das Feld besucht wurde: Ein leeres, komplett rot eingefärbtes Formular wäre unschön;
- Zeilen 76–86: wie in Beispiel 06 die gemeinsamen Attribute der Felder; das Verlassen eines Felds markiert es als besucht;
- Zeilen 88–94: Das Absenden des Formulars markiert die Felder als ausgefüllt (ihre Fehler erscheinen), und das Absenden gelingt nur, wenn das Formular gültig ist.
JSX:
- Zeile 101: Die browsereigene Validierung wird deaktiviert, um UNSERE Meldungen in UNSEREM Stil anzuzeigen;
- Zeilen 114–115: Die Klasse [is-invalid] rahmt das Feld rot ein UND zeigt das folgende Element [.invalid-feedback] an, in das der Feldfehler geschrieben wird.
Geben Sie einen Vornamen ein, geben Sie einen Nachnamen ein, geben Sie ein ungültiges Login ein:

Klicken Sie auf „Konto erstellen“:

Sobald alles korrigiert ist:

WARNUNG: Diese Validierung dient lediglich der Bequemlichkeit des Benutzers (eine sofortige Rückmeldung ohne Round-Trip zum Server). Sie bietet keinerlei Schutz: Jeder kann eine von Hand erstellte Anfrage an den Server senden ([curl] ...). Der Server validiert daher IMMER alles erneut (siehe Beispiel 25).
Das Formular aus Beispiel 07, geschrieben mit [React Hook Form], der am weitesten verbreiteten Formularbibliothek für [React]:
| // =========================================================================
// 08-react-hook-form/src/App.tsx - eine Formularbibliothek
// -------------------------------------------------------------------------
// Das Formular aus Beispiel 07, geschrieben mit React Hook Form, der meistgenutzten Formularbibliothek
// mit React. Man findet sie in den meisten
// bestehenden Anwendungen.
// - useForm<T>() liefert Werkzeuge für ein Formular vom Typ T;
// - register('lastName', rules) verknüpft ein HTML-Feld mit dem Feld "lastName" des
// Formulars: Es liefert die Attribute, die auf das Element zu spreaden sind (name,
// ref, onChange, onBlur). Die Felder sind NICHT kontrolliert: Die
// Bibliothek liest ihren Wert aus der Seite, ohne die
// Komponente bei jedem Tastenanschlag erneut aufzurufen;
// - die Regeln: required, maxLength, minLength, pattern, validate (eine
// „selbstgebaute“ Regel), jeweils mit ihrer Meldung;
// - formState.errors: die Fehler jedes Feldes;
// - handleSubmit(action): validiert alles; ruft die Aktion nur auf, wenn das
// Formular gültig ist.
// =========================================================================
import { useState } from 'react';
import { useForm } from 'react-hook-form';
interface Account {
title: string;
firstName: string;
lastName: string;
login: string;
password: string;
confirmation: string;
}
const TITLES = ['Mr', 'Mme', 'Melle'];
export default function App() {
const {
register,
handleSubmit,
getValues,
formState: { errors, isSubmitted },
} = useForm<Account>({
// die Anfangswerte
defaultValues: { title: 'Mr', firstName: '', lastName: '', login: '', password: '', confirmation: '' },
// wann validiert wird: beim Verlassen eines Feldes, danach bei jedem Tastenanschlag
mode: 'onTouched',
});
const [sent, setSent] = useState('');
// ein Feld wird als fehlerhaft markiert, wenn es einen Fehler hat (errors.lastName existiert)
const cssClass = (field: keyof Account) => `form-control${errors[field] ? ' is-invalid' : ''}`;
// von handleSubmit aufgerufen, NUR wenn das Formular gültig ist;
// es erhält die Werte, typisiert
function create(account: Account) {
setSent(JSON.stringify(account));
}
return (
<div className="container py-4" style={{ maxWidth: 640 }}>
<h1 className="h3 mb-3">Example 08 - React Hook Form</h1>
<form className="card p-4" noValidate onSubmit={handleSubmit(create, () => setSent(''))}>
<div className="mb-3">
<label className="form-label" htmlFor="title">Title</label>
<select id="title" className="form-select" {...register('title', { required: true })}>
{TITLES.map((t) => <option key={t}>{t}</option>)}
</select>
</div>
<div className="row g-3 mb-3">
<div className="col-sm-6">
<label className="form-label" htmlFor="firstName">First name</label>
<input id="firstName" className={cssClass('firstName')}
{...register('firstName', {
required: 'The first name is required.',
maxLength: { value: 20, message: '20 characters at most.' },
})} />
{/* errors.firstName?.message: die Meldung der fehlgeschlagenen Regel */}
<div className="invalid-feedback">{errors.firstName?.message}</div>
</div>
<div className="col-sm-6">
<label className="form-label" htmlFor="lastName">Last name</label>
<input id="lastName" className={cssClass('lastName')}
{...register('lastName', {
required: 'The last name is required.',
maxLength: { value: 20, message: '20 characters at most.' },
})} />
<div className="invalid-feedback">{errors.lastName?.message}</div>
</div>
</div>
<div className="mb-3">
<label className="form-label" htmlFor="login">Login</label>
<input id="login" className={cssClass('login')}
{...register('login', {
required: 'The login is required.',
pattern: { value: /^[a-z0-9._-]{1,30}$/, message: 'Unaccented lower-case letters, digits, dot, hyphen, underscore.' },
})} />
<div className="invalid-feedback">{errors.login?.message}</div>
</div>
<div className="row g-3 mb-4">
<div className="col-sm-6">
<label className="form-label" htmlFor="password">Password</label>
<input id="password" type="password" className={cssClass('password')}
{...register('password', {
required: 'The password is required.',
minLength: { value: 6, message: 'At least 6 characters.' },
// deps: wenn sich das Passwort ändert, die Bestätigung AUCH erneut validieren
deps: ['confirmation'],
})} />
<div className="invalid-feedback">{errors.password?.message}</div>
</div>
<div className="col-sm-6">
<label className="form-label" htmlFor="confirmation">Confirmation</label>
{/* validate: eine „selbstgebaute“ Regel; getValues liest ein ANDERES Feld */}
<input id="confirmation" type="password" className={cssClass('confirmation')}
{...register('confirmation', {
validate: (value) => value === getValues('password') || 'The confirmation does not match the password.',
})} />
<div className="invalid-feedback">{errors.confirmation?.message}</div>
</div>
</div>
<button type="submit" className="btn btn-primary">Create the account</button>
{isSubmitted && (
<div className={`alert mt-3 mb-0 ${sent ? 'alert-success' : 'alert-danger'}`}>
{sent ? <>Valid form: <code>{sent}</code></> : 'Invalid form.'}
</div>
)}
</form>
</div>
);
}
|
- Zeile 21: der Haupt-Hook der Bibliothek;
- Zeilen 35–40: [useForm<Account>(options)] gibt die Bestandteile eines Formulars vom Typ [Account] zurück, die ausgepackt werden: [register], [handleSubmit], [getValues] und [formState], den Zustand des Formulars (darunter [errors], die Feldfehler, und [isSubmitted], das nach dem ersten Absenden true ist);
- Zeile 42: die Anfangswerte;
- Zeile 44: wann validiert wird: beim Verlassen eines Felds, danach bei jedem Tastendruck;
- Zeile 49: Ein Feld wird als fehlerhaft markiert, wenn es einen Fehler enthält;
- Zeilen 53–55: die Absendeaktion, die von [handleSubmit] nur aufgerufen wird, wenn das Formular gültig ist; sie erhält die eingegebenen Werte;
- Zeile 60: [handleSubmit(onValid, onInvalid)] erzeugt den Absende-Handler: Er validiert alle Felder und ruft dann die eine oder die andere Funktion auf;
- Zeilen 71–74: [register('firstName', rules)] verknüpft das HTML-Feld mit dem Feld [firstName] des Formulars, und zwar mit dessen Regeln: [required], [maxLength], [minLength], [pattern] und [validate] (eine „benutzerdefinierte“ Regel), jeweils mit eigener Meldung. [register] liefert die Attribute, die auf das Element anzuwenden sind ([name], [ref], [onChange], [onBlur]). Die Felder sind NICHT kontrolliert: Die Bibliothek liest ihre Werte über die Referenz aus der Seite; die Komponente wird daher nicht bei jedem Tastenanschlag neu aufgerufen, was bei großen Formularen wichtig ist;
- Zeile 76: die Meldung der fehlgeschlagenen Validierungsregel ([?.]: [undefined] , wenn das Feld keine Fehler hat);
- Zeile 105: Wenn sich das Passwort ändert, wird auch die Bestätigung erneut validiert;
- Zeile 114: eine benutzerdefinierte Regel, die zwei Felder vergleicht: [getValues('password')] liest den Wert eines anderen Feldes. Sie liefert [true] (gültig) oder die Fehlermeldung.

Für [React] gibt es für jeden Bedarf mehrere konkurrierende Bibliotheken. Für Formulare begegnen uns außerdem [Formik], [TanStack Form] und, um die Regeln zu beschreiben, [Zod] oder [Yup] (Validierungs-„Schemas“, die mit einem [Node.js]-Server geteilt werden können). Für die Fallstudie, in der die gesamte Validierung vom Server übernommen wird, verwenden wir keine Bibliothek: Kontrollierte Felder und ein eigener Hook genügen.
[Angular] hat eigene „Pipes“, um einen Wert in einem Template zu formatieren. [React] kennt keinen eigenen Mechanismus: In JSX rufen wir Funktionen auf, die in einem Modul abgelegt sind. Für Datumsangaben, Zahlen und Beträge stellt der Browser die API [Intl] bereit, die die Konventionen jeder Sprache kennt.
| // =========================================================================
// 09-formatting/src/formatting.ts - „selbstgebaute“ Formatierungsfunktionen
// -------------------------------------------------------------------------
// React hat keinen eigenen Mechanismus zur Formatierung (Angular hat seine
// „Pipes“, Vue.js seine Funktionen): In JSX rufen wir gewöhnliche
// FUNKTIONEN auf, die in einem Modul liegen und für sich testbar sind:
// {timeRange(slot)} -> "8:00 - 8:20"
// {timeRange(slot, 'start')} -> "8:00"
// Für Datumsangaben, Zahlen und Beträge stellt der Browser die
// Intl-API bereit, die die Konventionen jeder Sprache kennt.
// =========================================================================
export interface Slot {
startHour: number;
startMinute: number;
endHour: number;
endMinute: number;
}
// "8:05" statt "8:5"
function time(h: number, m: number): string {
return `${h}:${String(m).padStart(2, '0')}`;
}
export function timeRange(c: Slot, part: 'all' | 'start' | 'end' = 'all'): string {
switch (part) {
case 'start':
return time(c.startHour, c.startMinute);
case 'end':
return time(c.endHour, c.endMinute);
default:
return `${time(c.startHour, c.startMinute)} - ${time(c.endHour, c.endMinute)}`;
}
}
// "marie pelissier" -> "Marie Pelissier"
export function capitalize(text: string): string {
return text.replace(/\p{L}+/gu, (word) => word[0].toUpperCase() + word.slice(1).toLowerCase());
}
// "Marie PELISSIER" -> "MP"
export function initials(fullName: string): string {
return fullName
.split(/\s+/)
.filter((word) => word !== '')
.map((word) => word[0].toUpperCase())
.join('');
}
// "2026-10-05" (das Format der RdvMedecins-API) -> ein Date, um Mitternacht UTC
export function toDate(day: string): Date {
return new Date(`${day}T00:00:00Z`);
}
|
- Zeilen 13–18: ein Zeitfenster, wie es vom [RdvMedecins]-Server gesendet wird (Stunden und Minuten von Beginn und Ende);
- Zeilen 21–23: [padStart(2, '0')] füllt die Zeichenkette links auf: „5“ wird zu „05“;
- Zeilen 25–34: „8:00 – 8:20“ oder nur der Beginn oder das Ende, je nach Parameter [part], der optional ist (Standardwert ['all']);
- Zeilen 37–39: [\p{L}+] bezeichnet eine Folge von Buchstaben, einschließlich Buchstaben mit Akzent (Option [u]): Der erste Buchstabe wird großgeschrieben;
- Zeilen 51–53: ein Datum in der Form der API (["2026-10-05"]) wird zu einem [Date]-Objekt um Mitternacht UTC.
2.9.2. Die Seite
| // =========================================================================
// 09-formatting/src/App.tsx - Werte in JSX formatieren
// -------------------------------------------------------------------------
// Jede Zeile der Tabelle zeigt ein Stück Code und das, was es anzeigt.
// Die Intl-Formatierer werden einmalig außerhalb der Komponente erstellt:
// Sie zu erstellen kostet mehr, als sie zu verwenden.
// =========================================================================
import { useState } from 'react';
import { timeRange, initials, capitalize, toDate, type Slot } from './formatting';
// Datumsangaben: dateStyle / timeStyle oder die Angabe der anzuzeigenden Teile
const shortDate = new Intl.DateTimeFormat('en-US', { dateStyle: 'medium' });
const fullDate = new Intl.DateTimeFormat('en-US', { dateStyle: 'full' });
const timeOnly = new Intl.DateTimeFormat('en-US', { timeStyle: 'medium' });
const longDay = new Intl.DateTimeFormat('en-US', { weekday: 'long', day: 'numeric', month: 'long', year: 'numeric', timeZone: 'UTC' });
const frenchDay = new Intl.DateTimeFormat('fr-FR', { dateStyle: 'long', timeZone: 'UTC' });
// Zahlen und Beträge
const euros = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' });
const integer = new Intl.NumberFormat('en-US', { maximumFractionDigits: 0 });
const percent = new Intl.NumberFormat('en-US', { style: 'percent', minimumFractionDigits: 1 });
const day = '2026-10-05'; // ein Datum im Format der RdvMedecins-API
const price = 1234.5;
const rate = 0.055;
const name = 'marie pelissier';
const doctor = { title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER' };
const languages = ['TypeScript', 'HTML', 'CSS', 'JavaScript', 'SQL'];
const slots: Slot[] = [
{ startHour: 8, startMinute: 0, endHour: 8, endMinute: 20 },
{ startHour: 8, startMinute: 20, endHour: 8, endMinute: 40 },
{ startHour: 14, startMinute: 5, endHour: 14, endMinute: 25 },
];
export default function App() {
const [now, setNow] = useState(() => new Date());
// [angezeigter Code, Wert]: eine Zeile der Tabelle
const rows: [string, string][] = [
['shortDate.format(now)', shortDate.format(now)],
['fullDate.format(now)', fullDate.format(now)],
['timeOnly.format(now)', timeOnly.format(now)],
['longDay.format(toDate(day))', longDay.format(toDate(day))],
['frenchDay.format(toDate(day))', frenchDay.format(toDate(day))],
['now.toLocaleDateString()', now.toLocaleDateString()],
['euros.format(price)', euros.format(price)],
['integer.format(price)', integer.format(price)],
['percent.format(rate)', percent.format(rate)],
['name.toUpperCase()', name.toUpperCase()],
['capitalize(name)', capitalize(name)],
["'RDV'.toLowerCase()", 'RDV'.toLowerCase()],
["languages.slice(0, 3).join(', ')", languages.slice(0, 3).join(', ')],
['JSON.stringify(doctor)', JSON.stringify(doctor)],
// zwei Funktionen hintereinander: Das Ergebnis der ersten geht an die zweite
['initials(capitalize(name))', initials(capitalize(name))],
];
return (
<div className="container py-4" style={{ maxWidth: 820 }}>
<h1 className="h3 mb-3">Example 09 - the formatting of values</h1>
<table className="table table-sm align-middle">
<thead><tr><th>In the code</th><th>Displayed</th></tr></thead>
<tbody>
{rows.map(([code, value]) => (
<tr key={code}><td><code>{`{${code}}`}</code></td><td>{value}</td></tr>
))}
</tbody>
</table>
<h2 className="h6">Object.entries: going through the properties of an object</h2>
<ul>
{Object.entries(doctor).map(([key, value]) => (
<li key={key}>{key} = {value}</li>
))}
</ul>
<h2 className="h6">A home-made function: timeRange</h2>
<ul>
{slots.map((c) => (
<li key={timeRange(c)}>{timeRange(c)} (start: {timeRange(c, 'start')})</li>
))}
</ul>
<button className="btn btn-sm btn-outline-primary" onClick={() => setNow(new Date())}>Refresh the time</button>
</div>
);
}
|
- Zeilen 13–17: Datumsformatierer, [Intl.DateTimeFormat(language, options)]: [dateStyle] und [timeStyle] liefern vordefinierte Formate ([full], [long], [medium], [short]); man kann auch angeben, welche Teile angezeigt werden sollen ([weekday], [day], [month], [year]). [timeZone: 'UTC']: Das Datum [2026-10-05T00:00:00Z] muss unabhängig von der Zeitzone des Browsers der 5. Oktober bleiben;
- Zeilen 19–21: Zahlenformatierer: ein Betrag in Euro, eine Zahl ohne Nachkommastellen, ein Prozentsatz;
- Zeilen 39–56: Tabellenzeilen: der Code und sein Wert. Die letzte verkettet zwei Funktionen;
- Zeile 65: der Code in geschweiften Klammern;
- Zeilen 72–74: [Object.entries(object)] liefert die Paare [key, value] eines Objekts, die mit [map] durchlaufen werden;
- Zeilen 79–81: die eigene Funktion [timeRange].

Die [Intl]-Generatoren werden ein für alle Mal außerhalb der Komponente erzeugt: Ihre Erzeugung kostet mehr als ihre Verwendung. Die Sprache ist dort fest vorgegeben ([en-US], und [fr-FR] für die französische Zeile); Beispiel 21 zeigt, wie man der vom Benutzer gewählten Sprache folgt.