2. Einstieg in Angular
2.1. Beispiel 01: Die Struktur einer Angular-Anwendung
2.1.1. Die Datei package.json
Die Datei [package.json] im Ordner examples deklariert die verwendeten Bibliotheken und die Projektbefehle:
| {
"name": "examples-angular",
"version": "1.0.0",
"description": "The small examples of the course [Step-by-step introduction to the Angular framework] - a single installation for all",
"private": true,
"scripts": {
"ng": "ng",
"start": "ng serve",
"build": "ng build"
},
"dependencies": {
"@angular/common": "^22.2.0",
"@angular/compiler": "^22.2.0",
"@angular/core": "^22.2.0",
"@angular/forms": "^22.2.0",
"@angular/platform-browser": "^22.2.0",
"@angular/router": "^22.2.0",
"@ngx-translate/core": "^18.0.0",
"bootstrap": "^5.3.8",
"rxjs": "~7.8.0",
"tslib": "^2.8.0"
},
"devDependencies": {
"@angular/build": "^22.2.0",
"@angular/cli": "^22.2.0",
"@angular/compiler-cli": "^22.2.0",
"typescript": "~6.0.2"
}
}
|
Gehen wir diese Datei im Einzelnen durch:
- Zeilen 6–10: die Projektbefehle, gestartet mit [npm run <name>] (oder [npm start] für den Befehl [start]):
- [npm start 05-ngmodel] startet [ng serve 05-ngmodel]: den Entwicklungsserver für Beispiel 05;
- [npm run build 05-ngmodel] startet [ng build 05-ngmodel]: die Produktionsversion von Beispiel 05, die im Ordner [dist/05-ngmodel/] liegt;
- [npm run ng -- <arguments>] ermöglicht den Zugriff auf alle Befehle des Werkzeugs [ng];
- Zeilen 11–22: die Bibliotheken, die die Anwendung im Browser benötigt: die [Angular]-Pakete ([@angular/core], der Kern; [@angular/common], allgemeine Werkzeuge, darunter der HTTP-Client; [@angular/forms], Formulare; [@angular/router], der Router; [@angular/platform-browser], die Initialisierung im Browser; [@angular/compiler], der Template-Compiler; [ngx-translate] für Sprachen; [Bootstrap] für die Formatierung, [RxJS] für Observables und [tslib], eine kleine Hilfsbibliothek, die vom durch [TypeScript] erzeugten Code verwendet wird;
- Zeilen 23–28: die Entwicklungswerkzeuge: das Kommandozeilenwerkzeug [ng] ([@angular/cli]), der [Angular]-Compiler ([@angular/compiler-cli]), das Build-Werkzeug ([@angular/build], das auf [esbuild] und [Vite] aufbaut) und der [TypeScript]-Compiler. Sie sind nicht Teil der an die Benutzer ausgelieferten Anwendung.
Das Präfix [^] vor einer Version ([^22.2.0]) erlaubt [npm] die Installation einer neueren Version derselben Hauptversion (22.x.y); das Präfix [~] ([~6.0.2]) erlaubt nur Fehlerkorrekturen (6.0.x). Alle [@angular/...]-Pakete müssen dieselbe Version haben.
In einem Standardprojekt wird diese Datei durch den Befehl [ng new project-name] erzeugt, der eine vollständige, sofort lauffähige [Angular]-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 angular.json
[angular.json] beschreibt den Workspace: die darin enthaltenen Anwendungen und wie sie gebaut und bereitgestellt werden. Ihr Anfang, der Beispiel 01 beschreibt:
| {
"$schema": "./node_modules/@angular/cli/lib/config/schema.json",
"version": 1,
"cli": {
"packageManager": "npm",
"analytics": false
},
"projects": {
"01-first-application": {
"projectType": "application",
"root": "01-first-application",
"sourceRoot": "01-first-application/src",
"prefix": "app",
"architect": {
"build": {
"builder": "@angular/build:application",
"options": {
"outputPath": "dist/01-first-application",
"index": "01-first-application/src/index.html",
"browser": "01-first-application/src/main.ts",
"tsConfig": "01-first-application/tsconfig.app.json",
"styles": [
"node_modules/bootstrap/dist/css/bootstrap.min.css"
]
},
"configurations": {
"production": {
"outputHashing": "all"
},
"development": {
"optimization": false,
"extractLicenses": false,
"sourceMap": true
}
},
"defaultConfiguration": "production"
},
"serve": {
"builder": "@angular/build:dev-server",
"options": {
"proxyConfig": "proxy.conf.json"
},
"configurations": {
"production": {
"buildTarget": "01-first-application:build:production"
},
"development": {
"buildTarget": "01-first-application:build:development"
}
},
"defaultConfiguration": "development"
}
}
},
|
- Zeilen 4–7: die Einstellungen für das Werkzeug [ng] (der Paketmanager, ohne Erfassung von Nutzungsstatistiken);
- Zeile 9: der Projektname, der [ng serve] oder [npm start] übergeben wird;
- Zeilen 11–12: das Projektverzeichnis und das Quellverzeichnis;
- Zeile 13: das Präfix für Komponenten-Selektoren ([app-root], [app-doctor-card]...);
- Zeilen 15–37: der Build der Anwendung ([ng build]):
- Zeile 16: das Build-Werkzeug;
- Zeile 18: der Ausgabeordner;
- Zeilen 19–20: die HTML-Seite der Anwendung und ihr [TypeScript]-Einstiegspunkt;
- Zeile 21: die [TypeScript]-Projektkonfiguration;
- Zeilen 22–24: die globalen Stylesheets der Anwendung: hier das von [Bootstrap];
- Zeilen 26–36: zwei Konfigurationen: [production] (optimierter Code; [outputHashing] fügt jedem Dateinamen einen Inhalts-Hash hinzu) und [development] (lesbarer Code mit „Source Maps“, die das Debuggen von [TypeScript] im Browser ermöglichen). [ng build] verwendet standardmäßig die erste (Zeile 36);
- Zeilen 38–52: der Entwicklungsserver ([ng serve]):
- Zeile 41: die Proxy-Datei, die erst ab Beispiel 22 verwendet wird: Jede Anfrage des Browsers an eine Adresse, die mit [/api] beginnt, wird an den JSON-Server [RdvMedecins] weitergeleitet. Darauf kommen wir zurück;
- Zeile 51: [ng serve] baut die Anwendung mit der Konfiguration [development].
Die anderen vierundzwanzig Beispiele werden weiter unten in der Datei auf dieselbe Weise beschrieben (insgesamt mehr als tausend Zeilen). Ein Standardprojekt, das mit [ng new] erstellt wurde, enthält nur eines.
2.1.3. Die Dateien tsconfig.json und tsconfig.app.json
Die für alle Beispiele gemeinsame [TypeScript]-Konfiguration:
| {
"compilerOptions": {
"strict": true,
"noImplicitOverride": true,
"noPropertyAccessFromIndexSignature": true,
"noImplicitReturns": true,
"noFallthroughCasesInSwitch": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"skipLibCheck": true,
"isolatedModules": true,
"experimentalDecorators": true,
"importHelpers": true,
"resolveJsonModule": true,
"target": "ES2022",
"module": "preserve"
},
"angularCompilerOptions": {
"strictInjectionParameters": true,
"strictInputAccessModifiers": true,
"strictTemplates": true
},
"include": ["*/src/**/*.ts", "common/**/*.ts"]
}
|
- Zeile 3: der strikte Modus von [TypeScript] (Typen werden streng geprüft, auch [null] und [undefined]);
- Zeilen 4–9: zusätzliche Prüfungen; insbesondere wird eine nicht verwendete Variable oder ein nicht verwendeter Parameter als Fehler gemeldet;
- Zeile 12: [Angular] verwendet die Dekoratoren von [TypeScript] ([@Component], [@Injectable]...);
- Zeile 14: Eine JSON-Datei kann als Modul importiert werden (Beispiel 21);
- Zeilen 15–16: moderner [JavaScript]-Code (ES2022) und Module, die vom Build-Werkzeug verarbeitet werden;
- Zeilen 18–22: Prüfungen speziell für den [Angular]-Compiler. Die wichtigste in Zeile 21: Templates werden wie [TypeScript] geprüft. Ein Tippfehler in einem Template ([{{ titl }}] statt [{{ title }}]) führt zu einem Kompilierungsfehler, der von [ng serve] und vom Editor gemeldet wird;
- Zeile 23: die vom Editor ([VS Code]) angezeigten Dateien: die aller Beispiele.
Jedes Beispiel hat außerdem seine eigene Datei [tsconfig.app.json], die diese Konfiguration verwendet und nur IHRE Dateien kompiliert:
| {
"extends": "../tsconfig.json",
"include": ["src/**/*.ts"]
}
|
So verhindert ein Fehler in einem Beispiel nicht, dass die anderen funktionieren.
2.1.4. Die Seite index.html
Jedes Beispiel hat seine eigene HTML-Seite. Die von Beispiel 01:
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Example 01 - a first application</title>
<!-- base href: Ausgangsadresse für relative Pfade (siehe Router) -->
<base href="/">
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
<!-- Die Angular-Anwendung wird in diesem Element angezeigt (siehe src/main.ts) -->
<app-root></app-root>
</body>
</html>
|
Dies ist die einzige Seite, die der Browser laden wird. Sie ist fast leer:
- Zeile 7: die Basisadresse für die relativen Pfade der Seite; der Router (Beispiel 17) nutzt sie;
- Zeile 12: das Element, in dem [Angular] die Anwendung anzeigt. Dies ist kein bekanntes HTML-Tag: Es ist der Selektor der Wurzelkomponente der Anwendung.
Es gibt keine [<script>] oder [<link>] -Tags: Das Build-Werkzeug fügt sie automatisch hinzu (das kompilierte Programm, das [Bootstrap]-Stylesheet).
2.1.5. Der Einstiegspunkt: main.ts
| // =========================================================================
// 01-first-application/src/main.ts - der Einstiegspunkt der Anwendung
// -------------------------------------------------------------------------
// angular.json legt diese Datei als Einstiegspunkt fest ("browser"). Sie
// startet die Angular-Anwendung ausgehend von ihrer Wurzelkomponente (App):
// Angular sucht in index.html das Element <app-root> (den "selector" von
// App) und zeigt darin das HTML der Komponente an.
// =========================================================================
import { bootstrapApplication } from '@angular/platform-browser';
import { App } from './app/app';
// bootstrapApplication(App) liefert ein Promise zurück: ein möglicher
// Startfehler wird in der Browser-Konsole ausgegeben
bootstrapApplication(App).catch((error) => console.error(error));
|
- Zeile 10: die Funktion von [Angular] , die eine Anwendung in einem Browser startet;
- Zeile 11: die Wurzelkomponente der Anwendung, die Klasse [App] aus der Datei [app/app.ts];
- Zeile 15: Die Anwendung wird von dieser Komponente aus gestartet: [Angular] sucht in der Seite das Element [<app-root>] und zeigt dort das HTML von [App] an.
2.1.6. Die Wurzelkomponente: app.ts, app.html, app.css
Eine [Angular] -Komponente ist eine [TypeScript]-Klasse, die mit [@Component] dekoriert ist:
| // =========================================================================
// 01-first-application/src/app/app.ts - eine erste Komponente
// -------------------------------------------------------------------------
// Eine Angular-Komponente ist eine TypeScript-KLASSE, dekoriert mit @Component:
// - selector : das HTML-Tag, das sie repräsentiert (<app-root>);
// - templateUrl : die Datei mit ihrem HTML (app.html);
// - styleUrl : die Datei mit ihrem CSS (app.css), das nur für
// diese Komponente gilt.
// Die Eigenschaften und Methoden der Klasse können im Template verwendet werden.
// =========================================================================
import { Component, signal } from '@angular/core';
@Component({
selector: 'app-root',
templateUrl: './app.html',
styleUrl: './app.css',
})
export class App {
// "gewöhnliche" Daten: das Template kann sie anzeigen
protected readonly title = 'Welcome to Angular';
protected readonly languages = ['TypeScript', 'HTML', 'CSS'];
// signal(...): ein REAKTIVER Datenwert. Sein Wert wird gelesen, indem man das Signal
// AUFRUFT (counter()), und mit set() oder update() geändert. Angular
// aktualisiert dann AUTOMATISCH die Stellen der Seite, die ihn anzeigen.
protected readonly counter = signal(0);
protected readonly time = signal(new Date().toLocaleTimeString());
// eine Methode, die vom Button des Templates aufgerufen wird
protected increment(): void {
this.counter.update((n) => n + 1);
this.time.set(new Date().toLocaleTimeString());
}
}
|
- Zeilen 14–18: Der Dekorator [@Component] macht die Klasse zu einer Komponente:
- Zeile 15: ihr Selektor, das Tag, das sie in einem Template oder in [index.html] repräsentiert;
- Zeile 16: ihre Template-Datei, HTML;
- Zeile 17: ihre Stildatei, CSS;
- Zeilen 21–22: zwei gewöhnliche Datenelemente. [protected]: Sie werden nur von der Komponente und ihrem Template verwendet; [readonly]: Sie werden nicht ersetzt;
- Zeile 27: [signal(0)] erzeugt einen reaktiven Datenwert mit dem Anfangswert 0. Ein Signal ist eine Funktion: Seinen Wert lesen Sie, indem Sie es aufrufen ([this.counter()]), und ändern ihn mit [set(value)] oder [update(function)]. Wenn es sich ändert, aktualisiert [Angular] alle Stellen der Seite, die es anzeigen;
- Zeilen 31–34: eine Methode, die zwei Signals ändert. Sie ändert die Seite nicht: [Angular] aktualisiert sie. [update((n) => n + 1)] berechnet den neuen Wert anhand des alten.
Das Template der Komponente:
| <!-- 01-first-application/src/app/app.html - das Template der Komponente App -->
<div class="container py-4">
<!-- {{ expression }}: der Wert des Ausdrucks, in die Seite eingefügt -->
<h1 class="h3">{{ title }}</h1>
<p>This page is built in the browser, by Angular, from index.html, main.ts and the App component.</p>
<p>It is written in {{ languages.join(', ') }} ({{ languages.length }} languages).</p>
<!-- (click): die Methode, die bei einem Klick aufgerufen wird (siehe Beispiel 04) -->
<button class="btn btn-primary" (click)="increment()">Click me</button>
<!-- ein Signal wird durch Aufruf gelesen: counter(), nicht counter -->
<p class="mt-3 counter">You clicked {{ counter() }} times (last click: {{ time() }}).</p>
</div>
|
- Zeile 4: Die Syntax [{{ expression }}] (Interpolation) fügt den Wert eines [TypeScript]-Ausdrucks in die Seite ein, der an der Komponente ausgewertet wird ([title] bezeichnet [this.title]). Er wird maskiert: Wenn [title] den Wert [<b>] enthielte, würde [<b>] angezeigt, ohne dass das Tag interpretiert wird;
- Zeile 6: Der Ausdruck kann beliebig sein: ein Methodenaufruf, eine Berechnung;
- Zeile 9: Ein Klick auf die Schaltfläche ruft die Methode [increment] auf (siehe Beispiel 04);
- Zeile 11: Ein Signal wird durch den Aufruf der Methode angezeigt: [{{ counter() }}]. [Angular] merkt sich, dass das Template dieses Signal liest: Wenn es sich ändert, wird dieser Teil der Seite aktualisiert.
Und sein Stil:
| /* diese Regel gilt nur für die Elemente der Komponente App */
.counter {
font-weight: bold;
color: #dd0031;
}
|
Diese Regel gilt nur für Elemente DIESER Komponente: [Angular] fügt seinen Elementen ein eindeutiges Attribut hinzu ([_ngcontent-xxx]) und gibt es an die CSS-Selektoren weiter. Das ist die Stil-Kapselung: Zwei Komponenten können dieselbe CSS-Klasse verwenden, ohne sich gegenseitig zu stören.
Eine Komponente kann ihr Template und ihren Stil auch direkt im Dekorator schreiben, mit den Eigenschaften [template] und [styles] statt [templateUrl] und [styleUrl]. Die folgenden Beispiele zeigen dies für kleine Komponenten.
2.1.7. Ausführung
In der Konsole, die im Ordner [examples-angular] geöffnet ist:
npm start 01-first-application
Die Konsole zeigt an (Auszug):
| Initial chunk files | Names | Raw size
styles.css | styles | 276.99 kB |
main.js | main | 4.91 kB |
Application bundle generation complete. [2.520 seconds]
Watch mode enabled. Watching for file changes...
➜ Local: http://localhost:4200/
|
Öffnen Sie die URL http://localhost:4200/ und klicken Sie dreimal auf die Schaltfläche:

Zwei Experimente zum Ausprobieren:
- Ändern Sie den Titeltext in [app.ts] und speichern Sie die Datei: Die Seite aktualisiert sich sofort, ohne dass sie neu geladen werden muss. Der Entwicklungsserver überwacht die Dateien, kompiliert die Änderungen neu und benachrichtigt den Browser;
- sehen Sie sich den Quelltext der Seite an (Strg-U): Sie sehen nur die fast leere Seite [index.html]. Die angezeigte HTML-Seite wurde von [Angular] im Browser erzeugt. Um sie zu sehen, verwenden Sie den Inspektor der Entwicklerwerkzeuge (F12, Registerkarte Elemente) oder die Erweiterung [Angular DevTools], die auch die Komponenten und ihre Daten anzeigt.
2.2. Beispiel 02: Signals
Signals stehen im Zentrum der Reaktivität von [Angular]. Dieses Beispiel berechnet den Preis eines Artikels einschließlich Mehrwertsteuer:
| // =========================================================================
// 02-signals/src/app/app.ts - signal, computed, effect, linkedSignal
// -------------------------------------------------------------------------
// Ein kleiner Preisrechner mit Mehrwertsteuer:
// - signal : ein reaktiver Wert, der durch Aufruf gelesen und
// mit set() / update() geändert wird;
// - computed : ein aus anderen Signalen BERECHNETER Wert, der
// automatisch neu berechnet wird, wenn sich diese ändern;
// - effect : Code, der bei jeder Änderung der Signale ausgeführt wird,
// die er liest (ein "Seiteneffekt");
// - linkedSignal : ein beschreibbares Signal, das aber auf einen berechneten Wert
// ZURÜCKGESETZT wird, wenn sich ein anderes Signal ändert.
// =========================================================================
import { Component, computed, effect, linkedSignal, signal, untracked } from '@angular/core';
// FormsModule stellt [(ngModel)] bereit, das ein Feld mit einem Signal verknüpft (siehe Beispiel 05)
import { FormsModule } from '@angular/forms';
@Component({
selector: 'app-root',
imports: [FormsModule],
templateUrl: './app.html',
})
export class App {
protected readonly label = signal('Pen');
protected readonly priceExclVat = signal(2.5);
protected readonly vatRate = signal(20); // in %
// linkedSignal: die Menge springt bei jedem Wechsel des Artikels auf 1 zurück,
// der Benutzer kann sie zwischenzeitlich aber ändern
protected readonly quantity = linkedSignal({ source: this.label, computation: () => 1 });
// computed: wird nie direkt zugewiesen, sondern immer neu berechnet. Angular weiß,
// von welchen Signalen es abhängt (die es LIEST): es berechnet es neu, wenn sich eines
// davon ändert, und nur dann
protected readonly totalExclVat = computed(() => this.quantity() * this.priceExclVat());
protected readonly vatAmount = computed(() => (this.totalExclVat() * this.vatRate()) / 100);
protected readonly totalInclVat = computed(() => this.totalExclVat() + this.vatAmount());
// ein Formatierer für Beträge in Euro im englischen Stil (€1,234.50)
private readonly euros = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' });
// der Verlauf der Gesamtbeträge inkl. MwSt., gefüllt vom folgenden Effect
protected readonly history = signal<string[]>([]);
private oldTotal: number | null = null;
constructor() {
// effect: wird zuerst einmal ausgeführt, dann bei jeder Änderung von
// totalInclVat (dem einzigen Signal, das er liest)
effect(() => {
const total = this.totalInclVat();
document.title = `Incl. VAT: ${this.format(total)}`;
if (this.oldTotal !== null) {
const line = `${this.format(this.oldTotal)} -> ${this.format(total)}`;
// untracked: history ändern, OHNE es zu einer Abhängigkeit des Effects zu machen
untracked(() => this.history.update((h) => [line, ...h].slice(0, 5)));
}
this.oldTotal = total;
});
}
protected format(amount: number): string {
return this.euros.format(amount);
}
protected reset(): void {
this.label.set('Pen');
this.priceExclVat.set(2.5);
this.vatRate.set(20);
this.quantity.set(1);
}
}
|
- Zeile 15: die Reaktivitätsfunktionen, die alle von [@angular/core] bereitgestellt werden;
- Zeilen 21 und 17: Das Template verwendet [[(ngModel)]], das aus dem Modul [FormsModule] stammt. Eine Komponente muss alles, was ihr Template verwendet, importieren (Array [imports]): andere Komponenten, Direktiven und Pipes. Der Compiler meldet einen Fehler, wenn dies fehlt;
- Zeilen 25–27: drei Signals, [signal(initial value)]. Ihr Typ wird aus dem Anfangswert abgeleitet: [signal('Pen')] ist ein String-Signal, [signal(2.5)] ist ein numerisches Signal;
- Zeile 31: Ein [linkedSignal] ist ein veränderbares Signal (es kann wie ein gewöhnliches Signal beschrieben werden), aber es ist mit einem anderen Signal verknüpft, seiner Quelle: Sobald sich die Quelle ändert (hier die Artikelbezeichnung), wird sein Wert auf den von [computation] berechneten Wert zurückgesetzt (hier 1). Wenn sich der Artikel ändert, wird die Menge auf 1 zurückgesetzt;
- Zeilen 36–38: Ein [computed] ist ein aus anderen Signals berechneter Wert. Er wird nie beschrieben, sondern wie ein Signal gelesen ([this.totalExclVat()]). [Angular] weiß, von welchen Signals er abhängt, denn es zeichnet diejenigen auf, die die Funktion während der Berechnung liest. Er wird neu berechnet, wenn sich eines davon ändert, und nur dann: Wird [totalInclVat()] zehnmal gelesen, ohne dass sich etwas ändert, findet nur eine einzige Berechnung statt. Ein [computed] kann von anderen [computed]-Werten abhängen (Zeile 38);
- Zeile 41: ein Formatierer für Beträge im englischen Stil (€1,234.50). Beispiel 09 zeigt, wie sich das mit den Pipes von [Angular] erledigen lässt;
- Zeilen 50–59: Ein [effect] ist eine Funktion, die einmal ausgeführt wird und danach jedes Mal, wenn sich die Signals ändern, die sie liest (hier das einzige [totalInclVat]). Er dient für Seiteneffekte: Aktionen an etwas anderem als der Seite (der Tab-Titel, Zeile 52; der lokale Speicher des Browsers; ein Log);
- Zeile 56: Der Effect fügt dem Verlauf einen Eintrag hinzu. [untracked(...)] führt diese Aktualisierung aus, ohne [history] zu einer Abhängigkeit des Effects zu machen; andernfalls würde der Effect [history] (in [update]) lesen und bei jeder Änderung des Verlaufs erneut ausgelöst ... die er selbst verursacht;
- Ein [effect] wird im Konstruktor der Komponente erstellt (oder bei der Initialisierung einer Eigenschaft): Das nennt [Angular] den Injection-Kontext, auf den wir bei den Services (Beispiel 14) noch näher eingehen. Er endet von selbst, wenn die Komponente zerstört wird;
- Zeilen 66–71: [set()] ersetzt den Wert eines Signals. Die Menge ist ein [linkedSignal]: Es kann wie die anderen beschrieben werden.
Vermeiden Sie es, mit einem [effect] in ein Signal zu schreiben, wenn ein [computed] genügt: Ein [computed] beschreibt einen Wert, ein [effect] beschreibt eine Aktion. Hier hängt der Verlauf von den aufeinanderfolgenden Werten der Summe ab, was ein [computed] nicht ausdrücken kann.
Das Template:
| <div class="container py-4">
<h1 class="h3 mb-3">Example 02 - signals</h1>
<div class="row g-4">
<div class="col-md-6">
<div class="card p-3">
<!-- [(ngModel)]="signal": das Feld liest das Signal und ändert es (siehe Beispiel 05) -->
<label class="form-label" for="label">Item</label>
<input id="label" class="form-control mb-2" [(ngModel)]="label">
<label class="form-label" for="price">Unit price excl. VAT</label>
<input id="price" type="number" step="0.1" min="0" class="form-control mb-2" [(ngModel)]="priceExclVat">
<label class="form-label" for="quantity">Quantity (back to 1 if the item changes)</label>
<input id="quantity" type="number" min="0" class="form-control mb-2" [(ngModel)]="quantity">
<label class="form-label" for="vat">VAT rate</label>
<select id="vat" class="form-select mb-3" [(ngModel)]="vatRate">
<!-- [ngValue]: der übergebene Wert ist die ZAHL 5.5, nicht der String "5.5" -->
<option [ngValue]="5.5">5.5 %</option>
<option [ngValue]="10">10 %</option>
<option [ngValue]="20">20 %</option>
</select>
<button class="btn btn-outline-secondary" (click)="reset()">Reset</button>
</div>
</div>
<div class="col-md-6">
<div class="card p-3">
<h2 class="h5">{{ quantity() }} x {{ label() }}</h2>
<table class="table mb-0">
<tbody>
<tr><td>Total excl. VAT</td><td class="text-end">{{ format(totalExclVat()) }}</td></tr>
<tr><td>VAT ({{ vatRate() }} %)</td><td class="text-end">{{ format(vatAmount()) }}</td></tr>
<tr class="fw-bold"><td>Total incl. VAT</td><td class="text-end">{{ format(totalInclVat()) }}</td></tr>
</tbody>
</table>
</div>
<div class="card p-3 mt-3">
<h2 class="h6">History of the total incl. VAT (effect)</h2>
<ul class="mb-0">
@for (line of history(); track $index) {
<li>{{ line }}</li>
}
</ul>
</div>
</div>
</div>
</div>
|
- Zeilen 8–18: [[(ngModel)]="label"] verbindet das Feld in beiden Richtungen mit dem Signal [label]: Eine Eingabe im Feld ändert das Signal, und eine Änderung des Signals (über die Schaltfläche „Zurücksetzen“) ändert das Feld. Wir geben das Signal selbst an, ohne Klammern: [ngModel] benötigt das Signal, um es zu beschreiben. Beispiel 05 behandelt [ngModel] im Detail;
- Zeilen 10 und 12: Mit [type="number"] erhält das Signal eine Zahl, keinen String;
- Zeilen 16–18: [[ngValue]] liefert den Wert einer Option: hier die Zahl 5.5, nicht den String ["5.5"];
- Zeilen 25–30: die Anzeige von Signals und [computed]. [format(...)] ist eine Methode der Komponente;
- Zeilen 37–39: [@for] wiederholt den Block für jedes Element einer Liste (siehe Beispiel 03).
Bei laufendem Entwicklungsserver ([npm start 02-signals]) ändern wir Artikel, Preis, Menge und Steuersatz:

Jedes Mal, wenn sich die Summe einschließlich Mehrwertsteuer ändert, fügt der Effect dem Verlauf eine Zeile hinzu und ändert den Tab-Titel. Ein Wechsel des Artikels setzt die Menge auf 1 zurück.
Diese Signals sind nicht auf [Angular] beschränkt: Man findet sie auch in [SolidJS], [Preact], [Vue.js] (wo [ref] denselben Zweck erfüllt), und ein Standardentwurf schlägt vor, sie in [JavaScript] selbst aufzunehmen. Vor den Signals (eingeführt in [Angular] 16 im Jahr 2023) prüfte [Angular] regelmäßig den gesamten Komponentenbaum mithilfe der Bibliothek [zone.js], um festzustellen, was sich geändert hatte. Mit Signals weiß es genau, was zu aktualisieren ist: Das ist der „Zoneless“-Modus, der in [Angular] 22 der Standard ist und in allen Beispielen dieses Kurses verwendet wird.
2.3. Beispiel 03: Template-Syntax
Ein [Angular]-Template ist HTML, das um einige Syntaxelemente erweitert wurde. Dieses Beispiel zeigt eine filterbare Liste von Ärzten an:
| // =========================================================================
// 03-templates/src/app/app.ts - die Template-Syntax
// -------------------------------------------------------------------------
// In einem Angular-Template:
// - [property]="expr" : eine Eigenschaft des Elements, berechnet durch einen
// Ausdruck ([src], [disabled], [hidden]...);
// - [class.name]="expr" : die CSS-Klasse "name", wenn der Ausdruck wahr ist;
// [style.prop]="expr" : eine CSS-Eigenschaft;
// - @if / @else if / @else: ein Block, der nur existiert, wenn die Bedingung
// wahr ist;
// - @for (x of list; track x.id): ein Block, der für jedes Element wiederholt wird;
// track gibt die IDENTITÄT jedes Elements an; @empty, der Block, der
// angezeigt wird, wenn die Liste leer ist;
// - @switch / @case : ein Block von mehreren, abhängig von einem Wert;
// - @let name = expr; : eine lokale Variable des Templates.
// =========================================================================
import { Component, computed, signal } from '@angular/core';
import { FormsModule } from '@angular/forms';
// 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;
}
@Component({
selector: 'app-root',
imports: [FormsModule],
templateUrl: './app.html',
})
export class App {
// das Bild liegt im Ordner public/ des Beispiels: wird unverändert ausgeliefert
protected readonly logoUrl = 'doctor.svg';
protected readonly doctors = signal<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 },
]);
protected readonly filter = signal(''); // gesuchter Text
protected readonly onlyAvailable = signal(false);
protected readonly showHelp = signal(true);
// die angezeigte Liste: ein computed, das neu berechnet wird, wenn sich der Filter ändert
protected readonly displayedDoctors = computed(() => {
const text = this.filter().trim().toLowerCase();
return this.doctors().filter(
(m) =>
(!this.onlyAvailable() || m.available) &&
`${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(text),
);
});
protected toggleHelp(): void {
this.showHelp.update((a) => !a);
}
}
|
- Zeilen 22–29: Eine [TypeScript]-Schnittstelle beschreibt das Format der Objekte in der Liste. Die Fachrichtung kann nur drei Werte annehmen (Zeile 27);
- Zeile 38: die Adresse eines Bildes. Die Dateien im Ordner [public/] des Beispiels werden unverändert im Stammverzeichnis der Site bereitgestellt: [doctor.svg] verweist auf die Datei [03-templates/public/doctor.svg]. Dazu muss sie in [angular.json] deklariert werden:
| "assets": [
{
"glob": "**/*",
"input": "03-templates/public"
}
]
|
- Zeilen 40–44: [signal<Doctor[]>(...)]: ein Signal mit angegebenem Typ, eine Liste von Ärzten;
- Zeilen 46–48: drei Signals, die mit den Feldern der Seite verbunden sind;
- Zeilen 51–58: die angezeigte Liste, ein [computed], das von drei Signals abhängt ([filter], [doctors], [onlyAvailable]);
- Zeile 61: [update] kehrt einen booleschen Wert um.
Das Template:
| <div class="container py-4">
<h1 class="h3 mb-3">
<!-- [src]: der Wert der Eigenschaft src ist der von logoUrl -->
<img [src]="logoUrl" alt="logo" width="32" height="32">
Example 03 - the template syntax
</h1>
<div class="d-flex flex-wrap gap-3 align-items-center mb-3">
<input class="form-control w-auto" placeholder="search..." [(ngModel)]="filter">
<label class="form-check-label">
<input type="checkbox" class="form-check-input" [(ngModel)]="onlyAvailable"> available only
</label>
<button class="btn btn-sm btn-outline-secondary" (click)="toggleHelp()">
{{ showHelp() ? "Hide the help" : "Show the help" }}
</button>
</div>
<!-- [hidden]: der Absatz bleibt in der Seite, ist aber nur ausgeblendet -->
<p class="alert alert-info" [hidden]="!showHelp()">
Type a name or a specialty. Unavailable doctors are greyed out.
</p>
<!-- @let: eine Template-Variable, um den Aufruf nicht zu wiederholen -->
@let displayed = displayedDoctors();
<!-- @if / @else if / @else: es existiert immer nur einer der drei Blöcke -->
@if (doctors().length === 0) {
<p class="text-muted">No doctor.</p>
} @else if (displayed.length === 0) {
<p class="text-warning">No doctor matches "{{ filter() }}".</p>
} @else {
<table class="table">
<thead>
<tr><th>#</th><th>Doctor</th><th>Specialty</th><th>Status</th></tr>
</thead>
<tbody>
<!-- @for: eine Zeile pro Arzt; $index liefert die Position.
track m.id: die Identität jeder Zeile, damit Angular weiß,
welche Zeile hinzuzufügen, zu verschieben oder zu entfernen ist, wenn sich die Liste ändert -->
@for (m of displayed; track m.id; let i = $index) {
<tr [class.opacity-50]="!m.available">
<td>{{ i + 1 }}</td>
<td>{{ m.title }} {{ m.firstName }} {{ m.lastName }}</td>
<td>
<!-- @switch: ein Block abhängig vom Wert der Fachrichtung -->
@switch (m.specialty) {
@case ('pediatrician') { <span title="children">🧸</span> }
@case ('cardiologist') { <span title="heart">❤️</span> }
@default { <span title="all patients">🩺</span> }
}
{{ m.specialty }}
</td>
<td>
<!-- [class] mit einem String: die berechneten Klassen werden zu "badge" hinzugefügt -->
<span class="badge" [class]="m.available ? 'text-bg-success' : 'text-bg-secondary'">
{{ m.available ? 'available' : 'unavailable' }}
</span>
</td>
</tr>
}
</tbody>
</table>
}
<!-- [style.font-size.px]: eine CSS-Eigenschaft, mit ihrer Einheit -->
<p [style.font-size.px]="12 + displayed.length * 2">
{{ displayed.length }} doctor(s) displayed - the size of this text depends on it.
</p>
</div>
|
- Zeile 4: [[src]="logoUrl"] ist ein Property Binding: Der Eigenschaft [src] des Elements wird der Wert des Ausdrucks [logoUrl] zugewiesen. Ohne die eckigen Klammern ergäbe [src="logoUrl"] den String ["logoUrl"]. Jede Eigenschaft eines Elements lässt sich auf diese Weise binden: [[disabled]], [[value]], [[hidden]], [[title]]...;
- Zeilen 9 und 11: zwei Felder, die über [[(ngModel)]] mit Signals verbunden sind (siehe Beispiel 05);
- Zeile 14: Die Interpolation unterstützt den ternären Operator [? :];
- Zeile 19: [[hidden]]: Der Absatz bleibt auf der Seite, wird aber nur ausgeblendet (HTML-Eigenschaft [hidden]);
- Zeile 24: [@let] deklariert eine Template-Variable, die im gesamten restlichen Template sichtbar ist. So muss [displayedDoctors()] nicht wiederholt werden;
- Zeilen 27–63: [@if (condition) { ... } @else if (...) { ... } @else { ... }]: Nur einer der drei Blöcke existiert jeweils auf der Seite. Anders als bei [[hidden]] werden die Elemente eines nicht ausgewählten Blocks nicht erzeugt (oder werden entfernt);
- Zeile 40: [@for (m of displayed; track m.id)] wiederholt den Block für jeden Arzt:
- [track m.id] ist erforderlich: Es identifiziert jede Zeile. Wenn sich die Liste ändert, vergleicht [Angular] die Bezeichner, um zu bestimmen, welche Zeile hinzugefügt, verschoben oder gelöscht wird, statt alles neu zu erzeugen. Für eine Liste einfacher Werte ohne Bezeichner schreibt man [track $index] (Beispiel 02);
- [let i = $index]: der Rang des Elements. [@for] stellt außerdem [$first], [$last], [$even], [$odd] und [$count] bereit;
- ein mit [@empty { ... }] bezeichneter Block, der auf den mit [@for] bezeichneten Block folgt, erscheint, wenn die Liste leer ist (Beispiel 16);
- Zeile 41: [[class.opacity-50]="condition"]: Die Klasse [opacity-50] (aus [Bootstrap]) wird auf das Element angewendet, wenn die Bedingung wahr ist;
- Zeilen 46–50: [@switch] wählt einen Block anhand eines Werts aus: ein [@case] pro Wert und [@default] für alle anderen;
- Zeile 55: [[class]="expression"]: Der Ausdruck liefert eine oder mehrere Klassen, die zu den fest codierten Klassen hinzugefügt werden ([badge]);
- Zeile 66: [[style.font-size.px]="expression"]: eine CSS-Eigenschaft mit ihrer Einheit.
Ein Template-Ausdruck ähnelt [TypeScript], ist aber eingeschränkt: keine Zuweisungen (außer in Ereignishandlern, Beispiel 04), kein [new], kein Zugriff auf globale Variablen ([window], [document]). Er kann nur auf die Eigenschaften und Methoden der Komponente zugreifen.
[npm start 03-templates]:

Geben Sie „gen“ ein und blenden Sie die Hilfe aus:

Frühere Versionen von [Angular] schrieben diese Blöcke mit strukturellen Direktiven: [*ngIf], [*ngFor], [[ngSwitch]]. Sie finden sich noch in vielen Projekten; empfohlen wird heute die Syntax [@if] / [@for] / [@switch], die mit [Angular] 17 eingeführt wurde.
2.4. Beispiel 04: Ereignisse
Eine Aufgabenliste, die auf Benutzeraktionen reagiert. Die Komponente:
| // =========================================================================
// 04-events/src/app/app.ts - auf Aktionen des Benutzers reagieren
// -------------------------------------------------------------------------
// (event)="statement": die Anweisung wird ausgeführt, wenn das Element
// dieses Ereignis auslöst:
// - (click)="f()" ruft f auf;
// - (click)="f(3, $event)" ruft f mit Argumenten auf; $event ist
// das native Ereignis des Browsers;
// - (keyup.enter), (keydown.escape): nur für diese Taste;
// - #name an einem Element: eine "Template-Referenzvariable", die
// das HTML-Element selbst bezeichnet (name.value, name.focus()...).
// Hier gibt es weder FormsModule noch ngModel: wir lesen die Felder selbst aus.
// =========================================================================
import { Component, signal } from '@angular/core';
interface Task {
id: number;
label: string;
done: boolean;
}
@Component({
selector: 'app-root',
templateUrl: './app.html',
styles: `
.area {
background: #e9f2ff;
height: 80px;
cursor: crosshair;
}
`,
})
export class App {
protected readonly tasks = signal<Task[]>([
{ id: 1, label: 'Install Node.js', done: true },
{ id: 2, label: 'Read the chapter on events', done: false },
]);
protected readonly log = signal<string[]>([]);
private nextId = 3;
private trace(message: string): void {
this.log.update((j) => [`${new Date().toLocaleTimeString()} ${message}`, ...j]);
}
// aufgerufen von (submit): $event.preventDefault() verhindert, dass der Browser
// das Formular an den Server sendet (und die Seite neu lädt)
protected add(event: SubmitEvent, field: HTMLInputElement): void {
event.preventDefault();
const label = field.value.trim();
if (label === '') {
return;
}
// ein Signal mit einem Array: wir ERSETZEN es durch ein neues Array
this.tasks.update((t) => [...t, { id: this.nextId++, label, done: false }]);
this.trace(`added "${label}"`);
field.value = '';
field.focus();
}
protected toggle(task: Task, done: boolean): void {
this.tasks.update((t) => t.map((x) => (x.id === task.id ? { ...x, done } : x)));
this.trace(`"${task.label}": ${done ? 'done' : 'to do'}`);
}
protected remove(task: Task): void {
this.tasks.update((t) => t.filter((x) => x.id !== task.id));
this.trace(`deleted "${task.label}"`);
}
// $event: das native Ereignis (hier ein MouseEvent), mit seinen Koordinaten
protected position(event: MouseEvent): void {
this.trace(`click at (${event.offsetX}, ${event.offsetY})`);
}
}
|
- Zeilen 26–32: der Stil der Komponente, direkt im Dekorator geschrieben ([styles]) statt in einer [.css]-Datei;
- Zeilen 35–38: ein Signal, das eine Liste von Objekten enthält;
- Zeile 40: eine gewöhnliche Eigenschaft, die nicht angezeigt wird: Sie muss kein Signal sein;
- Zeilen 48–59: das Hinzufügen einer Aufgabe. Die Methode erhält das Ereignis des Browsers und das Element [<input>] selbst (siehe Template):
- Zeile 49: [preventDefault()] verhindert, dass der Browser das Formular an den Server sendet, was die Seite neu laden würde;
- Zeile 55: Das im Signal enthaltene Array ([push]) wird nicht verändert; stattdessen wird es ersetzt durch ein neues Array. Ein Signal meldet eine Änderung nur, wenn sich sein Wert ändert, das heißt, wenn ihm ein ANDERES Objekt zugewiesen wird. Würde man den Inhalt des Arrays ändern, ohne es zu ersetzen, bliebe die Seite unverändert;
- Zeilen 57–58: Das Feld wird geleert und behält den Fokus;
- Zeile 62: dasselbe Prinzip zum Ändern einer Aufgabe: [map] erzeugt ein neues Array, in dem die betreffende Aufgabe durch eine geänderte Kopie ersetzt wird ([{ ...x, done }]);
- Zeile 67: und zum Löschen einer Aufgabe [filter];
- Zeilen 72–74: [MouseEvent]: das Klickereignis mit der Zeigerposition.
Das Template:
| <div class="container py-4">
<h1 class="h3 mb-3">Example 04 - events</h1>
<!-- (submit): Enter im Feld ODER Klick auf den Button.
#newTask: eine Referenz auf das Element <input>, überall im
Template verwendbar -->
<form class="d-flex gap-2 mb-3" (submit)="add($event, newTask)">
<input #newTask class="form-control" placeholder="new task (Escape to clear)"
(keydown.escape)="newTask.value = ''">
<button type="submit" class="btn btn-primary">Add</button>
</form>
<ul class="list-group mb-3">
@for (t of tasks(); track t.id) {
<li class="list-group-item d-flex align-items-center gap-2">
<!-- #box: die Checkbox DIESER Zeile; box.checked: ihr Zustand -->
<input #box type="checkbox" class="form-check-input" [checked]="t.done"
(change)="toggle(t, box.checked)">
<span class="flex-grow-1" [class.text-decoration-line-through]="t.done" [class.text-muted]="t.done">
{{ t.label }}
</span>
<!-- ein Handler mit einem Argument: die Aufgabe DIESER Zeile -->
<button class="btn btn-sm btn-outline-danger" (click)="remove(t)">Delete</button>
</li>
}
</ul>
<div class="area p-3 mb-3 rounded" (click)="position($event)">Click in this area</div>
<h2 class="h6">Log</h2>
<ul class="small">
@for (line of log(); track $index) {
<li>{{ line }}</li>
}
</ul>
</div>
|
- Zeile 7: [(submit)="instruction"] ist ein Event Binding: Die Anweisung wird ausgeführt, wenn das Element das Ereignis [submit] auslöst (Eingabe im Feld oder Klick auf die Schaltfläche). [$event] bezeichnet das Browser-Ereignis;
- Zeile 8: [#newTask] ist eine Template-Referenzvariable: Sie bezeichnet im gesamten Template das Element [<input>] selbst. In Zeile 7 wird sie an die Methode [add] übergeben;
- Zeile 9: [(keydown.escape)]: das Ereignis [keydown], aber nur für die Esc-Taste. Ebenso schreiben wir [(keyup.enter)], [(keydown.control.s)]... In einem Event Binding ist eine Zuweisung erlaubt: [newTask.value = ''] leert das Feld;
- Zeilen 17–18: [#box] bezeichnet das Kontrollkästchen DIESER Zeile des [@for]; [[checked]] setzt das Häkchen abhängig von der Aufgabe; [(change)] benachrichtigt die Komponente, wenn der Benutzer es ändert;
- Zeile 23: ein Handler mit einem Argument: der Aufgabe dieser Zeile;
- Zeile 28: ein Klick in das Feld: [$event] ist ein [MouseEvent].
Hier lesen wir die Felder selbst aus ([field.value], [box.checked]). Die folgenden Beispiele übertragen diese Aufgabe zunächst an [ngModel] und dann an signalbasierte Formulare.
[npm start 04-events]; fügen Sie eine Aufgabe hinzu (Enter), haken Sie die zweite ab und klicken Sie in das Feld:

[Angular] aktualisiert die Seite nur als Reaktion auf ein Ereignis oder eine Signaländerung. Ein vom Template behandeltes Ereignis ((click), (submit) usw.) genügt, um eine Prüfung der Komponente auszulösen; Daten, die später geändert werden, außerhalb eines Ereignisses (etwa als Reaktion auf einen Server oder wenn ein Timer abläuft), werden jedoch nur angezeigt, wenn sie ein Signal sind. Daher die Regel, die dieser Kurs durchgehend befolgt: Jedes von einem Template angezeigte Datum ist ein Signal.
Dasselbe Formular wie in Beispiel 18 des Kurses [NestJS] (alle Feldtypen), aber ohne Server: Alles geschieht im Browser. Die Felder sind über die Direktive [ngModel] mit Signals verbunden:
| // =========================================================================
// 05-ngmodel/src/app/app.ts - alle Feldtypen, verknüpft per ngModel
// -------------------------------------------------------------------------
// [(ngModel)]="signal" (Modul FormsModule) verknüpft ein Formularfeld in
// BEIDE Richtungen mit einem Signal: Eingaben im Feld ändern das Signal, und
// eine Änderung des Signals (per Code) ändert das Feld. Die Syntax [( )], genannt
// "banana in a box", kombiniert [ngModel] (Signal zu Feld) und
// (ngModelChange) (Feld zu Signal). Der empfangene Wert hängt vom Feld ab:
// - text input, textarea -> string
// - input type="number" -> number (null, wenn das Feld leer ist)
// - einzelne Checkbox -> boolean
// - Radiobuttons -> der Wert des gewählten Buttons
// - select / multiple select -> der Wert / ein Array von Werten
// - input type="date" -> string "yyyy-MM-dd"
// In einem <form> muss jedes per ngModel verknüpfte Feld ein Attribut name haben.
// Gleiches Formular wie in Beispiel 18 des NestJS-Kurses; hier aber ohne
// Server: alles geschieht im Browser.
// =========================================================================
import { Component, computed, signal } from '@angular/core';
import { JsonPipe } from '@angular/common';
import { FormsModule } from '@angular/forms';
@Component({
selector: 'app-root',
// JsonPipe: die Pipe json, die ein Objekt im JSON-Format anzeigt (siehe Beispiel 09)
imports: [FormsModule, JsonPipe],
templateUrl: './app.html',
})
export class App {
protected readonly titles = ['Mr', 'Mme', 'Melle'];
protected readonly possibleHobbies = ['sport', 'music', 'reading', 'cinema'];
protected readonly countries = [
{ code: 'fr', name: 'France' },
{ code: 'be', name: 'Belgium' },
{ code: 'ch', name: 'Switzerland' },
];
// ein Signal pro Feld des Formulars
protected readonly title = signal('Mme');
protected readonly name = signal('');
protected readonly age = signal<number | null>(30);
protected readonly presentation = signal('');
protected readonly newsletter = signal(false);
protected readonly hobbies = signal<string[]>(['reading']);
protected readonly country = signal('fr');
protected readonly languages = signal<string[]>([]);
protected readonly birthDate = signal('');
// alle Werte, zusammengefasst in einem Objekt (das, was an einen Server gesendet würde)
protected readonly model = computed(() => ({
title: this.title(),
name: this.name().trim(), // ngModel entfernt die Leerzeichen nicht: das erledigen wir hier
age: this.age(),
presentation: this.presentation(),
newsletter: this.newsletter(),
hobbies: this.hobbies(),
country: this.country(),
languages: this.languages(),
birthDate: this.birthDate(),
}));
protected readonly sent = signal<string | null>(null);
// mehrere Checkboxen für EIN Array: ngModel kann das nicht, wir erledigen es selbst
protected toggleHobby(hobby: string, checked: boolean): void {
this.hobbies.update((l) => (checked ? [...l, hobby] : l.filter((x) => x !== hobby)));
}
// (ngSubmit): das Absenden des Formulars, ohne die Seite neu zu laden
protected send(): void {
this.sent.set(JSON.stringify(this.model()));
}
}
|
- Zeile 22: [FormsModule] enthält die Direktive [ngModel] (sowie [ngSubmit], [ngModelOptions]...): Dies sind die sogenannten „Template-driven“ Formulare ([template-driven forms]);
- Zeile 27: Die Komponente importiert außerdem die Pipe [json], die ein Objekt im JSON-Format anzeigt (siehe Beispiel 09);
- Zeilen 40–48: ein Signal pro Feld, mit dem Werttyp, den das Feld liefert: ein String, eine Zahl (oder [null] bei leerem Feld), ein boolescher Wert oder eine Liste von Strings;
- Zeilen 51–61: alle Werte, mit [computed] in einem einzigen Objekt zusammengefasst: Das würde an einen Server gesendet. [ngModel] entfernt keine Leerzeichen um eine Eingabe: Das erledigen wir hier (Zeile 53);
- Zeilen 66–68: mehrere Kontrollkästchen für dieselbe Liste: [ngModel] kann das nicht verarbeiten, daher übernehmen wir das selbst;
- Zeilen 71–73: das Absenden.
Das Template:
| <div class="container py-4">
<h1 class="h3 mb-3">Example 05 - the fields of a form and ngModel</h1>
<div class="row g-4">
<!-- (ngSubmit): mit FormsModule wird das Formular nie vom Browser an den
Server gesendet; stattdessen wird unsere Methode aufgerufen -->
<form class="col-md-7" (ngSubmit)="send()">
<div class="mb-3">
<span class="form-label d-block">Title</span>
<!-- Radiobuttons: gleiches ngModel, ein Wert pro Button -->
@for (t of titles; track t) {
<div class="form-check form-check-inline">
<input type="radio" class="form-check-input" name="title" [id]="'title-' + t" [value]="t"
[(ngModel)]="title">
<label class="form-check-label" [for]="'title-' + t">{{ t }}</label>
</div>
}
</div>
<div class="row g-3 mb-3">
<div class="col-8">
<label class="form-label" for="name">Name</label>
<input id="name" name="name" class="form-control" [(ngModel)]="name">
</div>
<div class="col-4">
<label class="form-label" for="age">Age</label>
<!-- type="number": das Signal erhält eine Zahl, nicht den String "30" -->
<input id="age" name="age" type="number" class="form-control" [(ngModel)]="age">
</div>
</div>
<div class="mb-3">
<label class="form-label" for="presentation">Presentation (updated when leaving the field)</label>
<!-- updateOn: 'blur': das Signal wird erst aktualisiert, wenn das Feld verlassen wird -->
<textarea id="presentation" name="presentation" rows="2" class="form-control"
[(ngModel)]="presentation" [ngModelOptions]="{ updateOn: 'blur' }"></textarea>
</div>
<div class="mb-3 form-check">
<!-- eine einzelne Checkbox: true / false -->
<input id="newsletter" name="newsletter" type="checkbox" class="form-check-input" [(ngModel)]="newsletter">
<label for="newsletter" class="form-check-label">Receive the newsletter</label>
</div>
<div class="mb-3">
<span class="form-label d-block">Hobbies</span>
<!-- mehrere Checkboxen für ein Array: [checked] + (change) -->
@for (h of possibleHobbies; track h) {
<div class="form-check form-check-inline">
<input #hobbyBox type="checkbox" class="form-check-input" [id]="'hobby-' + h"
[checked]="hobbies().includes(h)" (change)="toggleHobby(h, hobbyBox.checked)">
<label class="form-check-label" [for]="'hobby-' + h">{{ h }}</label>
</div>
}
</div>
<div class="row g-3 mb-3">
<div class="col-6">
<label class="form-label" for="country">Country</label>
<select id="country" name="country" class="form-select" [(ngModel)]="country">
<!-- [value]: der übergebene Wert (der Code), der angezeigte Text ist der Name -->
@for (c of countries; track c.code) {
<option [value]="c.code">{{ c.name }}</option>
}
</select>
</div>
<div class="col-6">
<label class="form-label" for="languages">Spoken languages</label>
<select id="languages" name="languages" multiple size="3" class="form-select" [(ngModel)]="languages">
<option value="fr">French</option>
<option value="en">English</option>
<option value="es">Spanish</option>
</select>
</div>
</div>
<div class="mb-3">
<label class="form-label" for="birthDate">Date of birth</label>
<input id="birthDate" name="birthDate" type="date" class="form-control w-auto" [(ngModel)]="birthDate">
</div>
<button type="submit" class="btn btn-primary">Send</button>
</form>
<div class="col-md-5">
<h2 class="h6">The model, live</h2>
<pre class="bg-light p-2 rounded small">{{ model() | json }}</pre>
@if (sent(); as text) {
<h2 class="h6">Last submission</h2>
<pre class="bg-success-subtle p-2 rounded small">{{ text }}</pre>
}
</div>
</div>
</div>
|
- Zeile 6: [(ngSubmit)]: Mit [FormsModule] wird das Formular nie vom Browser abgesendet (kein Neuladen der Seite); stattdessen wird die Methode [send] aufgerufen. [preventDefault()] ist nicht mehr nötig (siehe Beispiel 04);
- Zeilen 12–13: Optionsfelder: dasselbe [ngModel] an jedem Feld und ein Wert pro Feld ([[value]]). Das Signal erhält den Wert des ausgewählten Feldes;
- Zeile 21: [[(ngModel)]="name"] bindet das Feld an das Signal [name], in beide Richtungen. Die Syntax [[( )]], bekannt als „Banana in a Box“, kombiniert ein Property Binding [[ngModel]] (vom Signal zum Feld) und ein Event Binding [(ngModelChange)] (vom Feld zum Signal). In einem [<form>] muss jedes durch [ngModel] verbundene Feld ein Attribut [name] haben;
- Zeile 26: Mit [type="number"] erhält das Signal eine Zahl;
- Zeile 33: [[ngModelOptions]="{ updateOn: 'blur' }"]: Das Signal wird nur aktualisiert, wenn das Feld verlassen wird, nicht bei jedem Tastendruck;
- Zeile 37: ein einzelnes Feld: [true] / [false];
- Zeilen 45–46: die Freizeitfelder, manuell verwaltet: [[checked]] und [(change)], wie in Beispiel 04;
- Zeilen 54–59: eine Dropdown-Liste: Das Signal erhält den Wert ([[value]], den Ländercode) der ausgewählten Option;
- Zeile 63: eine Mehrfachauswahlliste ([multiple]): Das Signal erhält die Liste der ausgewählten Werte;
- Zeile 72: ein Datum: Das Signal erhält einen String ["yyyy-MM-dd"];
- Zeile 79: [{{ model() | json }}]: das Modell im JSON-Format, in Echtzeit;
- Zeile 80: [@if (sent(); as text)]: Ist der Wert „wahr“ (hier ein nicht leerer String), wird der Block angezeigt, und [as text] macht ihn zu einer Variablen des Blocks.
[npm start 05-ngmodel]; füllen Sie das Formular aus und senden Sie es ab:

[ngModel] gibt es seit der ersten Version von [Angular] , und es akzeptiert Signals seit [Angular] 17. Es findet sich in unzähligen Anwendungen. Es überlässt es jedoch der Komponente, alles zu erledigen, was über das einfache Hin und Her eines Werts hinausgeht: Felder zusammenführen, feststellen, welche geändert wurden, sie validieren ... Das folgende Beispiel zeigt die neueste Art, ein Formular zu schreiben.
[Angular] 22 führt eine neue Art ein, Formulare zu schreiben, die vollständig auf Signals beruht: signalbasierte Formulare ([Signal Forms], Paket [@angular/forms/signals]). Das Prinzip:
- Das Formularmodell ist ein Signal, das ein Objekt mit einer Eigenschaft pro Feld enthält;
- die Funktion [form(model)] erstellt einen Feldbaum ([FieldTree]), der dieselbe Struktur wie das Modell hat: [f.lastName], [f.age], [f.newsletter]...;
- Im Template verbindet [[formField]="f.lastName"] ein HTML-Feld mit einem Feld im Baum.
Das Formular liest aus dem Modell und schreibt in das Modell; und jedes Feld kennt seinen Status: Wurde darauf zugegriffen, wurde es geändert, ist es deaktiviert, ist es gültig?
| // =========================================================================
// 06-signal-forms/src/app/app.ts - Signal-Formulare
// -------------------------------------------------------------------------
// Die moderne Art (Angular 22), ein Formular zu schreiben:
// 1. das MODELL: ein Signal, das ein Objekt mit einer Eigenschaft pro
// Feld enthält (das Formular liest und schreibt in diesem Signal);
// 2. form(model, schema): erstellt einen FELDBAUM (FieldTree), der
// dieselbe Form wie das Modell hat: f.lastName, f.age, f.newsletter... Das
// Schema (optional) beschreibt die Regeln der Felder (siehe Beispiel 07);
// 3. [formField]="f.lastName" verknüpft ein HTML-Feld mit einem Feld des Baums.
// Jedes Feld hat einen ZUSTAND, den man durch Aufruf erhält: f.lastName() liefert seinen Wert
// (value()), ob es berührt wurde (touched()), geändert wurde (dirty()), ob es
// deaktiviert ist (disabled())...
// =========================================================================
import { Component, signal } from '@angular/core';
import { JsonPipe } from '@angular/common';
import { disabled, form, FormField } from '@angular/forms/signals';
// die Form der Formulardaten
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: '',
};
@Component({
selector: 'app-root',
imports: [FormField, JsonPipe],
templateUrl: './app.html',
})
export class App {
protected readonly titles = ['Mr', 'Mme', 'Melle'];
// 1. das Modell
protected readonly model = signal<Profile>({ ...INITIAL });
// 2. der Feldbaum; eine Regel: die E-Mail kann nur geändert werden, wenn das Kästchen
// "newsletter" angehakt ist (valueOf liest den Wert eines ANDEREN Felds)
protected readonly f = form(this.model, (p) => {
disabled(p.email, ({ valueOf }) => !valueOf(p.newsletter));
});
// die Felder, deren Zustand in der Tabelle rechts angezeigt wird
protected readonly fields = ['firstName', 'lastName', 'age', 'email'] as const;
protected reset(): void {
// das Modell kehrt zu seinem Anfangswert zurück und der Zustand der Felder wird zurückgesetzt
this.model.set({ ...INITIAL });
this.f().reset();
}
protected upperCase(): void {
// das MODELL per Code ändern: die Felder folgen
this.model.update((m) => ({ ...m, lastName: m.lastName.toUpperCase(), firstName: m.firstName.toUpperCase() }));
}
}
|
- Zeile 18: die Funktionen und die Direktive für signalbasierte Formulare;
- Zeilen 21–31: das Format der Formulardaten;
- Zeile 47: Die Komponente importiert die Direktive [FormField], also die von [[formField]];
- Zeile 54: das Modell – ein Signal, das ein Objekt [Profile] enthält;
- Zeilen 58–60: der Feldbaum. Das zweite Argument von [form] ist das Schema des Formulars: eine Funktion, die die Feldpfade ([p.email], [p.newsletter]...) erhält und ihnen Regeln zuordnet. Hier gibt es nur eine: [disabled(p.email, logic)] deaktiviert das Feld [email] , wenn die Funktion [logic] den Wert [true] zurückgibt. [valueOf(p.newsletter)] liest den Wert eines anderen Feldes: Die E-Mail-Adresse kann nur bearbeitet werden, wenn das Kontrollkästchen „newsletter“ ausgewählt ist. Die Regel ist reaktiv: Sie wird neu ausgewertet, sobald sich das Kontrollkästchen ändert. Beispiel 07 ergänzt Validierungsregeln;
- Zeile 63: die Namen der Felder, deren Status das Template anzeigt; [as const] erzeugt eine Liste exakter Namen (['firstName' | 'lastName' | ...]), nicht beliebiger Strings;
- Zeilen 65–69: das Zurücksetzen. Das Modell wird auf seinen Anfangswert zurückgesetzt (die Felder folgen), dann werden die Feldzustände auf null gesetzt ([touched], [dirty]): [f()] (der aufgerufene Baum) liefert den Zustand des gesamten Formulars, einschließlich der Methode [reset()];
- Zeilen 71–74: Das Modell wird per Code geändert; die Felder der Seite folgen.
Das Template:
| <div class="container py-4">
<h1 class="h3 mb-3">Example 06 - signal forms</h1>
<div class="row g-4">
<form class="col-md-7" (submit)="$event.preventDefault()">
<div class="mb-3">
<span class="form-label d-block">Title</span>
<!-- Radiobuttons: dasselbe Feld, ein Wert pro Button -->
@for (t of titles; track t) {
<div class="form-check form-check-inline">
<input type="radio" class="form-check-input" [id]="'title-' + t" [value]="t" [formField]="f.title">
<label class="form-check-label" [for]="'title-' + t">{{ t }}</label>
</div>
}
</div>
<div class="row g-3 mb-3">
<div class="col-5">
<label class="form-label" for="firstName">First name</label>
<!-- [formField]: dieses HTML-Feld bearbeitet das Feld f.firstName des Formulars -->
<input id="firstName" class="form-control" [formField]="f.firstName">
</div>
<div class="col-5">
<label class="form-label" for="lastName">Last name</label>
<input id="lastName" class="form-control" [formField]="f.lastName">
</div>
<div class="col-2">
<label class="form-label" for="age">Age</label>
<!-- type="number" und ein Modell vom Typ number: ein numerischer Wert -->
<input id="age" type="number" class="form-control" [formField]="f.age">
</div>
</div>
<div class="row g-3 mb-3 align-items-end">
<div class="col-5">
<div class="form-check">
<input id="newsletter" type="checkbox" class="form-check-input" [formField]="f.newsletter">
<label for="newsletter" class="form-check-label">Receive the newsletter</label>
</div>
</div>
<div class="col-7">
<label class="form-label" for="email">E-mail (if newsletter)</label>
<!-- disabled wird vom Formular verwaltet: hier ist kein Attribut zu schreiben -->
<input id="email" type="email" class="form-control" [formField]="f.email">
</div>
</div>
<div class="row g-3 mb-3">
<div class="col-6">
<label class="form-label" for="country">Country</label>
<select id="country" class="form-select" [formField]="f.country">
<option value="fr">France</option>
<option value="be">Belgium</option>
<option value="ch">Switzerland</option>
</select>
</div>
<div class="col-6">
<label class="form-label" for="birthDate">Date of birth</label>
<input id="birthDate" type="date" class="form-control" [formField]="f.birthDate">
</div>
</div>
<div class="mb-3">
<label class="form-label" for="presentation">Presentation</label>
<textarea id="presentation" rows="2" class="form-control" [formField]="f.presentation"></textarea>
</div>
<div class="d-flex gap-2">
<button type="button" class="btn btn-outline-primary" (click)="upperCase()">Name in upper case</button>
<button type="button" class="btn btn-outline-secondary" (click)="reset()">Reset</button>
</div>
</form>
<div class="col-md-5">
<h2 class="h6">The model, live</h2>
<!-- f().value(): der Wert des gesamten Formulars, also das Modell -->
<pre class="bg-light p-2 rounded small">{{ f().value() | json }}</pre>
<h2 class="h6">The state of the fields</h2>
<table class="table table-sm small">
<thead><tr><th>field</th><th>touched</th><th>dirty</th><th>disabled</th></tr></thead>
<tbody>
@for (c of fields; track c) {
<tr>
<td>{{ c }}</td>
<td>{{ f[c]().touched() }}</td>
<td>{{ f[c]().dirty() }}</td>
<td>{{ f[c]().disabled() }}</td>
</tr>
}
</tbody>
</table>
<p class="small mb-0">form modified (dirty): <strong>{{ f().dirty() }}</strong></p>
</div>
</div>
</div>
|
- Zeile 4: Das Formular wird nicht abgesendet (in diesem Beispiel gibt es keine Absenden-Schaltfläche); wir verhindern nur das Absenden über die Eingabetaste;
- Zeile 10: Optionsfelder: dasselbe Feld [f.title] an jedem Feld, ein Wert pro Feld;
- Zeile 19: [[formField]="f.firstName"] verbindet das HTML-Feld in beiden Richtungen mit dem Feld [firstName] des Formulars, wie mit [ngModel] in Beispiel 05;
- Zeile 28: ein numerisches Feld für eine numerische Eigenschaft des Modells: Das Modell erhält eine Zahl;
- Zeile 34: ein Kontrollkästchen für einen booleschen Wert;
- Zeile 41: das Feld [email]. Geben Sie das Attribut [disabled] nicht an: Die Direktive [[formField]] setzt und entfernt es automatisch gemäß der Schemaregel;
- Zeilen 47, 55, 60: eine Dropdown-Liste, ein Datum, ein Textfeld;
- Zeile 71: [f().value()]: der Wert des gesamten Formulars, also das Modell;
- Zeilen 76–83: der Status von vier Feldern. [f[c]] ist das Feld mit dem Namen [c]; [fc] ist sein Status; [touched()] (der Benutzer hat das Feld betreten und wieder verlassen), [dirty()] (der Benutzer hat seinen Wert geändert), [disabled()]: alle sind Signals;
- Zeile 86: der Status des gesamten Formulars – er wird aktualisiert, sobald eines seiner Felder geändert wird.
[npm start 06-signal-forms]; wählen Sie die Anrede, geben Sie Vorname, Nachname und Alter ein, setzen Sie das Häkchen (das Feld E-Mail wird bearbeitbar), geben Sie die E-Mail-Adresse ein und klicken Sie dann auf „Name in Großbuchstaben“:

Im Vergleich zu [ngModel]: ein einziges Signal für das gesamte Formular und der Status jedes Feldes, ohne dass etwas geschrieben werden muss. Signalbasierte Formulare können mehrere Kontrollkästchen weder an dieselbe Liste noch an eine Mehrfachauswahlliste binden: Verwenden Sie für diese Felder die Technik aus Beispiel 05.
Das Formular „Konto erstellen“ der Anwendung [RdvMedecins], im Browser nach denselben Regeln validiert wie auf dem Server: Anrede aus der Liste, Vor- und Nachname erforderlich (maximal 20 Zeichen), Benutzername in Kleinbuchstaben, Passwort mit mindestens 6 Zeichen, Bestätigung.
Hinweis: Diese Validierung dient lediglich dem Komfort des Benutzers (eine sofortige Rückmeldung, ohne Hin und Her mit dem Server). Sie bietet keinerlei Sicherheit: Jeder kann eine manuell erstellte Anfrage an den Server senden ([curl]...). Der Server validiert daher IMMER ebenfalls (siehe Beispiel 25).
2.7.1. Anwendungskonfiguration
| import { bootstrapApplication } from '@angular/platform-browser';
import { provideSignalFormsConfig } from '@angular/forms/signals';
import { App } from './app/app';
bootstrapApplication(App, {
providers: [
provideSignalFormsConfig({
classes: {
// ein fehlerhaftes Feld wird erst markiert, nachdem es "touched" ist (verlassen wurde)
'is-invalid': (field) => field.state().touched() && field.state().invalid(),
'is-valid': (field) => field.state().touched() && field.state().valid(),
},
}),
],
}).catch((error) => console.error(error));
|
- Zeile 15: Das zweite Argument von [bootstrapApplication] ist die Konfiguration der Anwendung: eine Liste von Providern ([providers]), die der gesamten Anwendung Services und Einstellungen zur Verfügung stellen (siehe Beispiel 14);
- Zeilen 17–23: [provideSignalFormsConfig] konfiguriert die signalbasierten Formulare. [classes] ordnet einer CSS-Klasse eine Bedingung zu, die auf dem Zustand eines Feldes beruht: Die Direktive [[formField]] wendet die Klasse auf das HTML-Feld an, wenn die Bedingung wahr ist. Es werden die folgenden Klassen aus [Bootstrap] verwendet:
- Zeile 20: [is-invalid] (roter Rand), wenn das Feld betreten wurde, aber ungültig ist (beide Bedingungen). Fehler werden nicht sofort angezeigt: Ein leeres, komplett rot markiertes Formular wirkt abschreckend;
- Zeile 21: [is-valid] (grüner Rahmen), wenn das Feld betreten wurde und gültig ist.
2.7.2. Die Komponente
| // =========================================================================
// 07-validation/src/app/app.ts - ein Formular im Browser validieren
// -------------------------------------------------------------------------
// Die Regeln der Felder stehen im SCHEMA des Formulars (zweites
// Argument von form()): required, maxLength, minLength, pattern... und
// validate() für eine "selbstgeschriebene" Regel. Jedes Feld kennt dann seine
// Fehler (f.lastName().errors()), die bei jedem Tastendruck neu berechnet werden.
// Sie werden nicht sofort angezeigt (ein komplett rotes leeres Formular ist
// unangenehm): nur für ein bereits verlassenes Feld ("touched"). submit()
// markiert alle Felder als touched und führt die Aktion nur aus, 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 Rückmeldung, ohne Roundtrip zum Server). Sie schützt
// nichts: Jeder kann dem Server eine von Hand gebaute Anfrage
// senden (curl...). Der Server validiert deshalb IMMER alles erneut (siehe Beispiel 25).
// =========================================================================
import { Component, signal } from '@angular/core';
import { form, FormField, maxLength, minLength, pattern, required, submit, validate } from '@angular/forms/signals';
interface Account {
title: string;
firstName: string;
lastName: string;
login: string;
password: string;
confirmation: string;
}
const TITLES = ['Mr', 'Mme', 'Melle'];
const LOGIN_FORMAT = /^[a-z0-9._-]{1,30}$/;
const PASSWORD_MIN = 6;
@Component({
selector: 'app-root',
imports: [FormField],
templateUrl: './app.html',
})
export class App {
protected readonly titles = TITLES;
protected readonly model = signal<Account>({
title: 'Mr',
firstName: '',
lastName: '',
login: '',
password: '',
confirmation: '',
});
// das Schema: p bezeichnet die PFADE der Felder (p.lastName, p.login...)
protected readonly f = form(this.model, (p) => {
validate(p.title, ({ value }) =>
TITLES.includes(value()) ? null : { kind: 'title', message: 'Choose a title from the list.' },
);
required(p.firstName, { message: 'The first name is required.' });
maxLength(p.firstName, 20, { message: 'The first name must not exceed 20 characters.' });
required(p.lastName, { message: 'The last name is required.' });
maxLength(p.lastName, 20, { message: 'The last name must not exceed 20 characters.' });
required(p.login, { message: 'The login is required.' });
pattern(p.login, LOGIN_FORMAT, { message: 'Unaccented lower-case letters, digits, dot, hyphen, underscore.' });
required(p.password, { message: 'The password is required.' });
minLength(p.password, PASSWORD_MIN, { message: `At least ${PASSWORD_MIN} characters.` });
// eine "selbstgeschriebene" Regel, die ZWEI Felder vergleicht (valueOf liest das andere)
validate(p.confirmation, ({ value, valueOf }) =>
value() === valueOf(p.password)
? null
: { kind: 'confirmation', message: 'The confirmation does not match the password.' },
);
});
protected readonly submitAttempted = signal(false);
protected readonly success = signal(false);
// (submit) des Formulars
protected async send(event: SubmitEvent): Promise<void> {
event.preventDefault();
this.submitAttempted.set(true);
// submit() markiert alle Felder als touched (ihre Fehler
// erscheinen) und führt die Aktion nur aus, wenn alles gültig ist
const valid = await submit(this.f, async () => {
// hier würden wir das Modell an den Server senden (siehe Beispiel 25)
return null; // null: kein Fehler
});
this.success.set(valid);
}
}
|
- Zeile 21: Validierungsfunktionen für signalbasierte Formulare;
- Zeilen 53–71: das Schema des Formulars: Jede Funktion ordnet einem Feld, das über seinen Pfad ([p.firstName]) identifiziert wird, eine Regel zu, zusammen mit der Meldung, die im Fehlerfall angezeigt wird:
- [required]: Das Feld muss ausgefüllt sein;
- [maxLength], [minLength]: eine maximale oder minimale Länge;
- [pattern]: Der Wert muss einem regulären Ausdruck entsprechen;
- [validate(path, function)]: eine „benutzerdefinierte“ Regel. Die Funktion erhält den Kontext des Feldes (seinen Wert [value()], den Wert eines anderen Feldes [valueOf(...)]) und gibt [null] (kein Fehler) oder einen Fehler zurück: ein Objekt [{ kind, message }], wobei [kind] den Fehlertyp angibt (Zeilen 54–56 und 66–70). Die Bestätigungsregel vergleicht zwei Felder: Sie wird neu ausgewertet, wenn sich das eine ODER das andere ändert;
- [Angular] stellt außerdem [email], [min], [max] und asynchrone Regeln ([validateHttp]) bereit, die einen Server abfragen;
- Zeilen 77–87: das Absenden. [submit(form, action)]:
- markiert alle Felder als berührt: Ihre Fehler erscheinen, auch bei Feldern, die der Benutzer nie besucht hat;
- führt die Aktion nur aus, wenn das Formular gültig ist;
- gibt [true] zurück, wenn das Absenden erfolgreich war. Die Aktion gibt [null] zurück, wenn alles gut geht, oder Fehlercodes, die Beispiel 25 vom Server abrufen wird.
2.7.3. Das Template
| <div class="container py-4" style="max-width: 640px">
<h1 class="h3 mb-3">Example 07 - validating a form</h1>
<!-- novalidate: wir deaktivieren die browsereigene Validierung, um
UNSERE Meldungen in UNSEREM Stil anzuzeigen -->
<form class="card p-4" novalidate (submit)="send($event)">
<div class="mb-3">
<label class="form-label" for="title">Title</label>
<select id="title" class="form-select" [formField]="f.title">
@for (t of titles; track t) {
<option [value]="t">{{ t }}</option>
}
</select>
<div class="invalid-feedback">{{ f.title().errors()[0]?.message }}</div>
</div>
<div class="row g-3 mb-3">
<div class="col-sm-6">
<label class="form-label" for="firstName">First name</label>
<!-- die Klasse is-invalid (von der Konfiguration gesetzt, siehe main.ts)
gibt dem Feld einen roten Rand UND macht das darauffolgende .invalid-feedback
sichtbar: darin schreiben wir den ersten Fehler des Feldes -->
<input id="firstName" class="form-control" [formField]="f.firstName">
<div class="invalid-feedback">{{ f.firstName().errors()[0]?.message }}</div>
</div>
<div class="col-sm-6">
<label class="form-label" for="lastName">Last name</label>
<input id="lastName" class="form-control" [formField]="f.lastName">
<div class="invalid-feedback">{{ f.lastName().errors()[0]?.message }}</div>
</div>
</div>
<div class="mb-3">
<label class="form-label" for="login">Login</label>
<input id="login" class="form-control" autocomplete="username" [formField]="f.login">
<div class="invalid-feedback">{{ f.login().errors()[0]?.message }}</div>
</div>
<div class="row g-3 mb-4">
<div class="col-sm-6">
<label class="form-label" for="password">Password</label>
<input id="password" type="password" class="form-control" autocomplete="new-password" [formField]="f.password">
<div class="invalid-feedback">{{ f.password().errors()[0]?.message }}</div>
</div>
<div class="col-sm-6">
<label class="form-label" for="confirmation">Confirmation</label>
<input id="confirmation" type="password" class="form-control" autocomplete="new-password"
[formField]="f.confirmation">
<div class="invalid-feedback">{{ f.confirmation().errors()[0]?.message }}</div>
</div>
</div>
<button type="submit" class="btn btn-primary">Create the account</button>
@if (submitAttempted() && f().invalid()) {
<div class="alert alert-danger mt-3 mb-0">The form contains {{ f().errorSummary().length }} error(s).</div>
}
@if (success()) {
<div class="alert alert-success mt-3 mb-0">Valid form: it could be sent to the server.</div>
}
</form>
</div>
|
- Zeile 5: [novalidate] deaktiviert die browsereigene Validierung (die Tooltips „Bitte füllen Sie dieses Feld aus“): UNSERE Meldungen werden in UNSEREM Stil angezeigt;
- Zeile 13: [f.title().errors()]: die Liste der Fehler des Feldes, bei jeder Änderung neu berechnet. Die Meldung des ersten Fehlers wird angezeigt. [?.]: Wenn es keine Fehler gibt, ist [[0]] gleich [undefined], und damit auch der Ausdruck;
- Zeilen 21–22: das Feld und sein Meldungsbereich. Die Klasse [invalid-feedback] von [Bootstrap] ist ausgeblendet, es sei denn, sie folgt auf ein Feld mit der Klasse [is-invalid]: Es ist also kein Code nötig, damit sie zum richtigen Zeitpunkt erscheint;
- Zeile 49: [f().invalid()]: Das Formular ist ungültig, wenn eines seiner Felder ungültig ist; [f().errorSummary()] (Zeile 50): die Fehler aller seiner Felder.
[npm start 07-validation]; geben Sie einen Vornamen ein, gehen Sie zum Nachnamen weiter, lassen Sie ihn leer und geben Sie einen falschen Benutzernamen ein:

Nur die Felder, die ausgefüllt wurden, werden grün oder rot hervorgehoben. Klicken Sie bei leerem Formular auf „Konto erstellen“: Alle Felder werden hervorgehoben:

Das leere Bestätigungsfeld ist „gültig“: Es stimmt mit dem Passwort überein, das ebenfalls leer ist. Ein gültiges Formular:

Vor den signalbasierten Formularen wurden [Angular]-Formulare mit [ngModel] (Beispiel 05) oder mit reaktiven Formularen ([ReactiveFormsModule]) geschrieben, wobei diese API in bestehenden Anwendungen am häufigsten verwendet wird. Sie werden ihr bestimmt begegnen: Hier ist das Formular aus Beispiel 07, damit neu geschrieben.
| // =========================================================================
// 08-reactive-forms/src/app/app.ts - die "historische" Formular-API
// -------------------------------------------------------------------------
// Vor den Signal-Formularen (Angular 22) wurden Formulare mit
// REAKTIVEN FORMULAREN (ReactiveFormsModule) geschrieben. Sie finden sich in
// den meisten bestehenden Anwendungen: hier ist das Formular aus Beispiel
// 07, damit umgeschrieben.
// - eine FormGroup fasst FormControls zusammen, eines pro Feld;
// - jedes FormControl hat einen Anfangswert und VALIDATOREN
// (Validators.required, Validators.maxLength(20)...);
// - im Template verknüpft [formGroup] das <form> mit der Gruppe, und
// formControlName="lastName" verknüpft ein HTML-Feld mit einem Control;
// - der Zustand eines Controls (value, errors, touched, invalid...) ist eine
// gewöhnliche Eigenschaft, kein Signal.
// =========================================================================
import { Component, inject, signal } from '@angular/core';
import { AbstractControl, FormBuilder, ReactiveFormsModule, ValidationErrors, Validators } from '@angular/forms';
const TITLES = ['Mr', 'Mme', 'Melle'];
// ein "selbstgeschriebener" Validator gilt für die GRUPPE: er vergleicht zwei ihrer Felder.
// Er liefert null (kein Fehler) oder ein Objekt, das den Fehler beschreibt.
function sameConfirmation(group: AbstractControl): ValidationErrors | null {
const password = group.get('password')?.value;
const confirmation = group.get('confirmation')?.value;
return password === confirmation ? null : { confirmation: true };
}
@Component({
selector: 'app-root',
imports: [ReactiveFormsModule],
templateUrl: './app.html',
})
export class App {
protected readonly titles = TITLES;
private readonly fb = inject(FormBuilder).nonNullable;
// die Gruppe: { name: [Anfangswert, Validatoren] }
protected readonly form = this.fb.group(
{
title: ['Mr', [Validators.required]],
firstName: ['', [Validators.required, Validators.maxLength(20)]],
lastName: ['', [Validators.required, Validators.maxLength(20)]],
login: ['', [Validators.required, Validators.pattern(/^[a-z0-9._-]{1,30}$/)]],
password: ['', [Validators.required, Validators.minLength(6)]],
confirmation: [''],
},
{ validators: sameConfirmation },
);
protected readonly success = signal(false);
protected readonly value = signal('');
// ein Feld wird als fehlerhaft markiert, wenn es touched und ungültig ist
protected inError(name: string): boolean {
const control = this.form.get(name);
return !!control && control.touched && control.invalid;
}
// (ngSubmit): alle Felder werden "touched", ihre Fehler erscheinen
protected send(): void {
this.form.markAllAsTouched();
this.success.set(this.form.valid);
// getRawValue(): der Wert der gesamten Gruppe, typisiert
this.value.set(JSON.stringify(this.form.getRawValue()));
}
}
|
- Zeile 18: die Klassen für reaktive Formulare, in [@angular/forms];
- Zeilen 24–28: ein „benutzerdefinierter“ Validator. Das ist eine Funktion, die ein Steuerelement (hier die gesamte Gruppe, um zwei ihrer Felder zu vergleichen) erhält und [null] (kein Fehler) oder ein Objekt zurückgibt, das den Fehler beschreibt;
- Zeile 32: Die Komponente importiert [ReactiveFormsModule], das die Direktiven [[formGroup]] und [formControlName] bereitstellt;
- Zeile 37: [inject(FormBuilder)]: Die Komponente fordert einen Service von [Angular] an (Dependency Injection; siehe Beispiel 14). [FormBuilder] hilft beim Erzeugen von Formularen; [nonNullable]: Ein zurückgesetztes Feld kehrt zu seinem Anfangswert zurück, nicht zu [null];
- Zeilen 40–50: Das Formular ist eine Gruppe ([FormGroup]) von Steuerelementen ([FormControl]), eines pro Feld. Jedes wird durch seinen Anfangswert und die Liste seiner Validatoren beschrieben: [Validators.required], [Validators.maxLength(20)], [Validators.pattern(...)]... Zeile 49: der Validator der Gruppe;
- Zeilen 56–59: Ein Feld wird als fehlerhaft gekennzeichnet, wenn es geändert wurde und ungültig ist. Der Status eines Steuerelements ([touched], [invalid], [errors], [value]) ist eine gewöhnliche Eigenschaft, kein Signal;
- Zeilen 62–67: der Befehl. [markAllAsTouched()] zeigt alle Fehler an; [valid] gibt an, ob die gesamte Gruppe gültig ist; [getRawValue()] gibt ihren Wert zurück, typisiert gemäß der Beschreibung der Gruppe.
Das Template:
| <div class="container py-4" style="max-width: 640px">
<h1 class="h3 mb-3">Example 08 - reactive forms</h1>
<!-- [formGroup]: dieses <form> wird von der Gruppe "form" gesteuert -->
<form class="card p-4" novalidate [formGroup]="form" (ngSubmit)="send()">
<div class="mb-3">
<label class="form-label" for="title">Title</label>
<!-- formControlName: dieses Feld ist das Control "title" der Gruppe -->
<select id="title" class="form-select" formControlName="title">
@for (t of titles; track t) {
<option [value]="t">{{ t }}</option>
}
</select>
</div>
<div class="row g-3 mb-3">
<div class="col-sm-6">
<label class="form-label" for="firstName">First name</label>
<input id="firstName" class="form-control" formControlName="firstName" [class.is-invalid]="inError('firstName')">
<!-- errors: ein Objekt, dessen Schlüssel jeweils der Name eines fehlgeschlagenen Validators ist -->
<div class="invalid-feedback">
@if (form.controls.firstName.errors?.['required']) { The first name is required. }
@if (form.controls.firstName.errors?.['maxlength']) { 20 characters at most. }
</div>
</div>
<div class="col-sm-6">
<label class="form-label" for="lastName">Last name</label>
<input id="lastName" class="form-control" formControlName="lastName" [class.is-invalid]="inError('lastName')">
<div class="invalid-feedback">
@if (form.controls.lastName.errors?.['required']) { The last name is required. }
@if (form.controls.lastName.errors?.['maxlength']) { 20 characters at most. }
</div>
</div>
</div>
<div class="mb-3">
<label class="form-label" for="login">Login</label>
<input id="login" class="form-control" formControlName="login" [class.is-invalid]="inError('login')">
<div class="invalid-feedback">
@if (form.controls.login.errors?.['required']) { The login is required. }
@if (form.controls.login.errors?.['pattern']) { Unaccented lower-case letters, digits, dot, hyphen, underscore. }
</div>
</div>
<div class="row g-3 mb-4">
<div class="col-sm-6">
<label class="form-label" for="password">Password</label>
<input id="password" type="password" class="form-control" formControlName="password"
[class.is-invalid]="inError('password')">
<div class="invalid-feedback">
@if (form.controls.password.errors?.['required']) { The password is required. }
<!-- die Fehler tragen auch Informationen: die erforderliche Länge -->
@if (form.controls.password.errors?.['minlength']; as e) { At least {{ e.requiredLength }} characters. }
</div>
</div>
<div class="col-sm-6">
<label class="form-label" for="confirmation">Confirmation</label>
<!-- der Fehler "confirmation" ist der der GRUPPE (selbstgeschriebener Validator) -->
<input id="confirmation" type="password" class="form-control" formControlName="confirmation"
[class.is-invalid]="form.controls.confirmation.touched && form.hasError('confirmation')">
<div class="invalid-feedback">The confirmation does not match the password.</div>
</div>
</div>
<button type="submit" class="btn btn-primary">Create the account</button>
@if (value()) {
<div class="alert mt-3 mb-0" [class]="success() ? 'alert-success' : 'alert-danger'">
{{ success() ? 'Valid form' : 'Invalid form' }}: <code>{{ value() }}</code>
</div>
}
</form>
</div>
|
- Zeile 4: [[formGroup]] verbindet das HTML-Formular mit der Gruppe; [(ngSubmit)] ruft die Methode zum Absenden auf;
- Zeile 8: [formControlName="title"] verbindet das Feld mit dem [title]-Steuerelement der Gruppe;
- Zeile 17: Die Klasse [is-invalid] wird vom Template mit der Methode [inError] gesetzt;
- Zeilen 20–21: [errors] ist ein Objekt, dessen Eigenschaften nach den fehlgeschlagenen Validatoren benannt sind ([required], [maxlength]...). Für jeden möglichen Fehler wird eine Meldung geschrieben;
- Zeile 49: Ein Fehler enthält auch Informationen: hier die erforderliche Länge;
- Zeile 56: Der Bestätigungsfehler ist der der Gruppe: [form.hasError('confirmation')].
[npm start 08-reactive-forms]; einige Fehler, dann ein Klick auf „Konto erstellen“:

Beide APIs erfüllen dieselbe Funktion. Reaktive Formulare beschreiben das Formular im Code (Steuerelemente, die den Wert UND den Zustand halten), während signalgesteuerte Formulare von den Daten ausgehen (einem Modell, dem Regeln zugeordnet werden) und sich natürlich in die Signals der übrigen Anwendung einfügen. Diese verwenden wir im weiteren Verlauf des Kurses und in der Fallstudie.
2.9. Beispiel 09: Pipes
Eine Pipe formatiert einen Wert für die Anzeige, ohne ihn zu verändern: [{{ value | pipe }}] oder, mit Parametern, [{{ value | pipe: parameter1 : parameter2 }}]. [Angular] stellt ein Dutzend davon bereit; Sie können eigene schreiben.
2.9.1. Die Sprache der Pipes
Datums- und Zahlen-Pipes formatieren Werte gemäß einer Sprache ([locale]). Standardmäßig unterstützt [Angular] nur amerikanisches Englisch. Für britisches Englisch:
| import { LOCALE_ID } from '@angular/core';
import { registerLocaleData } from '@angular/common';
import localeEnGb from '@angular/common/locales/en-GB';
import { bootstrapApplication } from '@angular/platform-browser';
import { App } from './app/app';
registerLocaleData(localeEnGb);
bootstrapApplication(App, {
providers: [{ provide: LOCALE_ID, useValue: 'en-GB' }],
}).catch((error) => console.error(error));
|
- Zeile 18: [registerLocaleData(localeEnGb)] lädt die britischen Regeln: Namen der Tage und Monate, Reihenfolge von Tag und Monat, Datumsformate usw.;
- Zeile 21: ein Provider, der dem Token [LOCALE_ID] einen Wert zuweist: die von den Pipes verwendete Standardsprache. [{ provide: token, useValue: value }] ist die einfachste Form eines Providers; Beispiel 14 kommt darauf zurück.
2.9.2. Zwei benutzerdefinierte Pipes
Eine Pipe ist eine mit [@Pipe] dekorierte Klasse, deren Methode [transform] den Wert vor dem senkrechten Strich zusammen mit eventuellen Parametern erhält:
| // =========================================================================
// 09-pipes/src/app/pipes/time-range.pipe.ts - eine "selbstgeschriebene" Pipe
// -------------------------------------------------------------------------
// Eine Pipe ist eine mit @Pipe dekorierte Klasse, deren Methode transform()
// den Wert VOR dem senkrechten Strich (und gegebenenfalls
// Parameter) erhält und zurückgibt, was angezeigt werden soll:
// {{ slot | timeRange }} -> "8:00 - 8:20"
// {{ slot | timeRange: 'start' }} -> "8:00"
// Eine Pipe ist standardmäßig "pure": Angular ruft transform() nur erneut auf, wenn sich
// der Wert oder die Parameter GEÄNDERT haben (gleiches Objekt = gleiches Ergebnis).
// =========================================================================
import { Pipe, PipeTransform } from '@angular/core';
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')}`;
}
@Pipe({ name: 'timeRange' })
export class TimeRangePipe implements PipeTransform {
transform(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)}`;
}
}
}
|
- Zeile 27: der Name der Pipe, der in den Templates geschrieben wird;
- Zeile 29: [transform(value, part)] gibt zurück, was angezeigt werden soll. Der Parameter ist optional (Standardwert ['all']): [{{ slot | timeRange }}] zeigt [8:00 - 8:20] an, [{{ slot | timeRange: 'start' }}] zeigt [8:00] an.
Eine Pipe ist standardmäßig pure: [Angular] ruft [transform] nur auf, wenn sich der Wert oder einer der Parameter geändert hat (ein anderes Objekt, ein anderer String). Das macht sie effizienter als eine Methode der Komponente, die im Template aufgerufen wird (wie [format(...)] in Beispiel 02) und bei jeder Prüfung der Komponente ausgeführt wird.
Eine zweite Pipe, die Initialen berechnet:
| // 09-pipes/src/app/pipes/initials.pipe.ts - "Marie PELISSIER" -> "MP"
import { Pipe, PipeTransform } from '@angular/core';
@Pipe({ name: 'initials' })
export class InitialsPipe implements PipeTransform {
transform(fullName: string): string {
return fullName
.split(/\s+/)
.filter((word) => word !== '')
.map((word) => word[0].toUpperCase())
.join('');
}
}
|
2.9.3. Die Komponente und ihr Template
| // =========================================================================
// 09-pipes/src/app/app.ts - Werte in einem Template formatieren
// -------------------------------------------------------------------------
// {{ value | pipe }} oder {{ value | pipe: parameter1 : parameter2 }}:
// eine PIPE wandelt einen Wert für die Anzeige um, ohne ihn zu ändern. Angular
// stellt ein Dutzend davon bereit (Modul @angular/common); man kann
// eigene schreiben (siehe pipes/). Eine Komponente importiert die Pipes, die sie verwendet.
// =========================================================================
import { Component, signal } from '@angular/core';
import {
CurrencyPipe,
DatePipe,
DecimalPipe,
JsonPipe,
KeyValuePipe,
LowerCasePipe,
PercentPipe,
SlicePipe,
TitleCasePipe,
UpperCasePipe,
} from '@angular/common';
import { Slot, TimeRangePipe } from './pipes/time-range.pipe';
import { InitialsPipe } from './pipes/initials.pipe';
@Component({
selector: 'app-root',
imports: [
CurrencyPipe,
DatePipe,
DecimalPipe,
JsonPipe,
KeyValuePipe,
LowerCasePipe,
PercentPipe,
SlicePipe,
TitleCasePipe,
UpperCasePipe,
TimeRangePipe,
InitialsPipe,
],
templateUrl: './app.html',
})
export class App {
protected readonly now = signal(new Date());
protected readonly day = '2026-10-05'; // ein Datum im Format der RdvMedecins-API
protected readonly price = 1234.5;
protected readonly rate = 0.055;
protected readonly name = 'marie pelissier';
protected readonly doctor = { title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER' };
protected readonly 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 },
];
protected readonly languages = ['TypeScript', 'HTML', 'CSS', 'JavaScript', 'SQL'];
protected refresh(): void {
this.now.set(new Date());
}
}
|
- Zeilen 11–22 und 28–41: Eine Komponente importiert die Pipes, die sie verwendet, [Angular] ([@angular/common]) ebenso wie eigene;
- Zeile 46: ein Datum im Format der API [RdvMedecins]: Die Pipe [date] akzeptiert ein [Date]-Objekt, eine Zahl (Millisekunden) oder einen ISO-String.
| <div class="container py-4" style="max-width: 820px">
<h1 class="h3 mb-3">Example 09 - pipes</h1>
<table class="table table-sm align-middle">
<thead><tr><th>In the template</th><th>Displayed</th></tr></thead>
<tbody>
<tr><td><code>{{ '{{' }} now() | date {{ '}}' }}</code></td><td>{{ now() | date }}</td></tr>
<tr><td><code>{{ '{{' }} now() | date: 'fullDate' {{ '}}' }}</code></td><td>{{ now() | date: 'fullDate' }}</td></tr>
<tr><td><code>{{ '{{' }} now() | date: 'HH:mm:ss' {{ '}}' }}</code></td><td>{{ now() | date: 'HH:mm:ss' }}</td></tr>
<tr><td><code>{{ '{{' }} day | date: 'EEEE d MMMM y' {{ '}}' }}</code></td><td>{{ day | date: 'EEEE d MMMM y' }}</td></tr>
<tr><td><code>{{ '{{' }} day | date: 'longDate' : '' : 'en-US' {{ '}}' }}</code></td><td>{{ day | date: 'longDate' : '' : 'en-US' }}</td></tr>
<tr><td><code>{{ '{{' }} price | currency: 'EUR' {{ '}}' }}</code></td><td>{{ price | currency: 'EUR' }}</td></tr>
<tr><td><code>{{ '{{' }} price | number: '1.0-0' {{ '}}' }}</code></td><td>{{ price | number: '1.0-0' }}</td></tr>
<tr><td><code>{{ '{{' }} rate | percent: '1.1-1' {{ '}}' }}</code></td><td>{{ rate | percent: '1.1-1' }}</td></tr>
<tr><td><code>{{ '{{' }} name | uppercase {{ '}}' }}</code></td><td>{{ name | uppercase }}</td></tr>
<tr><td><code>{{ '{{' }} name | titlecase {{ '}}' }}</code></td><td>{{ name | titlecase }}</td></tr>
<tr><td><code>{{ '{{' }} 'APPOINTMENT' | lowercase {{ '}}' }}</code></td><td>{{ 'APPOINTMENT' | lowercase }}</td></tr>
<tr><td><code>{{ '{{' }} languages | slice: 0 : 3 {{ '}}' }}</code></td><td>{{ languages | slice: 0 : 3 }}</td></tr>
<tr><td><code>{{ '{{' }} doctor | json {{ '}}' }}</code></td><td><code>{{ doctor | json }}</code></td></tr>
<!-- zwei Pipes hintereinander: das Ergebnis der ersten geht an die zweite -->
<tr><td><code>{{ '{{' }} name | titlecase | initials {{ '}}' }}</code></td><td>{{ name | titlecase | initials }}</td></tr>
</tbody>
</table>
<h2 class="h6">keyvalue: iterating over the properties of an object</h2>
<ul>
@for (p of doctor | keyvalue; track p.key) {
<li>{{ p.key }} = {{ p.value }}</li>
}
</ul>
<h2 class="h6">A home-made pipe: timeRange</h2>
<ul>
@for (c of slots; track $index) {
<li>{{ c | timeRange }} (start: {{ c | timeRange: 'start' }})</li>
}
</ul>
<button class="btn btn-sm btn-outline-primary" (click)="refresh()">Refresh the time</button>
</div>
|
- Zeilen 6–20: eine Zeile pro Pipe: der Ausdruck, gefolgt von seinem Ergebnis. [{{ '{{' }}] zeigt die Zeichen [{{] an, die in einem Template nicht unverändert geschrieben werden können;
- Zeilen 6–10: die Pipe [date] mit einem vordefinierten Format ([fullDate], [longDate]...) oder einem zusammengesetzten Format ([EEEE d MMMM y], [HH:mm:ss]). Zeile 10: Ihr zweiter und dritter Parameter sind die Zeitzone und die Sprache: hier amerikanisches Englisch ([en-US]), nur für dieses Datum;
- Zeile 11: [currency], ein Betrag in einer Währung;
- Zeile 12: [number: '1.0-0']: mindestens 1 Ziffer vor dem Dezimalzeichen, zwischen 0 und 0 Ziffern danach: auf die nächste ganze Zahl gerundet;
- Zeile 13: [percent], ein Prozentsatz;
- Zeilen 14–16: Großbuchstaben, Initialen in Großbuchstaben, Kleinbuchstaben;
- Zeile 17: [slice], ein Teil einer Liste oder eines Strings;
- Zeile 18: [json], ein Objekt im JSON-Format (sehr nützlich zum Debuggen);
- Zeile 20: zwei Pipes hintereinander: Das Ergebnis der ersten wird an die zweite übergeben;
- Zeile 26: [keyvalue] wandelt ein Objekt in eine Liste von [{ key, value }]-Paaren um, die [@for] durchlaufen kann;
- Zeile 34: unsere Pipe [timeRange], zuerst ohne und dann mit Parameter.
[npm start 09-pipes]:

[Angular] stellt außerdem die Pipe [async], die den letzten Wert eines Observables anzeigt (siehe Beispiel 19), und [i18nPlural] für Pluralformen bereit. [ngx-translate] stellt die Pipe [translate]bereit, die Text übersetzt (Beispiel 21).