Einstieg
CLI-Setup & Projekterstellung
Die Angular CLI ist das wichtigste Werkzeug für die Entwicklung. ng new erstellt ein vollständiges Projekt mit vorkonfiguriertem Routing und Styling. Nutze ng generate (ng g) für einheitliche Dateierstellung. Die CLI übernimmt Build, Test und Deployment.
# install Angular CLI globally
npm install -g @angular/cli
# create a new project
ng new my-app --routing --style=scss
cd my-app
# serve the app (default: localhost:4200)
ng serve --open
# generate components, services, etc.
ng generate component components/user-profile
ng g service services/auth
ng g module modules/admin --routingProjektstruktur im Überblick
Angular setzt eine klare Ordnerstruktur durch. In src/app liegt der gesamte Feature-Code. main.ts startet die Root-Komponente. angular.json konfiguriert Build-, Test- und Serve-Optionen. Der Environments-Ordner erlaubt es, API-URLs pro Umgebung auszutauschen.
my-app/
├── src/
│ ├── app/ # application code lives here
│ │ ├── app.component.ts
│ │ ├── app.component.html
│ │ └── app.config.ts # standalone bootstrap config
│ ├── assets/ # static images, fonts
│ ├── environments/ # env-specific values
│ ├── index.html # main HTML entry
│ ├── main.ts # bootstrap entry point
│ └── styles.scss # global styles
├── angular.json # CLI workspace config
├── package.json
└── tsconfig.jsonServen & Bauen
ng serve startet einen Dev-Server mit HMR-artigem Reload standardmäßig auf Port 4200. Produktions-Builds tree-shaken, minifizieren und versehen Dateinamen mit Hashes fürs Caching. Nutze --stats-json mit webpack-bundle-analyzer, um aufgeblähte Abhängigkeiten zu finden. ng test führt standardmäßig Karma aus.
# dev server with live reload
ng serve --port 4300 --open
# production build (outputs to dist/)
ng build --configuration production
# analyze bundle size
ng build --stats-json
npx webpack-bundle-analyzer dist/my-app/stats.json
# run unit tests (Karma + Jasmine)
ng test
# run end-to-end tests
ng e2eCode generieren (Schematics)
Schematics sorgen für einheitliche Dateinamen und Boilerplate. Das Flag --standalone erzeugt Standalone-Komponenten (seit v17 empfohlen). --route + --module verdrahtet eine lazy-geladene Route automatisch. Mit --functional erzeugte Guards geben statt einer Klasse eine Funktion zurück.
# generate a standalone component
ng g component user-profile --standalone
# generate a service with root provider
ng g service services/auth
# generate a guard (functional by default)
ng g guard guards/auth --functional
# generate a pipe, directive, or module
ng g pipe pipes/shorten
ng g directive directives/highlight
ng g module admin --routing --route admin --module app
# generate an interface or enum
ng g interface models/user
ng g enum models/roleKonfiguration (angular.json)
angular.json ist die Workspace-Konfiguration. Jedes Projekt hat Build-, Serve-, Test- und Lint-Targets. budgets warnen oder brechen ab, wenn Bundles Schwellwerte überschreiten. Das polyfills-Array enthält das von Angular benötigte zone.js. Mehrere Projekte (App + Library) können in einem Workspace koexistieren.
{
"projects": {
"my-app": {
"architect": {
"build": {
"options": {
"outputPath": "dist/my-app",
"index": "src/index.html",
"main": "src/main.ts",
"polyfills": ["zone.js"],
"tsConfig": "tsconfig.app.json",
"assets": ["src/favicon.ico", "src/assets"],
"styles": ["src/styles.scss"],
"scripts": []
},
"configurations": {
"production": {
"budgets": [{ "type": "initial", "maximumWarning": "500kb" }]
}
}
}
}
}
}
}Environments
Angular tauscht Environment-Dateien beim Build entsprechend der Konfiguration aus (dev vs. prod). Datei-Austausche werden in angular.json unter fileReplacements konfiguriert. Injiziere das Environment-Objekt an beliebiger Stelle, um umgebungsspezifische Werte ohne hartcodierte URLs zu nutzen. Niemals echte Secrets in die Versionskontrolle committen.
// src/environments/environment.ts
export const environment = {
production: false,
apiUrl: 'http://localhost:3000/api',
apiKey: 'dev-key'
};
// src/environments/environment.prod.ts
export const environment = {
production: true,
apiUrl: 'https://api.example.com',
apiKey: 'prod-key'
};
// usage in a service
import { environment } from '../environments/environment';
@Injectable({ providedIn: 'root' })
export class ApiService {
private baseUrl = environment.apiUrl;
}Komponenten-Grundlagen
Grundlegende Komponente
Eine Komponente ist eine TypeScript-Klasse mit dem Decorator @Component. selector ist das Custom-HTML-Tag, das in Templates verwendet wird. templateUrl/styleUrls verweisen auf externe Dateien; für Inline-Code nutze template/styles. @Input markiert Properties, an die Parents binden können. Halte Komponenten auf eine einzige Verantwortung fokussiert.
// user-profile.component.ts
import { Component, Input } from '@angular/core';
@Component({
selector: 'app-user-profile',
templateUrl: './user-profile.component.html',
styleUrls: ['./user-profile.component.scss'],
})
export class UserProfileComponent {
@Input() name = 'Guest';
@Input() age = 0;
greet() {
return `Hello, ${this.name}!`;
}
}Komponente mit Inline-Template
Inline-Templates sind praktisch für kleine Komponenten und vermeiden zusätzliche Dateien. Verwende Backticks für mehrzeilige Strings — innere Backticks als \` escapen. styles akzeptiert ein Array von CSS-Strings. Der :host-Selector zielt auf das eigene Element der Komponente. Sobald ein Template über ~10 Zeilen wächst, sind externe Dateien besser.
@Component({
selector: 'app-counter',
template: `
<button (click)="decrement()">-</button>
<span>{{ count }}</span>
<button (click)="increment()">+</button>
`,
styles: [`
:host { display: flex; gap: 8px; align-items: center; }
button { padding: 4px 12px; }
`],
})
export class CounterComponent {
count = 0;
increment() { this.count++; }
decrement() { this.count--; }
}Standalone-Komponente (v14+)
Standalone-Komponenten brauchen kein NgModule — sie deklarieren ihr eigenes imports-Array mit den Abhängigkeiten (CommonModule, FormsModule, andere Komponenten). Das ist der moderne, empfohlene Ansatz. Importiere nur, was du verwendest, für besseres Tree-Shaking. Standalone-Komponenten werden direkt in main.ts gebootstrapped.
import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';
@Component({
selector: 'app-search',
standalone: true,
imports: [CommonModule, FormsModule],
template: `
<input [(ngModel)]="query" placeholder="Search..." />
<p>Searching for: {{ query }}</p>
`,
})
export class SearchComponent {
query = '';
}Inputs & Outputs
@Input erlaubt Parents, Daten per Property-Binding zu übergeben. @Output stellt einen EventEmitter bereit, den Parents per Event-Binding abonnieren. Initialisiere Inputs immer mit Defaults, um undefined-Fehler zu vermeiden. Nutze die neue input()/output()-Signals-API ab v17+ für saubereren Code.
@Component({
selector: 'app-toggle',
template: `
<button (click)="toggle()">{{ label }}: {{ on ? 'On' : 'Off' }}</button>
`,
})
export class ToggleComponent {
@Input() label = 'Toggle';
@Input() on = false;
@Output() changed = new EventEmitter<boolean>();
toggle() {
this.on = !this.on;
this.changed.emit(this.on);
}
}
<!-- parent template -->
<app-toggle [label]="'Power'" [on]="isOn" (changed)="onToggle($event)" />Signal-basierte Inputs (v17.1+)
Die Funktion input() erzeugt ein signal-basiertes, readonly Input, das man wie eine Funktion aufruft. Sie unterstützt erforderliche Inputs via input.required<T>(), Transforms und funktioniert nahtlos mit computed() und effect(). output() ist der moderne Ersatz für @Output EventEmitter. Das ist die Zukunft der Angular-Komponenten-APIs.
import { Component, input, output } from '@angular/core';
@Component({
selector: 'app-card',
template: `
<div>{{ title() }} - {{ count() }}</div>
<button (click)="clicked.emit()">Click</button>
`,
})
export class CardComponent {
// readonly signal inputs with defaults
title = input<string>('Default');
count = input<number>(0);
// output() function replaces @Output
clicked = output<void>();
// computed derived from inputs
// requires import { computed }
// label = computed(() => this.title().toUpperCase());
}View Encapsulation
Emulated (Standard) fügt eindeutige Attribute hinzu, um Styles auf die Komponente zu beschränken, ohne echtes Shadow DOM. None macht Styles global (sparsam einsetzen). ShadowDom nutzt natives Shadow DOM für echte Isolation, beeinträchtigt aber Style-Durchdringung und manche Drittbibliotheken. Bleibe bei Emulated, außer du hast spezielle Anforderungen.
@Component({
selector: 'app-styles',
template: `<p class="local">Emulated (default)</p>`,
styles: [`p.local { color: red; }`],
encapsulation: ViewEncapsulation.Emulated, // default
})
export class StylesComponent {}
// ViewEncapsulation.None -> styles leak globally
// ViewEncapsulation.ShadowDom -> real Shadow DOM (strong isolation)
// ViewEncapsulation.Emulated -> scoped attributes (default, recommended)Template-Syntax
Text-Interpolation
Doppelte geschweifte Klammern {{ }} rendern Ausdrücke als Text, HTML-escapet. Die meisten JS-Ausdrücke sind erlaubt: Arithmetik, Ternary, Methodenaufrufe, Property-Zugriff. Kein new, typeof oder Zuweisungsoperatoren. Pipes (|) transformieren die Ausgabe. Interpolation wird bei jedem Change-Detection-Zyklus neu ausgewertet.
<p>{{ title }}</p> <!-- renders the value -->
<p>{{ 1 + 2 }}</p> <!-- expressions allowed -->
<p>{{ user.name }}</p> <!-- property access -->
<p>{{ items.length }}</p> <!-- method/property -->
<p>{{ price | currency:'USD' }}</p> <!-- pipe in interpolation -->
<p>{{ isReady ? 'Yes' : 'No' }}</p> <!-- ternary -->
<!-- one-time interpolation updates when the source changes -->
<!-- new control flow @if, @for work without *ngIf/*ngFor directives -->Property- & Attribut-Binding
[prop] bindet an eine DOM-Property (bevorzugt). [attr.name] bindet an HTML-Attribute für Fälle ohne DOM-Property (colspan, SVG-Attribute). [class.x] schaltet eine einzelne Klasse per Wahrheitswert um; [style.prop] setzt einen Style, optional mit Einheitssuffix wie .px oder %. Vermeide Binding an innerHTML mit nicht vertrauenswürdigen Inhalten.
<!-- property binding: [prop]="expression" -->
<img [src]="user.avatar" [alt]="user.name" />
<button [disabled]="isSaving">Save</button>
<my-comp [data]="items"></my-comp>
<!-- attribute binding (for attrs without DOM props) -->
<td [attr.colspan]="2">Merged cell</td>
<svg [attr.viewBox]="box"></svg>
<!-- class & style binding -->
<div [class.active]="isActive">Active?</div>
<div [class]="dynamicClassString">
<div [style.color]="colorVar">
<div [style.width.px]="size">Width</div>Event-Binding
(event) bindet an DOM-Events und Custom-EventEmitter-Outputs. $event ist das Event-Payload (DOM-Event bei nativen Events, ausgegebener Wert bei Custom). Event-Modifikatoren wie .enter, .esc, .prevent, .stop filtern oder transformieren Events. Das Ziel in Klammern bestimmt, was den Handler auslöst.
<button (click)="save()">Save</button>
<input (input)="onInput($event)" (keyup)="onKey($event)" />
<div (mouseenter)="hover=true" (mouseleave)="hover=false">Hover</div>
<!-- $event is the DOM event object -->
<input (keyup.enter)="submit()" (keyup.esc)="cancel()" />
<!-- passive events (scroll, touchmove) -->
<div (scroll.passive)="onScroll($event)">...</div>
<!-- binding to custom component outputs -->
<app-child (changed)="onChanged($event)"></app-child>Template-Referenzvariablen
Eine #var (oder ref-var) referenziert das DOM-Element oder die Komponenteninstanz, auf der sie deklariert ist. Überall im Template zugänglich. Bei Komponenten ist der Wert die Komponenteninstanz, bei Elementen das HTMLElement. Innerhalb von @for sind $index, $first, $last, $even, $odd implizite Kontextvariablen.
<input #nameInput type="text" />
<button (click)="nameInput.focus()">Focus</button>
<p>You typed: {{ nameInput.value }}</p>
<!-- ref to a component instance -->
<app-form #f="appForm"></app-form>
<button [disabled]="!f.valid" (click)="f.submit()">Submit</button>
<!-- ref inside @for -->
<ul>
@for (item of items; track item.id) {
<li>{{ item.name }} (index: {{ $index }})</li>
}
</ul>Two-Way-Binding (Banana in a Box)
[(ngModel)] benötigt FormsModule. Die Syntax [(x)] ist nur Zuckersyntax für [x] + (xChange); eigene Two-Way-Bindings brauchen daher ein Input namens x und einen Output namens xChange. Merke dir die Eselsbrücke 'Banane in der Box' — die runden Klammern stehen innerhalb der eckigen. Die Signal-Funktion model() vereinfacht das ab v17.2+.
<!-- [()] = "banana in a box" - property + event combined -->
<input [(ngModel)]="username" />
<!-- equivalent to -->
<input [ngModel]="username" (ngModelChange)="username = $event" />
<!-- two-way binding on custom components -->
<app-counter [(value)]="count"></app-counter>
<!-- requires: @Input() value; @Output() valueChange = new EventEmitter() -->
<!-- signals: model() for two-way (v17.2+) -->
// value = model<number>(0);Safe Navigation & Non-Null-Assertion
Der Operator ?. navigiert sicher durch nullable Ketten und gibt undefined zurück statt zu werfen. Nutze ihn für async Daten, die noch nicht geladen sind. Der Operator ! ist nur eine Compile-time-Assertion — er fügt keine Runtime-Prüfung hinzu, also nur verwenden, wenn du dir sicher bist. Für Arrays, die null sein können, nutze ?? [] als Fallback.
<!-- safe navigation: short-circuits to undefined if null -->
<p>{{ user?.profile?.bio }}</p>
<p>{{ user?.getName?.() }}</p>
<!-- non-null assertion: tells compiler it's not null -->
<p>{{ user!.name }}</p>
<!-- in property bindings -->
<img [src]="user?.avatar" />
<app-detail [data]="user!"></app-detail>
<!-- safe navigation in @for doesn't replace track -->
@for (item of items ?? []; track item.id) { ... }Direktiven
@if / @else (Neuer Control Flow)
Die neue @if/@else if/@else-Block-Syntax ersetzt *ngIf. Kein Import von CommonModule oder NgIf nötig, kein Sternchen, und @else funktioniert nativ (anders als der ng-template-Trick von ngIf). Das ist die empfohlene Syntax für neuen Code. Sie gehört zum in v17 eingeführten Control Flow, der in v18 stabil ist.
@if (user) {
<p>Hello, {{ user.name }}</p>
} @else if (loading) {
<p>Loading...</p>
} @else {
<p>No user found.</p>
}
<!-- no structural directive import needed, no * prefix -->
<!-- works in standalone templates automatically (v17+) -->@for / @empty (Neuer Control Flow)
@for ersetzt *ngFor mit verpflichtendem track-Ausdruck für effizientes DOM-Diffing. @empty rendert Fallback-Inhalt, wenn die Collection leer ist. Implizite Kontextvariablen ($index, $first, $last usw.) sind immer verfügbar. Tracking über eine stabile, eindeutige ID ist entscheidend für die Performance großer Listen.
<ul>
@for (item of items; track item.id) {
<li>{{ item.name }} ({{ $index }})</li>
} @empty {
<li>No items yet.</li>
}
</ul>
<!-- 'track' is REQUIRED for performance -->
<!-- implicit vars: $index, $first, $last, $even, $odd, $count -->
<!-- @for over a range -->
@for (i of [1,2,3,4,5]; track i) {
<span>{{ i }}</span>
}ngClass & ngStyle
ngClass akzeptiert ein Objekt (wahre Keys werden angewendet), ein Array oder einen String. ngStyle akzeptiert ein Objekt mit camelCase- oder kebab-case-Keys, optional mit Einheitssuffixen. Erfordert den Import von CommonModule oder der jeweiligen Direktiven. Für eine einzelne Klasse/einen einzelnen Style sind [class.x] und [style.x] leichtgewichtiger und brauchen keine Imports.
<div [ngClass]="{ active: isActive, disabled: !enabled }">Box</div>
<div [ngClass]="['card', 'shadow', themeClass]">Card</div>
<div [ngClass]="currentClass">String</div>
<div [ngStyle]="{ color: textColor, 'font-size.px': size }">Text</div>
<div [ngStyle]="styleObject">Styled</div>
<!-- import CommonModule (or NgClass/NgStyle) for these -->
<!-- prefer [class.x] and [style.x] for single value bindings -->@switch (Neuer Control Flow)
@switch ersetzt *ngSwitch (und die Direktiven ngSwitchCase/ngSwitchDefault). Es ist aufgeräumter — kein umschließender Container nötig, keine Imports. Jedes @case rendert nur, wenn sein Wert zum @switch-Ausdruck passt. @default ist der Fallback. Dieser eingebaute Control Flow ist ab v17 verfügbar.
@switch (status) {
@case ('loading') {
<spinner>Loading...</spinner>
}
@case ('error') {
<p class="error">Something went wrong</p>
}
@case ('success') {
<p>Done!</p>
}
@default {
<p>Idle</p>
}
}Custom Attribut-Direktive
Attribut-Direktiven ändern Aussehen oder Verhalten von DOM-Elementen. Die [Klammern] im Selector matchen die Attribut-Verwendung. ElementRef gibt direkten DOM-Zugriff; HostListener bindet an DOM-Events. Injiziere ElementRef<HTMLElement> für Typsicherheit. Bevorzuge Renderer2 für DOM-Manipulation in Server-Side-Rendering-Szenarien.
import { Directive, ElementRef, Input, HostListener } from '@angular/core';
@Directive({
selector: '[appHighlight]',
})
export class HighlightDirective {
@Input('appHighlight') highlightColor = 'yellow';
constructor(private el: ElementRef<HTMLElement>) {}
@HostListener('mouseenter') onMouseEnter() {
this.el.nativeElement.style.backgroundColor = this.highlightColor;
}
@HostListener('mouseleave') onMouseLeave() {
this.el.nativeElement.style.backgroundColor = '';
}
}
<!-- usage: <p appHighlight="lightblue">Hover me</p> -->Strukturelle Direktiven im Inneren
Strukturelle Direktiven fügen DOM-Knoten hinzu oder entfernen sie über TemplateRef (das umschlossene Template) und ViewContainerRef (wo eingefügt wird). Das Sternchen (*) ist Zuckersyntax, die das Element in ein <ng-template> einschließt. Die neuen @if/@for/@switch-Blöcke ersetzen die meisten custom strukturellen Direktiven, aber dieses Muster bleibt für fortgeschrittene Fälle nützlich.
import { Directive, TemplateRef, ViewContainerRef, Input } from '@angular/core';
@Directive({ selector: '[appUnless]' })
export class UnlessDirective {
private hasView = false;
@Input() set appUnless(condition: boolean) {
if (!condition && !this.hasView) {
this.vc.createEmbeddedView(this.tpl);
this.hasView = true;
} else if (condition && this.hasView) {
this.vc.clear();
this.hasView = false;
}
}
constructor(private tpl: TemplateRef<unknown>, private vc: ViewContainerRef) {}
}
<!-- usage: <div *appUnless="hide">Shown when hide is false</div> -->Pipes
Eingebaute Pipes
Pipes transformieren angezeigte Werte im Template. Häufige Built-ins: date, number, currency, percent, uppercase, lowercase, titlecase, slice, json, async. Pipes sind standardmäßig pure — sie rechnen nur neu, wenn sich die Eingabe-Referenz ändert. Format-Strings folgen den locale-basierten Regeln von Angular.
<!-- date formatting -->
<p>{{ today | date }}</p> <!-- Sep 10, 2024 -->
<p>{{ today | date:'short' }}</p>
<p>{{ today | date:'yyyy-MM-dd HH:mm' }}</p>
<!-- number & currency -->
<p>{{ 3.14159 | number:'1.2-2' }}</p> <!-- 3.14 -->
<p>{{ price | currency:'USD':'symbol':'1.2-2' }}</p>
<p>{{ ratio | percent }}</p>
<!-- text transforms -->
<p>{{ 'hello world' | uppercase }}</p> <!-- HELLO WORLD -->
<p>{{ 'HELLO' | lowercase }}</p>
<p>{{ title | titlecase }}</p>
<p>{{ 'a/b/c' | slice:0:2 }}</p>
<!-- json (for debugging) -->
<pre>{{ obj | json }}</pre>Pipes verketten & Parameter
Pipes verketten sich von links nach rechts, jede erhält die vorherige Ausgabe. Parameter werden durch Doppelpunkte getrennt und sind positionsabhängig. Nutze sie für reine Transformationen (Formatierung, Filterung), um Templates deklarativ zu halten. Vermeide impure Pipes bei performancekritischen Daten; berechne stattdessen in der Komponente.
<!-- chain: left to right, output of one feeds the next -->
<p>{{ ' hello ' | trim | uppercase }}</p> <!-- HELLO -->
<p>{{ birthday | date:'fullDate' | uppercase }}</p>
<p>{{ items | slice:0:3 | json }}</p>
<!-- parameters separated by colons -->
<p>{{ amount | number:'1.2-2':'en-US' }}</p>
<p>{{ meeting | date:'shortTime' }}</p>
<p>{{ list | slice:1:5 }}</p>
<!-- multiple parameters -->
<p>{{ value | myPipe:arg1:arg2:arg3 }}</p>Custom Pipe
Custom Pipes implementieren PipeTransform.transform(). Der @Pipe-Name wird in Templates verwendet. Registriere Standalone-Pipes (v15+) im imports-Array einer Komponente oder deklariere sie in einem NgModule. Pure Pipes (Standard) laufen nur erneut, wenn sich die Eingabe-Referenz ändert — übergib neue Referenzen, um Updates auszulösen.
import { Pipe, PipeTransform } from '@angular/core';
@Pipe({ name: 'truncate' })
export class TruncatePipe implements PipeTransform {
transform(value: string, limit = 20, ellipsis = '...'): string {
if (!value) return '';
return value.length > limit
? value.slice(0, limit) + ellipsis
: value;
}
}
// register in a standalone component imports:
// imports: [TruncatePipe]
<!-- usage -->
<p>{{ longText | truncate:50 }}</p>
<p>{{ longText | truncate:10:'>>' }}</p>Async Pipe
Die async Pipe abonniert ein Observable oder Promise, rendert den Wert und beendet das Abo beim Destroy automatisch — kein manuelles subscribe/unsubscribe nötig. Kombiniert mit *ngIf as oder @for behandelt sie null während des Ladens sauber. Sie markiert die Komponente zur Prüfung, wenn ein neuer Wert ankommt, und integriert sich damit in OnPush.
@Component({
selector: 'app-user',
template: `
<div *ngIf="user$ | async as user">
{{ user.name }}
</div>
<ul>
@for (item of items$ | async; track item.id) {
<li>{{ item.name }}</li>
}
</ul>
`,
imports: [AsyncPipe, NgIf],
})
export class UserComponent {
user$ = this.http.get<User>('/api/user');
items$ = this.http.get<Item[]>('/api/items');
constructor(private http: HttpClient) {}
}Pure vs. impure Pipes
Pure Pipes cachen Ergebnisse, bis sich die Eingabe-Referenz ändert; das Mutieren von Arrays oder Objekten löst sie nicht aus. Impure Pipes (pure: false) laufen bei jeder Change Detection — praktisch zum Filtern mutierter Arrays, aber teuer. Halte Daten lieber immutable (Arrays ersetzen statt mutieren) und nutze pure Pipes für Performance.
// PURE (default): re-runs only when input reference changes
@Pipe({ name: 'filter' })
export class FilterPipe implements PipeTransform {
transform(items: Item[], term: string): Item[] {
return items.filter(i => i.name.includes(term));
}
}
// Issue: mutating items.push() won't trigger re-evaluation.
// IMPURE: re-runs on every change detection cycle
@Pipe({ name: 'filter', pure: false })
export class ImpureFilterPipe implements PipeTransform { ... }
// ⚠️ Expensive! Use sparingly — affects performance.i18n & Locale-Pipes
Pipes wie date, number, currency respektieren LOCALE_ID. Registriere Locale-Daten via registerLocaleData vor dem Bootstrap. Die Währungs-/Dezimalformate folgen der aktiven Locale. Für mehrsprachige Apps stelle LOCALE_ID pro Nutzer bereit oder nutze das i18n-Tooling für Template-Übersetzungen. Fehlende Locale-Daten fallen auf en-US zurück.
// register locale data in app.config.ts
import { registerLocaleData } from '@angular/common';
import localeFr from '@angular/common/locales/fr';
registerLocaleData(localeFr);
// provide a default locale
providers: [{ provide: LOCALE_ID, useValue: 'fr-FR' }]
// usage - now locale-aware
<p>{{ price | currency:'EUR' }}</p> <!-- 1 234,56 € -->
<p>{{ today | date:'fullDate' }}</p> <!-- lundi 10 septembre 2024 -->
<p>{{ number | number:'1.2-2' }}</p> <!-- 1 234,56 -->
<p>{{ amount | currency:'JPY' }}</p> <!-- ¥1,235 -->Services & Dependency Injection
Grundlegender Service
providedIn: 'root' erzeugt einen app-weiten Singleton ohne Modul-Registrierung. Der Service ist tree-shakeable — wird entfernt, wenn unbenutzt. Nutze die Funktion inject() (v14+) statt Konstruktor-Injection für saubereren Code und einfacheres Testen. Services halten geteilten Zustand und Geschäftslogik; Komponenten bleiben rein darstellend.
import { Injectable } from '@angular/core';
@Injectable({ providedIn: 'root' })
export class UserService {
private users = ['Alice', 'Bob'];
getUsers() { return this.users; }
addUser(name: string) { this.users.push(name); }
}
// usage in a component
export class UserListComponent {
// Angular injects the singleton instance
constructor(private users: UserService) {}
get users() { return this.usersService.getUsers(); }
private usersService = inject(UserService);
}inject()-Funktion
inject() ist die moderne Alternative zur Konstruktor-Injection. Sie funktioniert in Feld-Initialisierern, macht den Code lesbarer und ermöglicht bessere TypeScript-Inferenz. Sie muss während der Konstruktion laufen (nicht später in async Callbacks). Verwende sie konsistent — Konstruktor-Parameter und inject() zu mischen geht, aber inject() ist sauberer.
import { Injectable, inject } from '@angular/core';
@Injectable({ providedIn: 'root' })
export class AuthService {
private http = inject(HttpClient);
private router = inject(Router);
login(creds: Credentials) {
return this.http.post('/api/login', creds);
}
}
// in a component
export class DashboardComponent {
private auth = inject(AuthService);
user = this.auth.currentUser; // works in field initializers
}Provider-Konfiguration
Provider lassen sich auf jeder Ebene konfigurieren (root, module, component). useClass tauscht Implementierungen (ideal für Mocks). useValue liefert Konstanten. useExisting aliasiert einen Service auf einen anderen. useFactory erzeugt Instanzen dynamisch. InjectionToken ist für Nicht-Klassen-Werte wie Strings oder Konfigurationsobjekte.
@Component({
// ... provide at component level for instance-per-component
providers: [
UserService, // shorthand
{ provide: Logger, useClass: ConsoleLogger },
{ provide: API_URL, useValue: 'https://api.example.com' },
{ provide: Storage, useExisting: LocalStorageService },
{
provide: Config,
useFactory: () => new Config(env.production)
},
],
})
export class AdminComponent {}
// InjectionToken for non-class values
export const API_URL = new InjectionToken<string>('API_URL');Hierarchische Injectors
Angulars DI-Baum spiegelt den Komponentenbaum. providedIn: 'root' = eine Instanz für die ganze App. Provider auf Komponentenebene erzeugen Child-Injectors — jede Instanz bekommt ihren eigenen. Das ist nützlich für zustandsbehaftete Komponenten wie Editoren. 'any' beschränkt auf lazy Module. 'platform' ist selten und für Multi-App-Setups gedacht.
// root injector (singleton app-wide)
@Injectable({ providedIn: 'root' })
export class AuthService {}
// component-level provider: new instance for this component and children
@Component({
providers: [UserService], // each AdminComponent gets its own UserService
})
export class AdminComponent {}
// 'any' creates a lazy singleton per lazy module
@Injectable({ providedIn: 'any' })
export class SharedService {}
// 'platform' shared across all Angular apps on the page
@Injectable({ providedIn: 'platform' })
export class GlobalConfig {}Multi-Provider & Tokens
multi: true registriert mehrere Provider unter einem Token, injiziert als Array. Nützlich für Plugin-Systeme, Interceptors, Validatoren oder jede erweiterbare Sammlung. Die Reihenfolge der Injektion folgt der Registrierungsreihenfolge. Kombiniere mit InjectionToken, um das Array korrekt zu typisieren.
// define a token for a list of plugins
export const PLUGIN = new InjectionToken<Plugin>('PLUGIN');
// provide multiple plugins
@Component({
providers: [
{ provide: PLUGIN, useClass: AuthPlugin, multi: true },
{ provide: PLUGIN, useClass: AnalyticsPlugin, multi: true },
],
})
export class AppComponent {}
// inject all of them as an array
export class PluginManager {
plugins = inject(PLUGIN); // Plugin[]
}Optionale & Default-Provider
@Optional() oder inject(token, { optional: true }) gibt null zurück, wenn kein Provider gefunden wird, statt zu werfen. Nutze das für unkritische Abhängigkeiten. Weitere Modifikatoren: @SkipSelf() (aktuellen Injector überspringen), @Self() (nur aktueller), @Host() (bis zur Host-Komponente). Die inject()-Pendants akzeptieren Flags im Options-Objekt.
import { Injectable, inject, Optional, Inject } from '@angular/core';
@Injectable({ providedIn: 'root' })
export class Logger {
constructor(@Optional() @Inject(CONFIG) private cfg?: Config) {
// cfg is null if no provider exists — handle gracefully
}
}
// or with inject()
export class Service {
cfg = inject(CONFIG, { optional: true }); // Config | null
baseUrl = inject(API_URL, { optional: true }) ?? '/api';
}
// skipSelf: look in parent injectors only
// self: only this component's injector
// host: limit to host componentRouting
Routen-Konfiguration
Routen mappen URL-Pfade auf Komponenten. loadComponent/loadChildren aktivieren Lazy Loading (kleineres Anfangs-Bundle). :id ist ein Routen-Parameter. Der Wildcard '**' fängt nicht gematchte URLs ab — platziere ihn zuletzt. provideRouter richtet den Router in Standalone-Apps ein. Setze title für Browser-Tabs; es kann ein String oder ein ResolveFn sein.
// app.routes.ts (standalone)
import { Routes } from '@angular/router';
export const routes: Routes = [
{ path: '', component: HomeComponent, title: 'Home' },
{ path: 'about', loadComponent: () => import('./about/about.component')
.then(m => m.AboutComponent) },
{ path: 'users/:id', component: UserDetailComponent },
{ path: 'admin', loadChildren: () => import('./admin/admin.routes')
.then(m => m.ADMIN_ROUTES) },
{ path: '**', component: NotFoundComponent }, // wildcard
];
// app.config.ts
export const appConfig: ApplicationConfig = {
providers: [provideRouter(routes)]
};Router-Outlet & Links
router-outlet markiert, wo geroutete Komponenten gerendert werden. routerLink erzeugt Navigationslinks (Array-Form für Parameter nutzen). routerLinkActive setzt eine Klasse, wenn die Route passt. Programmatische Navigation nutzt router.navigate() oder routerLink. Benannte Outlets ermöglichen Sekundärrouten (z. B. ein Modal neben der Hauptansicht).
<!-- app.component.html -->
<nav>
<a routerLink="/" routerLinkActive="active">Home</a>
<a routerLink="/about" routerLinkActive="active">About</a>
<a [routerLink]="['/users', userId]">My Profile</a>
</nav>
<router-outlet></router-outlet>
<!-- named outlet (secondary route) -->
<router-outlet name="popup"></router-outlet>
<!-- navigate programmatically -->
<button (click)="go()">Go</button>
// constructor(private router: Router) {}
// go() { this.router.navigate(['/users', 42]); }Routen-Parameter & Query-Parameter
Nutze den Snapshot für einmaliges Auslesen, wenn die Komponente bei jeder Navigation zerstört und neu erstellt wird. Nutze das Observable param/queryParamMap, wenn dieselbe Komponenteninstanz verschiedene Parameter verarbeitet (z. B. Navigation von /users/1 zu /users/2). Immer unsubscriben oder die async Pipe nutzen, um Leaks zu vermeiden.
// reading route params
export class UserDetailComponent {
constructor(private route: ActivatedRoute) {
// snapshot: one-time read (good for static links)
const id = this.route.snapshot.paramMap.get('id');
// observable: reacts to param changes (same component reused)
this.route.paramMap.subscribe(params => {
console.log(params.get('id'));
});
}
}
// query params: /search?q=angular&page=2
this.route.queryParamMap.subscribe(qp => {
this.q = qp.get('q');
});
<!-- link with query params -->
<a [routerLink]="['/search']" [queryParams]="{ q: 'angular', page: 2 }">Child- & verschachtelte Routen
Child-Routen rendern in einem verschachtelten router-outlet innerhalb der Parent-Komponente. redirectTo mit pathMatch: 'full' leitet leere Child-Pfade weiter. Dieses Muster baut Master-Detail-Layouts (Parent-Chrome, Child-Inhalt). Jede Verschachtelungsebene braucht ihr eigenes router-outlet im Parent-Template.
export const routes: Routes = [
{
path: 'admin',
component: AdminLayoutComponent,
children: [
{ path: '', redirectTo: 'dashboard', pathMatch: 'full' },
{ path: 'dashboard', component: DashboardComponent },
{ path: 'users', component: AdminUsersComponent },
{ path: 'settings', component: SettingsComponent },
],
},
];
<!-- AdminLayoutComponent template -->
<h2>Admin Panel</h2>
<nav>...</nav>
<router-outlet></router-outlet> <!-- child routes render here -->Lazy Loading
Lazy Loading teilt die App in auf Bedarf geladene Chunks und verkleinert das Anfangs-Bundle. loadChildren lädt eine Routen-Datei (Default-Export von Routes); loadComponent lädt eine einzelne Standalone-Komponente. Der dynamische import()-String muss ein statischer Pfad sein, damit der Bundler korrekt splittet. Nutze das für Feature-Bereiche hinter der Navigation.
// main routes - load feature modules on demand
export const routes: Routes = [
{ path: '', component: HomeComponent },
{
path: 'admin',
loadChildren: () => import('./admin/admin.routes').then(m => m.ADMIN_ROUTES),
},
{
path: 'reports',
loadComponent: () => import('./reports/reports.component')
.then(m => m.ReportsComponent),
},
];
// admin.routes.ts
export const ADMIN_ROUTES: Routes = [
{ path: '', component: AdminComponent },
{ path: 'users', component: AdminUsersComponent },
];Router-Events & Navigation
Router-Events (NavigationStart, NavigationEnd, GuardsCheckStart usw.) lassen dich den Navigations-Lebenszyklus verfolgen. Immer auf bestimmte Events filtern und unsubscriben. router.navigate akzeptiert Extras: queryParams, fragment, state (transiente Daten, nicht in der URL) und replaceUrl. state ist lesbar über router.getCurrentNavigation().extras.state.
// subscribe to router events
export class AppComponent implements OnDestroy {
private sub = this.router.events.pipe(
filter((e): e is NavigationEnd => e instanceof NavigationEnd)
).subscribe(e => {
console.log('Navigated to:', e.url);
this.analytics.track(e.url);
});
constructor(private router: Router) {}
ngOnDestroy() { this.sub.unsubscribe(); }
}
// navigation with extras
this.router.navigate(['/users'], {
queryParams: { sort: 'name' },
fragment: 'top',
state: { from: 'login' }, // passed to next route, not in URL
});Formulare
Template-getriebenes Formular
Template-getriebene Formulare nutzen ngModel und Template-Referenzen. FormsModule ist erforderlich. Der Formularzustand (Gültigkeit, touched, dirty) wird über die Direktiven ngForm und ngModel getrackt. Am besten für einfache Formulare. Validierung wird im Template deklariert (required, minlength, pattern). Auf den Kontrollzustand greift man über Template-Refs wie #e='ngModel' zu.
import { FormsModule } from '@angular/forms';
@Component({
selector: 'app-login',
standalone: true,
imports: [FormsModule],
template: `
<form #f="ngForm" (ngSubmit)="save(f.value)">
<input name="email" [(ngModel)]="email" required email #e="ngModel" />
<span *ngIf="e.invalid && e.touched">Email required</span>
<input name="pwd" type="password" [(ngModel)]="pwd" required minlength="6" />
<button [disabled]="f.invalid">Submit</button>
</form>
`,
})
export class LoginComponent {
email = '';
pwd = '';
save(v: any) { console.log(v); }
}Reactive Formular einrichten
Reactive Forms definieren das Modell in der Komponentenklasse als FormControl/FormGroup-Instanzen. ReactiveFormsModule ist erforderlich. formControlName bindet Inputs an Controls. Das Formularmodell ist observable und testbar ohne DOM. nonNullable: true verhindert null-Werte, wenn das Input geleert wird. Bevorzugt für komplexe Formulare.
import { ReactiveFormsModule, FormControl, FormGroup } from '@angular/forms';
@Component({
selector: 'app-profile',
imports: [ReactiveFormsModule],
template: `
<form [formGroup]="form" (ngSubmit)="save()">
<input formControlName="name" />
<input formControlName="email" />
<button [disabled]="form.invalid">Save</button>
</form>
<p>Valid: {{ form.valid }}</p>
`,
})
export class ProfileComponent {
form = new FormGroup({
name: new FormControl('', { nonNullable: true }),
email: new FormControl('', { nonNullable: true }),
});
save() { console.log(this.form.value); }
}FormBuilder & typisierte Forms
FormBuilder reduziert Boilerplate. fb.group() leitet Typen aus Defaults ab. Verschachtelte Gruppen modellieren verschachtelte Daten. FormArray verwaltet dynamische Control-Listen. Mit nonNullable bleiben Controls vom deklarierten Typ statt null. Nutze get() oder controls für typsicheren Zugriff. Typisierte Forms (v14+) liefern Autocomplete und Typprüfung für values.
import { FormBuilder, FormGroup } from '@angular/forms';
export class CheckoutComponent {
private fb = inject(FormBuilder);
// typed form (v14+ nonNullable)
form = this.fb.group({
name: ['', { nonNullable: true }],
address: this.fb.group({
street: [''],
city: [''],
zip: [''],
}),
items: this.fb.array<CartItem>([]),
});
// type-safe access
get items() { return this.form.controls.items; }
addItem(item: CartItem) { this.items.push(this.fb.control(item)); }
}Formular-Validierung
Validators.required, .minLength, .maxLength, .pattern, .email, .min, .max sind eingebaut. Mehrere via Array anwenden. Feldübergreifende Validierung liegt auf der FormGroup mit einer Validator-Funktion, die die ganze Gruppe erhält. Prüfe control.touched/dirty, bevor du Fehler zeigst, um Nutzer beim ersten Rendern nicht sofort mit Fehlern zu überhäufen. Mit .hasError('key') testest du konkrete Fehler.
import { Validators } from '@angular/forms';
// built-in validators
const email = new FormControl('', [
Validators.required,
Validators.email,
Validators.maxLength(100),
]);
const password = new FormControl('', [
Validators.required,
Validators.minLength(8),
Validators.pattern(/[A-Z]/),
]);
// cross-field validation at group level
const form = this.fb.group({
pwd: ['', Validators.required],
confirm: ['', Validators.required],
}, { validators: matchPassword }); // custom group validator
// reading state in template
<!-- <span *ngIf="email.touched && email.hasError('required')">Required</span> -->Custom Validator
Custom Validatoren sind Funktionen, die ValidationErrors (eine Map) oder null zurückgeben, wenn gültig. Async Validatoren geben ein Observable oder Promise zurück — nutze sie für Server-Prüfungen wie Benutzernamen-Verfügbarkeit. Entprelle async Validatoren immer (via timer/switchMap), um den Server nicht bei jedem Tastendruck zu bombardieren.
import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
// function validator
export const matchPassword: ValidatorFn = (group: AbstractControl): ValidationErrors | null => {
const pwd = group.get('pwd')?.value;
const confirm = group.get('confirm')?.value;
return pwd === confirm ? null : { mismatch: true };
};
// async validator (returns Observable/Promise)
export function uniqueUsername(http: HttpClient): AsyncValidatorFn {
return (control: AbstractControl) => {
return timer(500).pipe(
switchMap(() => http.get(`/api/check/${control.value}`)),
map(exists => exists ? { taken: true } : null),
);
};
}Formular-Wertänderungen & Zustand
valueChanges und statusChanges sind Observables, die bei jeder Eingabe auslösen. debounceTime verhindert übermäßige Arbeit bei schnellem Tippen. takeUntil mit einem Subject ist der idiomatische Weg, beim Destroy zu unsubscriben. patchValue aktualisiert Teilwerte des Formulars; setValue verlangt alle Felder. Mit { emitEvent: false } aktualisierst du still, ohne valueChanges auszulösen.
export class FilterComponent implements OnDestroy {
private destroy = new Subject<void>();
form = this.fb.group({ q: [''], category: ['all'] });
ngOnInit() {
// react to entire form changes (debounced)
this.form.valueChanges.pipe(
debounceTime(300),
takeUntil(this.destroy),
).subscribe(v => this.search(v));
// react to a single control
this.form.controls.q.valueChanges.subscribe(q => {
console.log('q changed:', q);
});
}
ngOnDestroy() { this.destroy.next(); }
}HttpClient
Setup & grundlegendes GET
provideHttpClient() registriert den Client app-weit. HttpClient-Methoden geben kalte Observables zurück — sie laufen erst beim Subscriben (nutze die async Pipe in Templates oder subscribe in Services). Antworten sind per Generics typisiert. Behandle Fehler immer zentral oder pro Aufruf. withFetch() (v18) schaltet auf das moderne fetch-basierte Backend um.
// app.config.ts
import { provideHttpClient } from '@angular/common/http';
export const appConfig: ApplicationConfig = {
providers: [provideHttpClient()],
};
// usage in a service
@Injectable({ providedIn: 'root' })
export class PostService {
private http = inject(HttpClient);
private api = 'https://jsonplaceholder.typicode.com/posts';
getPosts() {
return this.http.get<Post[]>(this.api);
}
}
// in a component (use async pipe to auto-unsubscribe)
export class PostListComponent {
posts$ = this.posts.getPosts();
constructor(private posts: PostService) {}
}POST / PUT / DELETE
post/put/patch geben Observables zurück, die die Antwort einmal ausgeben und dann abschließen. Den Body als zweites Argument übergeben. Der Generic-Typ schränkt die Antwort ein. Die URL kann ein Template-Literal mit Parametern sein. Immer subscriben — Observables sind kalt und feuern sonst nicht. Für Einmal-Lesezugriffe greife auf toPromise() (deprecated) oder firstValueFrom() zurück.
export class PostService {
private http = inject(HttpClient);
create(post: Omit<Post, 'id'>) {
return this.http.post<Post>('/api/posts', post);
}
update(id: number, patch: Partial<Post>) {
return this.http.put<Post>(`/api/posts/${id}`, patch);
}
remove(id: number) {
return this.http.delete<void>(`/api/posts/${id}`);
}
}
// all return Observables — subscribe or use async pipe
// HTTP methods return a single value then completeQuery-Parameter & Header
params akzeptiert ein Objekt, HttpParams oder ein Array — Angular encodiert sie in den Query-String. headers setzt Request-Header. observe: 'response' gibt das vollständige HttpResponse zurück (status, headers, body) statt nur des Bodys. observe: 'events' mit reportProgress streamt Fortschritts-Events für Datei-Uploads/Downloads.
export class SearchService {
private http = inject(HttpClient);
search(term: string, page = 1) {
return this.http.get<Result[]>('/api/search', {
params: { q: term, page, sort: 'desc' },
headers: { 'X-Api-Key': 'secret' },
observe: 'response', // get full HttpResponse
responseType: 'json',
});
}
// observe: 'events' streams upload/download progress
upload(file: File) {
return this.http.post('/api/upload', file, {
reportProgress: true,
observe: 'events',
});
}
}Interceptors
Funktionale Interceptors (v15+) sind einfache Funktionen, die über withInterceptors() verkettet werden. Sie laufen bei jedem Request in dieser Reihenfolge — ideal für Auth-Tokens, Logging, Retry-Logik oder Caching. clone() erzeugt einen veränderten Request (Requests sind immutable). Die Funktion next(req) gibt den Antwort-Stream zurück — Pipe-Operatoren wie retry, catchError greifen hier.
// functional interceptor (v15+)
export const authInterceptor: HttpInterceptorFn = (req, next) => {
const token = localStorage.getItem('token');
const authReq = token
? req.clone({ setHeaders: { Authorization: `Bearer ${token}` } })
: req;
return next(authReq);
};
// register in app.config.ts
providers: [provideHttpClient(withInterceptors([authInterceptor]))]
// error/logging interceptor
export const loggingInterceptor: HttpInterceptorFn = (req, next) => {
console.log('Request:', req.url);
return next(req).pipe(tap({
error: e => console.error('Failed:', req.url, e),
}));
};Fehlerbehandlung
Nutze RxJS-Operatoren für HTTP-Resilienz: retry abonniert bei Fehler erneut, timeout bricht langsame Requests ab, catchError mappt Fehler auf Fallback-Werte oder wirft erneut. Behandle Fehler zusätzlich immer auf der Konsumentenseite — unbehandelte Observable-Fehler stoppen den Stream. Subscriben mit next/error/complete-Callbacks für volle Lebenszyklus-Steuerung.
export class PostService {
getPost(id: number) {
return this.http.get<Post>(`/api/posts/${id}`).pipe(
retry(2), // retry on failure
timeout(5000), // abort after 5s
catchError(err => {
if (err.status === 404) return of(null); // graceful fallback
return throwError(() => new Error('Network error'));
}),
);
}
}
// component-side
this.posts.getPost(1).subscribe({
next: p => this.post = p,
error: e => this.error = e.message,
complete: () => this.loading = false,
});Typisierte Antworten & withFetch
Generics typisieren den Antwort-Body, prüfen aber nicht zur Laufzeit — zur Sicherheit nutze einen Runtime-Validator wie zod. observe: 'response' legt status, headers und body offen. withFetch() (v18) nutzt die Fetch-API statt XHR und ermöglicht Streaming und besseres Server-Side-Rendering. withXsrfConfiguration ergänzt automatische CSRF-Token-Behandlung.
// typed generic — response is typed, runtime NOT validated
this.http.get<User[]>('/api/users');
// full HttpResponse observation
this.http.get<User>('/api/users/1', { observe: 'response' })
.subscribe(res => {
console.log(res.status); // 200
console.log(res.headers.get('X-Total-Count'));
console.log(res.body); // User
});
// opt into fetch() backend (v18+, recommended)
// provideHttpClient(withFetch())
// with XSRF protection enabled
// provideHttpClient(withXsrfConfiguration({ cookieName: 'XSRF-TOKEN' }))Observables & RxJS
Grundlegendes Observable
Observables sind lazy — der Producer läuft erst beim Subscriben. Sie können null oder mehrere Werte ausgeben und dann complete oder error. Der subscribe-Callback erhält next, error, complete. Bei langlebigen Abos immer unsubscriben (oder async Pipe / takeUntilDestroyed nutzen). of() gibt Werte synchron aus; from() flacht Arrays oder Promises ab.
import { Observable } from 'rxjs';
const obs = new Observable<number>(subscriber => {
subscriber.next(1);
subscriber.next(2);
setTimeout(() => {
subscriber.next(3);
subscriber.complete();
}, 1000);
});
const sub = obs.subscribe({
next: v => console.log(v),
error: e => console.error(e),
complete: () => console.log('done'),
});
// cleanup
sub.unsubscribe();
// use of(...) for synchronous values
of(1, 2, 3).subscribe(v => console.log(v));
// from(iterable) for arrays/async iterables
from([1, 2, 3]).subscribe(console.log);Häufige Operatoren
Operatoren transformieren Streams. map/filter arbeiten wie Array-Methoden. debounceTime wartet auf eine Ruhephase (ideal für Suchfelder). distinctUntilChanged überspringt identische aufeinanderfolgende Werte. switchMap bricht das vorherige innere Observable ab, wenn ein neuer Wert ankommt — perfekt für Suche bei jedem Tastendruck. Pipe-Operatoren von links nach rechts.
import { of, from, interval } from 'rxjs';
import { map, filter, switchMap, debounceTime, distinctUntilChanged } from 'rxjs/operators';
of(1, 2, 3, 4).pipe(
map(x => x * 10), // 10, 20, 30, 40
filter(x => x > 15), // 20, 30, 40
).subscribe(console.log);
// search input with debounce
input$.pipe(
debounceTime(300),
distinctUntilChanged(),
switchMap(term => http.get(`/api/search?q=${term}`)),
).subscribe(results => this.results = results);Streams kombinieren
combineLatest gibt aus, sobald eine Quelle ausgibt (nachdem alle mindestens einmal ausgegeben haben) — ideal für abgeleiteten View-Zustand. forkJoin wartet, bis alle Quellen abgeschlossen sind, und liefert den letzten Wert jeder Quelle — nutze es für parallele HTTP-Requests. merge verzahnt Ausgaben. zip paart nach Index. race wählt das erste Observable, das ausgibt, und ignoriert den Rest.
import { combineLatest, forkJoin, merge, race, zip } from 'rxjs';
// combineLatest: emits when ANY source emits, after all have emitted
combineLatest([user$, settings$]).subscribe(([u, s]) => ...);
// forkJoin: waits for all to complete, emits last values (like Promise.all)
forkJoin({ user: user$, posts: posts$ }).subscribe(r => ...);
// merge: emits values from all sources as they come
merge(clicks$, keys$).subscribe(e => ...);
// zip: pairs emissions by index
zip(range(1, 3), ['a', 'b', 'c']).subscribe(([n, letter]) => ...);
// race: takes the first to emit, ignores the rest
race(primary$, fallback$).subscribe(v => ...);Subjects (Multicasting)
Subjects sind sowohl Observables als auch Observers — mit .next() pusht man Werte. Subject: kein Anfangswert, spätere Abonnenten verpassen frühere Ausgaben. BehaviorSubject: braucht einen Anfangswert, neue Abonnenten erhalten sofort den aktuellen Wert (für State). ReplaySubject: puffert die letzten N Werte für neue Abonnenten (zum Wiederholen von Events).
import { Subject, BehaviorSubject, ReplaySubject } from 'rxjs';
// Subject: emits to current subscribers only
const click$ = new Subject<MouseEvent>();
click$.subscribe(x => console.log('A:', x));
click$.next({} as MouseEvent); // A: logs it
// BehaviorSubject: keeps last value, new subs get it immediately
const count$ = new BehaviorSubject(0);
count$.subscribe(v => console.log(v)); // logs 0 immediately
count$.next(1); // logs 1 to subscribers
// ReplaySubject: replays last N values to new subscribers
const recent$ = new ReplaySubject<string>(2);
recent$.next('a'); recent$.next('b'); recent$.next('c');
recent$.subscribe(v => console.log(v)); // logs 'b', then 'c'takeUntil & Cleanup
takeUntil(unsubscribe$) beendet ein Abo automatisch, wenn der Notifier ausgibt — das Standardmuster gegen Leaks in Komponenten. takeUntilDestroyed() (v16+) nutzt Angulars DestroyRef für Auto-Unsubscribe ohne OnDestroy-Boilerplate. Es muss im Injection-Kontext aufgerufen werden (Konstruktor oder Feld-Initialisierer) oder explizit ein DestroyRef erhalten.
import { Subject, takeUntil, takeUntilDestroyed } from 'rxjs';
export class DemoComponent implements OnDestroy {
private destroy$ = new Subject<void>();
ngOnInit() {
this.svc.stream$.pipe(
takeUntil(this.destroy$),
).subscribe(data => this.data = data);
}
ngOnDestroy() { this.destroy$.next(); this.destroy$.complete(); }
}
// v16+: takeUntilDestroyed (uses DestroyRef, no boilerplate)
export class DemoComponent {
data: any;
constructor() {
inject(SomeService).stream$.pipe(
takeUntilDestroyed(),
).subscribe(d => this.data = d);
}
}switchMap vs. mergeMap vs. concatMap
Diese Flattening-Operatoren unterscheiden sich im Umgang mit überlappenden inneren Observables. switchMap bricht ab (Suche bei jedem Tastendruck). mergeMap parallelisiert (vieles laden). concatMap reiht in die Warteschlange (Reihenfolge wahren). exhaustMap verwirft (Doppelsenden verhindern). Die falsche Wahl verursacht Race Conditions — den Operator an die Abbruch-Semantik des Anwendungsfalls anpassen.
import { from, interval } from 'rxjs';
import { switchMap, mergeMap, concatMap, exhaustMap } from 'rxjs/operators';
// switchMap: cancels the previous inner stream on new value
input$.pipe(switchMap(term => search(term)));
// Best for: typeahead search (discard stale results)
// mergeMap: runs all inner streams in parallel
ids$.pipe(mergeMap(id => fetchDetail(id)));
// Best for: parallel requests, order doesn't matter
// concatMap: queues inner streams, runs one at a time
queue$.pipe(concatMap(task => runTask(task)));
// Best for: ordered sequential operations
// exhaustMap: ignores new values while inner stream is active
save$.pipe(exhaustMap(() => saveForm()));
// Best for: prevent double-submit (ignore clicks while saving)Lifecycle-Hooks
Hook-Reihenfolge im Überblick
Hooks feuern in einer strengen Reihenfolge. ngOnChanges feuert bei @Input-Änderungen (und initial). ngOnInit feuert einmal nach dem ersten ngOnChanges. ngDoCheck läuft bei jedem Change-Detection-Zyklus. Die After*-Hooks signalisieren, dass Content/View für DOM-Abfragen bereit sind. ngOnDestroy ist der Aufräumpunkt — unsubscriben, Ressourcen freigeben, Timer abbrechen.
export class LifecycleComponent implements
OnChanges, OnInit, DoCheck, AfterContentInit,
AfterContentChecked, AfterViewInit, AfterViewChecked, OnDestroy {
ngOnChanges() { console.log('1. input changes'); }
ngOnInit() { console.log('2. component init (once)'); }
ngDoCheck() { console.log('3. custom change detection'); }
ngAfterContentInit() { console.log('4. projected content ready'); }
ngAfterContentChecked() { console.log('5. projected content checked'); }
ngAfterViewInit() { console.log('6. view (template) ready'); }
ngAfterViewChecked() { console.log('7. view checked'); }
ngOnDestroy() { console.log('8. cleanup before destroy'); }
}ngOnInit & ngOnDestroy
ngOnInit läuft einmal, nachdem Inputs gesetzt sind — der richtige Ort für teure Initialisierung (Fetching, Abos), da der Konstruktor leichtgewichtig bleiben sollte. ngOnDestroy ist der einzige Hook beim Zerstören der Komponente — niemals hier Cleanup überspringen, sonst leakst du Abos, Timer und Event-Listener. Der Konstruktor ist nur für DI; Logik gehört in ngOnInit.
export class ChartComponent implements OnInit, OnDestroy {
private timer?: ReturnType<typeof setInterval>;
ngOnInit() {
// good for: data fetching, initialization, subscriptions
this.timer = setInterval(() => this.refresh(), 5000);
this.loadInitialData();
}
ngOnDestroy() {
// cleanup: clear timers, unsubscribe, release resources
if (this.timer) clearInterval(this.timer);
// also: this.sub.unsubscribe();
}
private refresh() { /* ... */ }
private loadInitialData() { /* ... */ }
}ngOnChanges (SimpleChange)
ngOnChanges feuert, sobald sich eine @Input-Referenz ändert, mit einer SimpleChanges-Map: jeder Eintrag hat previousValue, currentValue, firstChange und isFirstChange(). Es feuert NICHT, wenn du die Properties eines Objekts mutierst — nur bei Änderung der Referenz. Für tiefe Änderungen nutze ngOnChanges mit einem Setter oder ngDoCheck mit IterableDiffers.
export class PaginationComponent implements OnChanges {
@Input() page = 1;
@Input() total = 0;
ngOnChanges(changes: SimpleChanges) {
if (changes['page'] && !changes['page'].firstChange) {
// react only when page actually changed (not on init)
console.log('page:', changes['page'].previousValue, '->', changes['page'].currentValue);
this.fetchPage(this.page);
}
}
private fetchPage(p: number) { /* ... */ }
}ngAfterViewInit & ViewChild
ViewChild/ContentChild-Abfragen lösen sich NACH den jeweiligen Init-Hooks auf. ngAfterViewInit für Elemente im eigenen Template der Komponente; ngAfterContentInit für projizierten Inhalt via <ng-content>. Zugriff auf diese Refs in ngOnInit liefert undefined. Die !-Non-Null-Assertion sagt dem Compiler, dass der Wert nach dem Init gesetzt ist — sicher nutzbar aber nur in After*-Hooks.
export class CanvasComponent implements AfterViewInit {
@ViewChild('canvas') canvasRef!: ElementRef<HTMLCanvasElement>;
// ❌ canvasRef is undefined in ngOnInit
ngOnInit() { /* this.canvasRef is undefined here */ }
// ✅ available after view init
ngAfterViewInit() {
const canvas = this.canvasRef.nativeElement;
const ctx = canvas.getContext('2d');
ctx?.fillText('Hello', 10, 50);
}
}
// template: <canvas #canvas></canvas>ngDoCheck (Custom Detection)
ngDoCheck läuft bei jedem Change-Detection-Zyklus — halte es leichtgewichtig. Mit IterableDiffers/KeyValueDiffers erkennst du Mutationen an Arrays/Objekten, die ngOnChanges entgehen (weil sich Referenzen nicht ändern). Das ist der Notausgang zum Tracken interner Mutationen. Vermeide teure Logik hier; sie läuft häufig und kann Performance-Probleme verursachen.
export class ListComponent implements DoCheck {
@Input() items: Item[] = [];
private differ: IterableDiffer<Item>;
constructor(differs: IterableDiffers) {
this.differ = differs.find(items).create<Item>((i) => i.id);
}
ngDoCheck() {
const changes = this.differ.diff(this.items);
if (changes) {
changes.forEachAddedItem(r => console.log('Added:', r.item));
changes.forEachRemovedItem(r => console.log('Removed:', r.item));
}
}
}Content- vs. View-Hooks
Content-Hooks (AfterContentInit/Checked) feuern für projizierten Inhalt via <ng-content>. View-Hooks (AfterViewInit/Checked) feuern für das eigene Template der Komponente. Content-Hooks feuern VOR den View-Hooks, weil Content initialisiert wird, bevor die View fertig ist. @ContentChild fragt projizierte Elemente ab; @ViewChild Elemente des eigenen Templates.
export class CardComponent implements
AfterContentInit, AfterViewInit, AfterContentChecked, AfterViewChecked {
@ContentChild('header') headerTpl?: TemplateRef<unknown>;
@ViewChild('body') bodyEl?: ElementRef<HTMLElement>;
// projected content (<ng-content>) is ready
ngAfterContentInit() {
console.log('content ready:', this.headerTpl);
}
// own template view is ready
ngAfterViewInit() {
console.log('view ready:', this.bodyEl?.nativeElement);
}
// ContentChecked/ViewChecked run every CD cycle after init — beware perf
}Content Projection
Grundlegendes ng-content
<ng-content> ist ein Platzhalter, an dem vom Parent bereitgestellter Inhalt projiziert wird. Denk an Angulars <slot>. Ohne select landet hier aller projizierter Inhalt. Projizierter Inhalt wird im Kontext des Parents kompiliert — Bindings wie {{ }} lösen sich gegen die Parent-Komponente auf, nicht gegen CardComponent.
// card.component.ts
@Component({
selector: 'app-card',
template: `
<div class="card">
<ng-content></ng-content>
</div>
`,
styles: ['.card { border: 1px solid #ccc; padding: 16px; }'],
})
export class CardComponent {}
<!-- usage: anything inside projects into <ng-content> -->
<app-card>
<h3>Title</h3>
<p>Body content here.</p>
</app-card>Multi-Slot-Projektion
Das select-Attribut auf ng-content zielt auf bestimmte projizierte Inhalte: nach Element ('header'), Attribut ('[header]'), Klasse ('.active') oder Kombinationen ('div.foo[bar]'). Nicht gematchter Inhalt fällt in das ng-content ohne select. Projizierter Inhalt behält Styles und Kontext des Parents — nur seine Position im DOM ändert sich.
@Component({
selector: 'app-layout',
template: `
<header><ng-content select="[header]"></ng-content></header>
<main><ng-content></ng-content></main>
<footer><ng-content select="footer"></ng-content></footer>
`,
})
export class LayoutComponent {}
<!-- usage: select matches attributes, elements, classes -->
<app-layout>
<nav header>Top nav</nav>
<p>Main body</p>
<footer>Bottom</footer>
</app-layout>Bedingte Projektion (ng-template)
Für bedingte oder wiederholte Projektion gibt ng-template mit ngTemplateOutlet volle Kontrolle. ContentChildren fragt projizierte Direktiven ab. ngTemplateOutlet rendert eine TemplateRef an einem frei wählbaren Ort — nützlich für Tabs, Accordions oder bedingte Slots. Dieses Muster entkoppelt die Inhaltsdeklaration davon, wo und wann er gerendert wird.
@Component({
selector: 'app-tabs',
template: `
<div class="tabs">
@for (t of tabs; track t) {
<button (click)="active = t">{{ t.title }}</button>
}
</div>
@for (t of tabs; track t) {
@if (t === active) {
<ng-container [ngTemplateOutlet]="t.template" />
}
}
`,
})
export class TabsComponent {
@ContentChildren(TabDirective) tabs!: QueryList<TabDirective>;
active: any;
}ContentChild & ContentChildren
@ContentChild / @ContentChildren fragen projizierten Inhalt ab (vs. ViewChild für das eigene Template). ContentChildren gibt eine QueryList zurück, die sich bei Inhaltsänderungen aktualisiert. Auflösen in ngAfterContentInit. Die Option { descendants: true } (Standard) durchläuft allen projizierten Inhalt. Mit { read: ... } fragst du einen bestimmten Typ ab (ElementRef, TemplateRef usw.).
@Directive({ selector: 'tab' })
export class TabDirective {
@Input() title = '';
@Input() active = false;
@ContentChild(TemplateRef) template!: TemplateRef<unknown>;
}
@Component({
selector: 'app-tabset',
template: `
@for (tab of tabs; track tab) {
<button (click)="select(tab)">{{ tab.title }}</button>
}
<ng-container *ngTemplateOutlet="activeTab?.template" />
`,
})
export class TabsetComponent implements AfterContentInit {
@ContentChildren(TabDirective) tabs!: QueryList<TabDirective>;
activeTab?: TabDirective;
ngAfterContentInit() {
this.activeTab = this.tabs.find(t => t.active) ?? this.tabs.first;
}
}ngTemplateOutlet mit Context
ngTemplateOutlet rendert eine TemplateRef mit optionalem Context. let-x bindet an context.$implicit (den Standardwert); let-y='key' bindet an context.key. So übergeben *ngFor und ngTemplateOutlet Schleifenvariablen. Nutze dieses Muster für wiederverwendbare Listen-/Grid-/Item-Templates, die Parents anpassen können, während die Komponente die Iterationslogik steuert.
@Component({
selector: 'app-list',
template: `
@for (item of items; track item.id) {
<ng-container *ngTemplateOutlet="itemTpl; context: { $implicit: item, i: $index }" />
}
<ng-template #itemTpl let-item let-i="i">
<li>{{ i }}: {{ item.name }}</li>
</ng-template>
`,
})
export class ListComponent {
items = [{ id: 1, name: 'A' }, { id: 2, name: 'B' }];
}ng-content select-Muster
select akzeptiert CSS-ähnliche Selektoren: Klassen (.x), Attribute ([x]), Elemente (header) oder kommaseparierte Listen ('a, b'). Inhalt ohne passenden Selektor fällt in das ng-content ohne select. Gibt es keinen Fallback, wird nicht gematchter Inhalt verworfen. Selektoren matchen gegen die eigenen Attribute der projizierten Elemente, nicht deren innere Struktur.
@Component({
selector: 'app-modal',
template: `
<div class="modal">
<ng-content select=".modal-header"></ng-content>
<ng-content select="[body]"></ng-content>
<ng-content select="app-modal-footer, footer"></ng-content>
<!-- fallback for unmatched content -->
<ng-content></ng-content>
</div>
`,
})
<!-- matches by class, attribute, element, or selector list -->
<app-modal>
<div class="modal-header">Title</div>
<section body>Body text</section>
<app-modal-footer>OK</app-modal-footer>
<p>This falls into the unselect'd slot.</p>
</app-modal>Route-Guards
CanActivate (funktional)
Funktionale Guards (v14.2+) geben true/false/UrlTree oder ein Observable/Promise davon zurück. Ein zurückgegebener UrlTree leitet auf diese Route um. inject() funktioniert, weil Guards im Injection-Kontext laufen. CanActivate verhindert die Navigation zu einer Route. Registriere Guards pro Route im canActivate-Array. Sie laufen bei jeder Navigation zu dieser Route.
import { inject } from '@angular/core';
import { CanActivateFn, Router } from '@angular/router';
export const authGuard: CanActivateFn = (route, state) => {
const auth = inject(AuthService);
const router = inject(Router);
if (auth.isLoggedIn) return true;
// redirect to login, preserving the attempted URL
return router.createUrlTree(['/login'], {
queryParams: { returnUrl: state.url },
});
};
// register in routes
{ path: 'dashboard', component: DashboardComponent, canActivate: [authGuard] }CanActivateChild
CanActivateChild läuft vor jeder Child-Route unterhalb des Parents — aufgeräumter, als canActivate an jedes Child zu hängen. Nutze es für den gemeinsamen Schutz eines Feature-Bereichs. Gibt dieselben Werttypen zurück wie CanActivate. Um auch den Parent selbst zu schützen, ergänze zusätzlich canActivate an der Parent-Route.
export const adminGuard: CanActivateChildFn = (route, state) => {
const auth = inject(AuthService);
if (!auth.isAdmin) {
return inject(Router).parseUrl('/forbidden');
}
return true;
};
// applies to all children of this route
{
path: 'admin',
canActivateChild: [adminGuard],
children: [
{ path: 'users', component: AdminUsersComponent },
{ path: 'settings', component: AdminSettingsComponent },
],
}CanDeactivate (ungespeicherte Änderungen)
CanDeactivate läuft, bevor eine Route verlassen wird — perfekt, um vor ungespeicherten Formularänderungen zu warnen. Der Guard erhält die Komponenteninstanz und ruft darauf eine Methode auf. Rückgabe false bricht die Navigation ab, true führt sie fort. Für async (Modale-Bestätigung) gib ein Observable oder Promise zurück. Die Komponente muss einen Vertrag erfüllen, den der Guard erwartet.
import { CanDeactivateFn } from '@angular/router';
import { inject } from '@angular/core';
export interface CanComponentDeactivate {
canDeactivate: () => boolean | Observable<boolean>;
}
export const unsavedGuard: CanDeactivateFn<CanComponentDeactivate> = (component) => {
return component?.canDeactivate() ?? true;
};
// component
export class EditComponent implements CanComponentDeactivate {
canDeactivate() {
if (this.form.dirty) return confirm('Discard changes?');
return true;
}
}
// route: { path: 'edit/:id', canDeactivate: [unsavedGuard] }CanMatch (bedingtes Laden)
CanMatch (v14.1+) läuft, bevor der Chunk einer lazy Route überhaupt heruntergeladen wird — effizienter als CanActivate für Paywall-Feature-Gates. Gibt es false zurück, wird die Route komplett übersprungen (andere passende Routen kommen zum Zug). CanActivate würde den Chunk erst laden und dann ablehnen. Nutze CanMatch, um das Herunterladen von Code zu verhindern, den Nutzer nicht nutzen können.
import { CanMatchFn } from '@angular/router';
export const paidFeatureGuard: CanMatchFn = (route, segments) => {
const auth = inject(AuthService);
// runs BEFORE the lazy chunk is even loaded
if (auth.hasProPlan) return true;
return inject(Router).createUrlTree(['/upgrade']);
};
// route configuration
{
path: 'premium',
canMatch: [paidFeatureGuard],
loadComponent: () => import('./premium/premium.component'),
}Resolve (Daten vorab laden)
Resolve läuft vor der Aktivierung der Route und verzögert die Navigation, bis die Daten da sind. Die aufgelösten Daten landen in route.snapshot.data. Nützlich, damit Komponenten beim Rendern Daten haben (kein Aufblitzen leerer Zustände). Behandle Fehler im Resolver — EMPTY bricht die Navigation ab. Für nicht-blockierendes Laden: lieber in ngOnInit fetchen.
import { ResolveFn } from '@angular/router';
import { inject } from '@angular/core';
export const userResolver: ResolveFn<User> = (route) => {
const id = route.paramMap.get('id')!;
return inject(UserService).getUser(+id).pipe(
catchError(() => {
inject(Router).navigate(['/users']);
return EMPTY;
}),
);
};
// route
{ path: 'users/:id', resolve: { user: userResolver }, component: UserComponent }
// component reads pre-fetched data
export class UserComponent {
user = this.route.snapshot.data['user'] as User;
constructor(private route: ActivatedRoute) {}
}Guard-Komposition & Reihenfolge
Mehrere Guards laufen in Array-Reihenfolge; der erste Fehlschlag bricht die Navigation ab. canMatch läuft vor dem Laden lazy Chunks; canActivate danach. canDeactivate läuft beim Verlassen. Alle Guards können synchron (boolean) oder async (Observable/Promise) sein. Halte sie schnell — sie blockieren die UI. Schwere Server-Prüfungen sollten entprellen oder Ergebnisse cachen.
// multiple guards run in declaration order, all must pass
{
path: 'admin',
canActivate: [authGuard, roleGuard],
canMatch: [paidFeatureGuard],
canDeactivate: [unsavedGuard],
loadChildren: () => import('./admin/admin.routes'),
}
// guard returning Observable (async check)
export const roleGuard: CanActivateFn = () => {
return inject(AuthService).hasRole('admin').pipe(
map(ok => ok || inject(Router).parseUrl('/forbidden')),
);
};
// ordering: canMatch → resolve → canActivate → canActivateChildResolvers
Grundlegender Resolver (ResolveFn)
ResolveFn ist die funktionale Resolver-API. Sie läuft, bevor die Navigation abgeschlossen ist, und der Rückgabewert landet unter dem zugewiesenen Key in route.data. Die Komponente kann ihn synchron aus snapshot.data lesen — kein Ladezustand nötig. Abonniere route.data für reaktive Updates bei Navigationen zwischen Routen derselben Komponente.
import { ResolveFn } from '@angular/router';
import { inject } from '@angular/core';
export const postResolver: ResolveFn<Post> = (route, state) => {
const id = Number(route.paramMap.get('id'));
return inject(PostService).getPost(id);
};
// route
{
path: 'posts/:id',
resolve: { post: postResolver },
component: PostDetailComponent,
}
// reading the resolved data
export class PostDetailComponent {
post = this.route.snapshot.data['post'] as Post;
constructor(private route: ActivatedRoute) {}
// reactive: re-fetch when :id changes (same component reused)
ngOnInit() {
this.route.data.subscribe(d => this.post = d['post']);
}
}Mehrere Resolvers
Mehrere Resolvers laufen parallel — alle müssen fertig sein, bevor die Route aktiviert wird. Jeder Key in resolve wird ein Key in route.data. Schlägt einer fehl, wird die Navigation abgebrochen. Für unabhängige Daten ist das effizient. Hängt einer von einem anderen ab, schachtel sie oder verketten sie in einem einzigen Resolver. Wäge Resolver vs. ngOnInit-Fetch ab.
{
path: 'dashboard',
component: DashboardComponent,
resolve: {
user: userResolver,
stats: statsResolver,
notifications: notifResolver,
},
}
// component
export class DashboardComponent {
constructor(private route: ActivatedRoute) {}
ngOnInit() {
const { user, stats, notifications } = this.route.snapshot.data;
// all three resolved before component loads
}
}Resolver-Fehlerbehandlung
Behandle Resolver-Fehler explizit — unbehandelte Fehler brechen die Navigation stumm ab. EMPTY schließt den Stream ohne Ausgabe ab und bricht die Navigation ab. Die Rückgabe von null lässt die Komponente fehlende Daten sanft verarbeiten. Bei 404s auf eine not-found-Route umleiten. Fehler immer loggen oder sichtbar machen; stille Fehler sind für Nutzer schwer zu debuggen.
export const userResolver: ResolveFn<User | null> = (route) => {
const id = route.paramMap.get('id')!;
const router = inject(Router);
const service = inject(UserService);
return service.getUser(+id).pipe(
catchError(err => {
if (err.status === 404) {
// redirect to a 'not found' page, cancel navigation
router.navigate(['/404']);
return EMPTY;
}
// re-throw other errors
return throwError(() => err);
}),
);
};Resolver vs. ngOnInit-Fetch
Resolvers blockieren die Navigation, bis Daten da sind — sauberes UX, fühlt sich aber langsamer an. ngOnInit-Fetching ist nicht blockierend, braucht aber Ladezustände in der Komponente. Moderne Angular-Richtung ist nicht-blockierend: in der Komponente fetchen mit Loading-Skeleton für bessere empfundene Performance. Resolvers nur nutzen, wenn die Komponente ohne die Daten wirklich nicht rendern kann.
// Approach A: Resolver (blocks navigation until data arrives)
// ✅ Component renders with data — no flicker
// ❌ Slower navigation feel, blocks route transition
{
path: 'user/:id',
resolve: { user: userResolver },
component: UserComponent,
}
// Approach B: Fetch in ngOnInit (non-blocking)
// ✅ Snappy navigation, show loading skeleton
// ❌ Component must handle null/loading state
export class UserComponent implements OnInit {
user?: User;
loading = true;
ngOnInit() {
this.route.params.subscribe(p => {
this.loading = true;
this.svc.getUser(+p['id']).subscribe(u => {
this.user = u;
this.loading = false;
});
});
}
}Resolver mit Query-Params & Signals
Resolvers können paramMap und queryParamMap von der Route lesen. Wenn dieselbe Komponente verschiedene Parameter verarbeitet, abonniere route.data reaktiv statt den Snapshot zu nutzen. Mit Signals aktualisiere ein Signal aus dem Data-Abo. Kombiniere Resolvers mit Signals für einen sauberen, reaktiven Datenfluss. Vermeide schwere Resolvers — sie blockieren die Navigation.
// read query params inside a resolver
export const searchResolver: ResolveFn<SearchResult[]> = (route) => {
const q = route.queryParamMap.get('q') ?? '';
const page = Number(route.queryParamMap.get('page') ?? 1);
return inject(SearchService).search(q, page);
};
// resolver feeding a signal-based component
export class SearchComponent {
private route = inject(ActivatedRoute);
results = signal<SearchResult[]>([]);
constructor() {
this.route.data.subscribe(d => this.results.set(d['results']));
}
}Animationen
Setup & grundlegende Animation
provideAnimations() registriert das Animations-Modul. trigger() definiert eine benannte Animation; transition() deklariert den Wechsel zwischen Zuständen. :enter und :leave sind eingebaute Pseudo-Zustände für Elemente, die via *ngIf oder @if hinzugefügt/entfernt werden. Angewendet über @triggerName im Template. Beim v17+ Control Flow funktionieren Animationen weiterhin mit @if/@for.
// app.config.ts
import { provideAnimations } from '@angular/platform-browser/animations';
export const appConfig: ApplicationConfig = {
providers: [provideAnimations()],
};
// component
@Component({
selector: 'app-fade',
animations: [
trigger('fadeIn', [
transition(':enter', [
style({ opacity: 0 }),
animate('300ms ease-in', style({ opacity: 1 })),
]),
transition(':leave', [
animate('300ms ease-out', style({ opacity: 0 })),
]),
]),
],
template: `<div *ngIf="show" @fadeIn>Hello</div>`,
})States & Transitions
state() definiert benannte Styles im Ruhezustand. transition('a => b') animiert von Zustand a zu b; '<=>' ist bidirektional. Binde den Trigger an einen Ausdruck, der den Zustandsnamen liefert. Zustands-Styles greifen sofort (ohne Animation); Transitions animieren dazwischen. Nutze 'void' für Elemente noch nicht im DOM und '*' als Wildcard.
@Component({
selector: 'app-toggle',
animations: [
trigger('openClose', [
state('open', style({ height: '*', opacity: 1 })),
state('closed', style({ height: '0', opacity: 0 })),
transition('open => closed', animate('200ms ease-out')),
transition('closed => open', animate('300ms ease-in')),
// bidirectional shortcut: 'open <=> closed'
]),
],
template: `
<button (click)="isOpen = !isOpen">Toggle</button>
<div [@openClose]="isOpen ? 'open' : 'closed'">Panel</div>
`,
})
export class ToggleComponent { isOpen = false; }Keyframes & parallele Animationen
keyframes() definieren Zwischenschritte mit offset (0 bis 1) für feingranulare Kontrolle — wie CSS @keyframes. group() läuft Animationen parallel; sequence() nacheinander. Damit komponierst du komplexe Ein-/Ausblend-Effekte. Halte Animationen kurz (200–400 ms) und respektiere prefers-reduced-motion für Barrierefreiheit.
trigger('wiggle', [
transition('* => *', [
animate('600ms ease-in-out', keyframes([
style({ transform: 'translateX(0)', offset: 0 }),
style({ transform: 'translateX(-10px)', offset: 0.25 }),
style({ transform: 'translateX(10px)', offset: 0.75 }),
style({ transform: 'translateX(0)', offset: 1 }),
])),
]),
]),
// parallel/group animations
transition(':enter', [
group([
animate('300ms', style({ opacity: 1 })),
animate('300ms', style({ transform: 'translateY(0)' })),
]),
]),Animierte Liste (@for)
Wende :enter/:leave-Animationen auf @for-Elemente an — sie feuern, wenn Elemente hinzugefügt oder entfernt werden. track sorgt dafür, dass Angular Elemente über Änderungen hinweg korrekt identifiziert, sodass Animationen bei echtem Hinzufügen/Entfernen feuern (nicht beim Umsortieren). Listen-Animationen können ruckelig sein ohne korrektes Tracking. Für Umsortier-Animationen nutze query() und animateChild().
@Component({
selector: 'app-list',
animations: [
trigger('itemAnim', [
transition(':enter', [
style({ height: 0, opacity: 0 }),
animate('200ms', style({ height: '*', opacity: 1 })),
]),
transition(':leave', [
animate('200ms', style({ height: 0, opacity: 0 })),
]),
]),
],
template: `
@for (item of items; track item.id) {
<div @itemAnim>{{ item.name }}</div>
}
`,
})
export class AnimListComponent { items = [...]; }Router-Animationen
Binde den Animations-Trigger an den Aktivierungszustand des router-outlet. query(':enter'/:leave) zielt auf die eintretenden/verlassenden gerouteten Komponenten. { optional: true } vermeidet Fehler, wenn eine Seite fehlt (beim initialen Laden gibt es kein :leave). position: absolute stapelt alte und neue Komponenten während der Transition. Route-Animationen liefern App-artige Übergänge zwischen Views.
@Component({
selector: 'app-root',
animations: [
trigger('routeAnim', [
transition('* => *', [
query(':enter', [
style({ opacity: 0, position: 'absolute', width: '100%' }),
animate('300ms', style({ opacity: 1 })),
], { optional: true }),
query(':leave', [
animate('300ms', style({ opacity: 0 })),
], { optional: true }),
]),
]),
],
template: `
<div [@routeAnim]="o.isActivated ? o.activatedRoute : ''">
<router-outlet #o="outlet"></router-outlet>
</div>
`,
})Reduced Motion & CSS-Animationen
Respektiere prefers-reduced-motion immer für Barrierefreiheit — manche Nutzer bekommen Bewegungsübelkeit. Angular-Animationen fügen ~50 KB zum Bundle hinzu; für einfache Fades reichen vielleicht reine CSS-Animationen. Nutze Angular-Animationen, wenn du zustandsbehaftete Transitions (Zustandsautomaten), Parent-Child-Koordination oder Route-Animationen brauchst. CSS ist leichter für Hover-/Fade-Effekte.
// respect prefers-reduced-motion
@Component({
selector: 'app-safe-anim',
animations: [
trigger('fade', [
transition(':enter', [
style({ opacity: 0 }),
animate('300ms', style({ opacity: 1 })),
]),
]),
],
// or just use CSS — Angular animations add bundle weight
template: `<div class="fade-in" @fade>Content</div>`,
styles: [`
@media (prefers-reduced-motion: reduce) {
.fade-in { animation: none !important; transition: none !important; }
}
`],
})Testing
Komponenten-Test-Setup
TestBed konfiguriert das Testmodul. Für Standalone-Komponenten importiere sie direkt (keine declarations in TestBed.configureTestingModule nötig). createComponent gibt eine ComponentFixture zurück: .componentInstance für die Klasse, .nativeElement für das DOM, .detectChanges() zum Auslösen der Change Detection. beforeEach mit async/await erledigt compileComponents.
import { ComponentFixture, TestBed } from '@angular/core/testing';
import { MyComponent } from './my.component';
describe('MyComponent', () => {
let fixture: ComponentFixture<MyComponent>;
let component: MyComponent;
beforeEach(async () => {
await TestBed.configureTestingModule({
imports: [MyComponent], // standalone components are imported
}).compileComponents();
fixture = TestBed.createComponent(MyComponent);
component = fixture.componentInstance;
fixture.detectChanges(); // runs initial change detection
});
it('should create', () => {
expect(component).toBeTruthy();
});
});Tests mit Mock-Services
Stelle Mock-Implementierungen von Services bereit, um die getestete Komponente zu isolieren. jasmine.createSpy() lässt dich Rückgabewerte steuern und Aufrufe prüfen. Nutze useValue für Objekt-Mocks, useClass für klassenbasierte Fakes. Ersetze HttpClient durch HttpTestingController für HTTP-Tests. Mocks halten Tests schnell und deterministisch — keine echten Netzwerkaufrufe.
describe('UserComponent', () => {
let mockUserService = {
getUsers: jasmine.createSpy().and.returnValue(of([...])),
addUser: jasmine.createSpy().and.returnValue(of({})),
};
beforeEach(async () => {
await TestBed.configureTestingModule({
imports: [UserComponent],
providers: [
{ provide: UserService, useValue: mockUserService },
],
}).compileComponents();
});
it('loads users on init', () => {
const fixture = TestBed.createComponent(UserComponent);
fixture.detectChanges();
expect(mockUserService.getUsers).toHaveBeenCalled();
expect(fixture.componentInstance.users.length).toBe(2);
});
});HTTP-Testing
HttpTestingController fängt HttpClient-Aufrufe in Tests ab — kein echtes Netzwerk. expectOne prüft, dass ein Request gestellt wurde, und gibt ihn zurück; flush() simuliert die Serverantwort. verify() stellt sicher, dass keine unverarbeiteten Requests übrig sind. Teste Erfolgs- und Fehlerpfade: flush mit einem Statuscode (z. B. { status: 500, statusText: 'Server Error' }), um Fehler zu simulieren.
import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
import { provideHttpClient } from '@angular/common/http';
describe('PostService', () => {
let service: PostService;
let httpMock: HttpTestingController;
beforeEach(() => {
TestBed.configureTestingModule({
providers: [
PostService,
provideHttpClient(),
provideHttpClientTesting(),
],
});
service = TestBed.inject(PostService);
httpMock = TestBed.inject(HttpTestingController);
});
it('fetches posts', () => {
service.getPosts().subscribe(posts => expect(posts.length).toBe(2));
const req = httpMock.expectOne('/api/posts');
expect(req.request.method).toBe('GET');
req.flush([{ id: 1 }, { id: 2 }]); // simulate response
httpMock.verify(); // no outstanding requests
});
});Testing von Template & Interaktionen
fixture.nativeElement gibt rohen DOM-Zugriff für Assertions. detectChanges() synchronisiert Template-Bindings, nachdem man Properties gesetzt hat. Mit spyOn prüfst du Methodenaufrufe. Für Abfragen innerhalb der Komponente ist debugElement.query(By.css()) typsicher. Events auslösen über native DOM-Methoden (click()) oder DebugElement.triggerEventHandler für Custom-Events.
it('renders the title', () => {
const fixture = TestBed.createComponent(MyComponent);
fixture.componentInstance.title = 'Hello';
fixture.detectChanges();
const el: HTMLElement = fixture.nativeElement;
expect(el.querySelector('h1')?.textContent).toContain('Hello');
});
it('calls save on button click', () => {
const fixture = TestBed.createComponent(MyComponent);
const spy = spyOn(fixture.componentInstance, 'save');
const button = fixture.nativeElement.querySelector('button');
button.click();
expect(spy).toHaveBeenCalled();
});
// By.css for debug element queries (faster than nativeElement)
const debugEl = fixture.debugElement.query(By.css('.submit'));Testing von Signals
Signals sind Funktionen — rufe sie (mit Klammern) auf, um in Tests Werte zu lesen. set() aktualisiert schreibbare Signals direkt, ohne den Umweg über indirekte Manipulation. detectChanges() synchronisiert signal-getriebene Templates. Für computed/effect stellt detectChanges oder TestBed.flushEffects() sicher, dass abhängige Effects laufen. Signals machen Tests synchroner und vorhersehbarer.
describe('CounterComponent', () => {
it('increments count', () => {
const fixture = TestBed.createComponent(CounterComponent);
const comp = fixture.componentInstance;
expect(comp.count()).toBe(0);
comp.increment();
expect(comp.count()).toBe(1);
// force signal effects to run in tests
fixture.detectChanges();
});
it('renders count in template', () => {
const fixture = TestBed.createComponent(CounterComponent);
fixture.componentInstance.count.set(5);
fixture.detectChanges(); // syncs signal to template
expect(fixture.nativeElement.textContent).toContain('5');
});
});E2E mit Cypress / Playwright
E2E-Tests durchlaufen die ganze App in einem echten Browser. Nutze data-cy-Attribute als Selektoren — sie sind stabil und koppeln nicht an CSS-Klassen. Cypress läuft im Browser; Playwright über mehrere Browser. Nutze ng e2e oder konfiguriere Cypress/Playwright manuell. E2E-Tests finden Integrationsprobleme, die Unit-Tests verpassen, sind aber langsamer — halte die Suite fokussiert.
// cypress test (cypress/e2e/login.cy.ts)
describe('Login flow', () => {
beforeEach(() => cy.visit('/login'));
it('logs in with valid credentials', () => {
cy.get('[data-cy=email]').type('[email protected]');
cy.get('[data-cy=password]').type('secret123');
cy.get('[data-cy=submit]').click();
cy.url().should('include', '/dashboard');
cy.contains('Welcome, User');
});
});
// run with: npx cypress open (interactive)
// npx cypress run (headless CI)PWA
PWA-Support hinzufügen
ng add @angular/pwa baut alles auf: Service-Worker-Registrierung, Web-Manifest und Icons. Der Service Worker läuft nur in Produktions-Builds (ng build --configuration production) — im Dev-Modus ist er deaktiviert, um Caching-Überraschungen zu vermeiden. registrationStrategy steuert, wann sich der SW registriert; registerWhenStable wartet, bis die App stabil ist.
# add @angular/service-worker
ng add @angular/pwa --project my-app
# this generates:
# - ngsw-config.json (service worker config)
# - manifest.webmanifest
# - icons in src/assets/icons/
# - registers service worker in app.config.ts
# app.config.ts (auto-updated)
export const appConfig: ApplicationConfig = {
providers: [
provideRouter(routes),
provideServiceWorker('ngsw-worker.js', {
enabled: environment.production,
registrationStrategy: 'registerWhenStable:30000',
}),
],
};Service-Worker-Konfiguration (ngsw-config.json)
assetGroups cachen die App-Shell (prefetch) und statische Assets (lazy). dataGroups cachen API-Antworten mit Frisch-/Performance-Strategien und TTLs. prefetch lädt vorab herunter; lazy lädt bei Bedarf. freshness versucht zuerst das Netzwerk und fällt aufs Caching zurück (gut für frische Daten); performance nutzt zuerst den Cache (gut für statische Daten).
{
"$schema": "./node_modules/@angular/service-worker/config/schema.json",
"index": "/index.html",
"assetGroups": [
{
"name": "app",
"installMode": "prefetch",
"updateMode": "prefetch",
"resources": {
"files": ["/favicon.ico", "/index.html", "/manifest.webmanifest", "/*.css", "/*.js"]
}
},
{
"name": "assets",
"installMode": "lazy",
"updateMode": "prefetch",
"resources": { "files": ["/assets/**", "/*.(svg|png|jpg|jpeg|webp|woff2)"] }
}
],
"dataGroups": [
{
"name": "api",
"urls": ["https://api.example.com/**"],
"cacheConfig": {
"maxSize": 100, "maxAge": "1d", "timeout": "10s", "strategy": "freshness"
}
}
]
}Updates behandeln
SwUpdate meldet, wenn eine neue Version verfügbar ist. VERSION_READY bedeutet, dass ein neues Bundle heruntergeladen und aktivierungsbereit ist. activateUpdate() wechselt zur neuen Version; danach reload, um sie zu laden. Bei kritischen Updates sofort erzwingen. Bei unkritischen den Nutzer fragen. Abonniere versionUpdates, um VERSION_DETECTED, VERSION_READY und NO_NEW_VERSION_DETECTED zu behandeln.
import { SwUpdate } from '@angular/service-worker';
import { inject } from '@angular/core';
export class UpdatePromptComponent {
private updates = inject(SwUpdate);
updateAvailable = false;
constructor() {
this.updates.versionUpdates.subscribe(evt => {
if (evt.type === 'VERSION_READY') {
this.updateAvailable = true;
}
});
}
applyUpdate() {
this.updates.activateUpdate().then(() => document.location.reload());
}
}Offline-Support & Caching
SwPush ermöglicht Web-Push-Benachrichtigungen über den Service Worker. requestSubscription fragt den Nutzer um Erlaubnis und liefert ein Subscription-Objekt, das an deinen Server gesendet wird. Der SW empfängt Push-Events auch bei geschlossenem Tab. VAPID-Keys authentifizieren deinen Server. Kombiniere mit der Notification-API zum Anzeigen von Nachrichten; behandle Klicks, um in der App zu navigieren.
import { SwPush } from '@angular/service-worker';
export class NotificationComponent {
private swPush = inject(SwPush);
subscribeToPush() {
this.swPush.requestSubscription({
serverPublicKey: this.VAPID_PUBLIC,
}).then(sub => this.sendToServer(sub))
.catch(err => console.error('Push denied', err));
}
// check if SW is enabled
ngOnInit() {
if (!this.swPush.isEnabled) {
console.warn('Push notifications not supported');
}
}
}App-Manifest
Das Web-Manifest macht die App installierbar (Zum Startbildschirm hinzufügen). name/short_name erscheinen auf dem Startbildschirm; theme_color färbt die Browser-UI; display: standalone entfernt Browser-Chrome für ein App-Gefühl. Stelle mehrere Icon-Größen bereit (192, 512) plus ein maskable-Icon für Android. Teste mit Lighthouses PWA-Audit, um die Installierbarkeit zu prüfen.
<!-- index.html (added by ng add @angular/pwa) -->
<link rel="manifest" href="manifest.webmanifest">
<meta name="theme-color" content="#1976d2">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<link rel="apple-touch-icon" href="assets/icons/icon-152x152.png">
// manifest.webmanifest
{
"name": "My App",
"short_name": "MyApp",
"theme_color": "#1976d2",
"background_color": "#fafafa",
"display": "standalone",
"scope": "/",
"start_url": "/",
"icons": [
{ "src": "assets/icons/icon-192x192.png", "sizes": "192x192", "type": "image/png" },
{ "src": "assets/icons/icon-512x512.png", "sizes": "512x512", "type": "image/png" }
]
}Installierbarkeit & Lighthouse
beforeinstallprompt feuert in Chrome, wenn die App installierbar ist, und erlaubt dir, den nativen Dialog aufzuschieben. Speichere das Event und löse prompt() aus einer Nutzergeste aus (Button-Klick). iOS Safari feuert dieses Event nicht — Nutzer installieren über das Teilen-Menü. Führe Lighthouses PWA-Audit aus, um die Installierbarkeit zu prüfen. PWAs funktionieren offline nur, wenn der Service Worker die App-Shell cached.
// detect install prompt (Chrome)
let deferredPrompt: any;
window.addEventListener('beforeinstallprompt', (e) => {
e.preventDefault();
deferredPrompt = e;
this.canInstall = true; // show "Install App" button
});
// user-triggered install (must be from user gesture)
async installApp() {
if (!deferredPrompt) return;
deferredPrompt.prompt();
const { outcome } = await deferredPrompt.userChoice;
console.log('Install:', outcome);
deferredPrompt = null;
}
// Lighthouse PWA checklist:
// ✅ served over HTTPS
// ✅ registers a service worker
// ✅ has a web manifest with icons
// ✅ start_url loads offlineStandalone-Komponenten
Standalone bootstrappen
bootstrapApplication startet eine Standalone-App — kein NgModule nötig. Die Root-AppComponent muss standalone sein. app.config.ts zentralisiert Provider (router, http, animations, zone config). Das ist der Standard seit v17. Jede provideX()-Funktion verdrahtet ein Subsystem. Viel sauberer als AppModule + AppModule-Provider.
// main.ts
import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { AppComponent } from './app/app.component';
bootstrapApplication(AppComponent, appConfig)
.catch(err => console.error(err));
// app.config.ts
import { ApplicationConfig, provideZoneChangeDetection } from '@angular/core';
import { provideRouter } from '@angular/router';
import { provideHttpClient } from '@angular/common/http';
import { routes } from './app.routes';
export const appConfig: ApplicationConfig = {
providers: [
provideZoneChangeDetection({ eventCoalescing: true }),
provideRouter(routes),
provideHttpClient(),
],
};Standalone-Komponenten-Imports
standalone: true markiert die Komponente als in sich geschlossen. Das imports-Array listet alles, was das Template braucht: Module, Komponenten, Direktiven, Pipes. Mit v17+ Control Flow (@if/@for) brauchst du dafür kein CommonModule. Importiere nur, was verwendet wird, für besseres Tree-Shaking. Standalone-Komponenten lassen sich über exports in NgModules nutzen.
@Component({
selector: 'app-user-list',
standalone: true,
imports: [
CommonModule, // *ngIf, *ngFor, pipes (or use built-in @if/@for)
FormsModule, // ngModel
UserCardComponent, // another standalone component
HighlightDirective, // standalone directive
TruncatePipe, // standalone pipe
],
template: `
<input [(ngModel)]="filter" />
@for (u of users; track u.id) {
<app-user-card [user]="u" appHighlight>{{ u.name | truncate:20 }}</app-user-card>
}
`,
})
export class UserListComponent { ... }Standalone-Routen & Lazy Loading
loadComponent lazy-lädt eine einzelne Standalone-Komponente — kleinstmöglicher Chunk. loadChildren lazy-lädt eine Routen-Datei (Default-Export von Routes). Beide nutzen dynamisches import() mit statischem Pfad, damit der Bundler splittet. Das ersetzt Feature-Module komplett. Jede lazy Route bekommt ihre eigene JS-Datei, geladen bei der ersten Navigation.
export const routes: Routes = [
{ path: '', loadComponent: () => import('./home/home.component')
.then(m => m.HomeComponent) },
{
path: 'admin',
loadComponent: () => import('./admin/admin.component')
.then(m => m.AdminComponent),
canMatch: [authGuard],
},
{
path: 'reports',
loadChildren: () => import('./reports/reports.routes')
.then(m => m.REPORTS_ROUTES),
},
];Direktiven & Pipes als Standalone
Auch Direktiven und Pipes können standalone sein (v15+). Ergänze standalone: true und importiere sie in jede Komponente, die sie braucht. Damit entfällt das Deklarieren in einem gemeinsamen Modul. F ür Rückwärtskompatibilität lassen sich Standalone-Direktiven/-Pipes weiterhin in NgModule-Exports aufnehmen, um sie in NgModule-basierten Komponenten zu nutzen.
@Directive({
selector: '[appHighlight]',
standalone: true,
})
export class HighlightDirective { ... }
@Pipe({
name: 'truncate',
standalone: true,
})
export class TruncatePipe implements PipeTransform { ... }
// use directly in a standalone component's imports
@Component({
imports: [HighlightDirective, TruncatePipe],
template: `<p appHighlight>{{ text | truncate:10 }}</p>`,
})Migration von NgModule
Das Schematic automatisiert die Migration: es macht alle Deklarationen standalone, verschiebt NgModule-Imports in das imports-Array jeder Komponente und entfernt obsolete Module. Führe es inkrementell aus — es kann teilweise sein. Nach der Migration kannst du AppRoutingModule, AppModule löschen und bootstrapApplication nutzen. Das Ergebnis ist eine schlankere, besser tree-shakebare App.
# automatic migration (v15.2+)
ng generate @angular/core:standalone
# options:
# 1. Convert all components/directives/pipes to standalone
# 2. Remove unnecessary NgModule classes
# 3. Bootstrap the app using bootstrapApplication
// before: declared in a module
@NgModule({
declarations: [OldComponent],
imports: [CommonModule],
exports: [OldComponent],
})
export class OldModule {}
// after: standalone component
@Component({
standalone: true,
imports: [CommonModule],
// ...
})
export class OldComponent {}Injection in Standalone-Providern
Standalone-Apps konfigurieren Provider in app.config.ts statt im AppModule. APP_INITIALIZER läuft vor dem Bootstrap. Provider auf Komponentenebene gelten für den Teilbaum dieser Komponente. Für Services bleibt providedIn: 'root' bevorzugt — tree-shakeable. Nutze providers-Arrays für Nicht-Service-Werte (Tokens, Konfigs, Mocks).
// app.config.ts — global providers
export const appConfig: ApplicationConfig = {
providers: [
{ provide: API_URL, useValue: 'https://api.example.com' },
{ provide: ErrorHandler, useClass: GlobalErrorHandler },
{ provide: APP_INITIALIZER, multi: true, useFactory: () => initApp },
],
};
// component-level providers (scoped to this component and children)
@Component({
providers: [
{ provide: UserService, useClass: MockUserService },
],
})
export class AdminComponent {}
// tree-shakable service
@Injectable({ providedIn: 'root' }) // preferred over providers array
export class AuthService {}Signals
Signals erstellen
signal() erzeugt einen reaktiven Wert. Gelesen wird durch Aufruf: count(). Aktualisieren mit set() (ersetzen) oder update() (aus vorherigem Wert berechnen). Signals sind synchron und vermeiden den Overhead von Observables für einfachen State. In Templates rufst du sie mit () auf — ab v17.2+ entwrappen sie sich in manchen Kontexten auch automatisch. Signals integrieren sich in die OnPush-Change-Detection.
import { signal, computed, effect } from '@angular/core';
export class CounterComponent {
// writable signal with initial value
count = signal(0);
user = signal<User | null>(null);
// reading: call the signal as a function
current = this.count(); // 0
// writing
increment() { this.count.update(v => v + 1); }
setFive() { this.count.set(5); }
// in templates, signals are called automatically in v17.2+
// {{ count }} or {{ count() }} both work in templates
}Computed Signals
computed() erzeugt ein abgeleitetes, readonly Signal, das seine Abhängigkeiten automatisch trackt und seinen Wert cached. Es rechnet nur neu, wenn sich eine Abhängigkeit ändert UND es erneut gelesen wird — lazy Evaluation. Computed Signals können von anderen Computed Signals abhängen und bilden so einen Graph. Anders als Methoden cachen sie Ergebnisse. Das ersetzt viele Einsatzfälle von RxJS combineLatest.
export class CartComponent {
items = signal<Item[]>([]);
taxRate = signal(0.08);
// derived state — recomputes only when items or taxRate change
subtotal = computed(() =>
this.items().reduce((sum, i) => sum + i.price * i.qty, 0)
);
tax = computed(() => Math.round(this.subtotal() * this.taxRate() * 100) / 100);
total = computed(() => this.subtotal() + this.tax());
// computed signals are readonly and cached
// they recompute lazily only when read AND a dependency changed
}Effects (Nebeneffekte)
effect() führt einen Nebeneffekt aus, wenn sich seine Signal-Abhängigkeiten ändern. Nutze es für Logging, Synchronisation in localStorage, Datenabrufe oder DOM-Manipulation. Effects laufen nach der Change Detection. Vermeide es, Signals zu schreiben, die im selben Effect gelesen werden — das erzeugt Endlosschleifen. onCleanup registriert Teardown-Logik für den nächsten Lauf. Effects müssen im Injection-Kontext erzeugt werden.
export class SearchComponent {
query = signal('');
results = signal<Result[]>([]);
constructor() {
// effect runs when its signal dependencies change
effect(() => {
const q = this.query();
// ⚠️ avoid setting signals read in this effect (causes loops)
this.search(q).then(r => this.results.set(r));
});
}
// effect with cleanup
private log = effect((onCleanup) => {
const id = setInterval(() => console.log(this.count()), 1000);
onCleanup(() => clearInterval(id));
});
}Signals in Templates (OnPush)
Signals integrieren sich nahtlos in OnPush — Angular weiß genau, welche Views von einem Signal abhängen, und markiert nur diese zur Prüfung, wenn es sich ändert. Kein manuelles markForCheck() nötig. In Templates Signale mit () aufrufen, um zu lesen. OnPush + Signals ist das effizienteste Change-Detection-Setup und erlaubt oft, zone.js komplett fallen zu lassen (zoneless mode).
@Component({
selector: 'app-todo',
// signals work great with OnPush — automatic efficiency
changeDetection: ChangeDetectionStrategy.OnPush,
template: `
<input (input)="text.set($any($event.target).value)" />
<p>You typed: {{ text() }}</p>
<p>Length: {{ length() }}</p>
<button (click)="clear()">Clear</button>
`,
})
export class TodoComponent {
text = signal('');
length = computed(() => this.text().length);
clear() { this.text.set(''); }
}Signal-Inputs & Queries
input()/input.required() erzeugen readonly Signal-Inputs. output() erzeugt typisierte Outputs. model() erzeugt two-way bindbare Signal-Inputs (mit automatisch generiertem xChange-Output). viewChild()/contentChild() geben Signals zurück, die sich nach dem View-Init auflösen — mit () aufrufen, um zu lesen. Diese modernen APIs ersetzen @Input/@Output/@ViewChild-Decorators durch reaktive Signals.
import { input, output, viewChild, contentChild, model } from '@angular/core';
export class EditComponent {
// signal input (readonly, v17.1+)
id = input<number>(0);
requiredName = input.required<string>();
// signal output (v17.3+)
saved = output<User>();
// two-way signal (v17.2+)
value = model<number>(0); // creates input + output named valueChange
// signal queries
inputEl = viewChild<ElementRef>('input'); // in own template
header = contentChild<TemplateRef>('header'); // projected content
focus() { this.inputEl()?.nativeElement.focus(); }
}Signals & RxJS-Interop
toSignal wandelt ein Observable in ein Signal um (abonniert einmal, unsubscribed beim Destroy). toObservable macht das Gegenteil. Nutze Interop, um Signals (für synchronen State) mit RxJS (für komplexe async Flüsse wie entprellte Suche) zu mischen. takeUntilDestroyed unsubscribed automatisch über DestroyRef. initialValue verhindert undefined-Lesen vor der ersten Ausgabe. Injection-Kontext erforderlich.
import { toSignal, toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
export class SearchComponent {
private http = inject(HttpClient);
// Observable → Signal (one-way)
results = toSignal(this.http.get<Result[]>('/api/results'), {
initialValue: [] as Result[],
});
// Signal → Observable (for RxJS operators)
private query$ = toObservable(this.query);
// combine the best of both worlds
filtered = toSignal(
this.query$.pipe(
debounceTime(300),
switchMap(q => this.http.get(`/api/search?q=${q}`)),
takeUntilDestroyed(),
),
{ initialValue: [] as Result[] },
);
}NgModules & Architektur
NgModule-Struktur
NgModules organisieren die App in kohärente Blöcke. declarations listet, was das Modul besitzt. imports bringen Exports anderer Module herein. exports stellen Deklarationen für Importeure bereit. Nur das Root-Modul setzt bootstrap. Modernes Angular bevorzugt Standalone-Komponenten (kein NgModule), aber NgModule-Apps existieren weiterhin. Verstehe beides — ältere Codebasen und manche Bibliotheken nutzen Module.
@NgModule({
declarations: [ // components, directives, pipes owned by this module
AppComponent,
UserListComponent,
HighlightDirective,
TruncatePipe,
],
imports: [ // other modules whose exports this module needs
BrowserModule,
FormsModule,
HttpClientModule,
AppRoutingModule,
],
exports: [ // what's visible to modules that import this module
UserListComponent,
TruncatePipe,
],
providers: [], // services (use providedIn: 'root' instead)
bootstrap: [AppComponent], // only in the root module
})
export class AppModule {}Feature- & Shared-Module
SharedModule bündelt häufige UI-Komponenten/Direktiven/Pipes für die Wiederverwendung über Features — exportiere CommonModule und FormsModule mit, damit Importeure es nicht selbst tun müssen. Feature-Module kapseln einen Feature-Bereich; forChild() erlaubt demselben Modul, sich pro Import unterschiedlich zu konfigurieren (z. B. Routing). In Standalone-Apps sind einzelne Standalone-Komponenten besser als Shared-Module.
// shared.module.ts — reusable UI bits
@NgModule({
imports: [CommonModule, FormsModule],
declarations: [ButtonComponent, CardComponent, HighlightDirective],
exports: [ButtonComponent, CardComponent, HighlightDirective, FormsModule],
})
export class SharedModule {}
// feature module (lazy-loaded)
@NgModule({
declarations: [AdminComponent, AdminUsersComponent],
imports: [CommonModule, RouterModule, SharedModule],
exports: [AdminComponent],
})
export class AdminModule {
static forChild(): ModuleWithProviders<AdminModule> {
return { ngModule: AdminModule, providers: [AdminService] };
}
}Core-Module & Singleton-Services
CoreModule hält app-weite Singletons (Services, Interceptors, Error-Handler) und wird einmal in AppModule importiert. Der Konstruktor-Guard verhindert versehentliches Re-Importieren (das würde Service-Instanzen duplizieren). In Standalone-Apps wandern diese Provider in app.config.ts. Das CoreModule-Muster ist Legacy, aber du wirst es in Codebasen vor v14 antreffen.
// core.module.ts — app-wide singletons, imported once in AppModule
@NgModule({
providers: [
AuthService,
{ provide: HTTP_INTERCEPTORS, useClass: AuthInterceptor, multi: true },
{ provide: ErrorHandler, useClass: GlobalErrorHandler },
],
})
export class CoreModule {
// guard against importing twice
constructor(@Optional() @SkipSelf() parent?: CoreModule) {
if (parent) throw new Error('CoreModule already loaded');
}
}forRoot- vs. forChild-Muster
forRoot konfiguriert die Root-Instanz (einmal in AppModule aufgerufen); forChild registriert Child-Routen (in Feature-Modulen aufgerufen). Dieses Muster nutzt RouterModule und Bibliotheks-Module, die Konfiguration brauchen. Modernes Angular ersetzt es durch provideX()-Funktionen in app.config.ts. Das Muster taucht weiterhin in Drittbibliotheken auf — verstehe es für Integrationen.
// classic RouterModule pattern
@NgModule({ imports: [CommonModule], exports: [RouterModule] })
export class RouterModule {
static forRoot(routes: Routes): ModuleWithProviders<RouterModule> {
return {
ngModule: RouterModule,
providers: [provideRouter(routes)],
};
}
static forChild(routes: Routes): ModuleWithProviders<RouterModule> {
return { ngModule: RouterModule, providers: [provideRoutes(routes)] };
}
}
// AppModule imports: RouterModule.forRoot(ROUTES)
// FeatureModule imports: RouterModule.forChild(FEATURE_ROUTES)
// modern equivalent: provideRouter(routes) in app.config.tsEntry Components & dynamische Komponenten
entryComponents (deprecated) listete Komponenten, die dynamisch erzeugt wurden (Dialoge, Modals). Modernes Angular nutzt ViewContainerRef.createComponent() oder NgComponentOutlet — keine Registrierung nötig. Das funktioniert nahtlos mit Standalone-Komponenten. createComponent gibt eine ComponentRef mit .instance und .destroy() zurück. Räum auf, indem du destroy() aufrufst, um Leaks zu vermeiden.
// older API: entryComponents for dynamically created components
@NgModule({
entryComponents: [DialogComponent, ModalComponent],
})
export class AppModule {}
// modern: ViewContainerRef.createComponent (no entryComponents needed)
export class DialogService {
constructor(private vcr: ViewContainerRef) {}
open() {
const ref = this.vcr.createComponent(DialogComponent);
ref.instance.title = 'Hello';
ref.instance.close.subscribe(() => ref.destroy());
return ref;
}
}
// even simpler: NgComponentOutlet in template
<ng-container *ngComponentOutlet="dialogComponent; inputs: { title: 'Hi' }" />Lazy geladene Module
Lazy geladene Module erzeugen einen separaten JS-Chunk, der bei Navigation geladen wird. Das dynamische import() muss ein statischer String sein, damit der Bundler splittet. Lazy Module haben ihren eigenen Root-Injector — Services mit providedIn in einem lazy Module sind keine Singletons über die ganze App. Moderne Standalone-Apps nutzen stattdessen loadComponent/loadChildren mit Routen-Dateien — einfacher und feiner granuliert.
// classic lazy module (pre-standalone)
const routes: Routes = [
{
path: 'admin',
loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule),
},
];
// admin-routing.module.ts
const routes: Routes = [
{ path: '', component: AdminComponent },
{ path: 'users', component: AdminUsersComponent },
];
@NgModule({
imports: [RouterModule.forChild(routes)],
exports: [RouterModule],
})
export class AdminRoutingModule {}
// admin.module.ts
@NgModule({
declarations: [AdminComponent, AdminUsersComponent],
imports: [CommonModule, AdminRoutingModule],
})
export class AdminModule {}Verwandte Angular-Snippets
Copy-paste ready code for common tasks.
Component Basics
Define an Angular component with selector, template, and styles.
Template Syntax & Binding
Interpolation, property, event, and two-way binding in Angular templates.
Built-in Directives
Use *ngIf, *ngFor, ngClass, and ngStyle to shape the DOM.
Pipes & Custom Pipe
Transform template values with built-in and custom pipes.
Services & Dependency Injection
Create an injectable service and consume it in a component.
Routing Configuration
Define routes with params, lazy loading, and redirects.
Reactive Forms
Build a typed reactive form with FormBuilder and validators.
HttpClient & RxJS
Perform typed HTTP requests with HttpClient and Observables.
Was this helpful?