Angular-UI-Muster
Kernprinzipien
- Nie veraltete UI anzeigen – Ladezustände nur, wenn tatsächlich geladen wird
- Fehler immer sichtbar machen – Benutzer müssen wissen, wenn etwas fehlschlägt
- Optimistische Aktualisierungen – Die UI fühlt sich sofort an
- Progressive Offenlegung – Mit
@deferInhalte anzeigen, sobald verfügbar - Sanfte Degradation – Teilweise Daten sind besser als gar keine Daten
Ladezustandsmuster
Die goldene Regel
Ladeindikator NUR anzeigen, wenn keine Daten vorhanden sind.
@Component({
template: `
@if (error()) {
<app-error-state [error]="error()" (retry)="load()" />
} @else if (loading() && !items().length) {
<app-skeleton-list />
} @else if (!items().length) {
<app-empty-state message="Keine Elemente gefunden" />
} @else {
<app-item-list [items]="items()" />
}
`,
})
export class ItemListComponent {
private store = inject(ItemStore);
items = this.store.items;
loading = this.store.loading;
error = this.store.error;
}
Entscheidungsbaum für Ladezustände
Gibt es einen Fehler?
→ Ja: Fehlerzustand mit Wiederholungsoption anzeigen
→ Nein: Weiter
Wird geladen UND wir haben keine Daten?
→ Ja: Ladeindikator anzeigen (Spinner/Skelett)
→ Nein: Weiter
Haben wir Daten?
→ Ja, mit Elementen: Daten anzeigen
→ Ja, aber leer: Leeren Zustand anzeigen
→ Nein: Laden anzeigen (Rückfall)
Skelett vs. Spinner
| Skelett verwenden, wenn | Spinner verwenden, wenn |
|---|---|
| Bekannte Inhaltsform | Unbekannte Inhaltsform |
| Listen-/Kartenlayouts | Modale Aktionen |
| Anfänglicher Seitenaufbau | Button-Absendungen |
| Inhaltsplatzhalter | Inline-Operationen |
Kontrollflussmuster
@if/@else für bedingte Darstellung
@if (user(); as user) {
<span>Willkommen, {{ user.name }}</span>
} @else if (loading()) {
<app-spinner size="small" />
} @else {
<a routerLink="/login">Anmelden</a>
}
@for mit Track
@for (item of items(); track item.id) {
<app-item-card [item]="item" (delete)="remove(item.id)" />
} @empty {
<app-empty-state
icon="inbox"
message="Noch keine Elemente"
actionLabel="Element erstellen"
(action)="create()"
/>
}
@defer für progressives Laden
<!-- Kritischer Inhalt wird sofort geladen -->
<app-header />
<app-hero-section />
<!-- Nicht-kritischer Inhalt wird verzögert -->
@defer (on viewport) {
<app-comments [postId]="postId()" />
} @placeholder {
<div class="h-32 bg-gray-100 animate-pulse"></div>
} @loading (minimum 200ms) {
<app-spinner />
} @error {
<app-error-state message="Kommentare konnten nicht geladen werden" />
}
Fehlerbehandlungsmuster
Fehlerbehandlungshierarchie
1. Inline-Fehler (Feldebene) → Formularvalidierungsfehler
2. Toast-Benachrichtigung → Behebbare Fehler, Benutzer kann wiederholen
3. Fehlerbanner → Seitenebenenfehler, Daten sind noch teilweise nutzbar
4. Vollständiger Fehlerbildschirm → Nicht behebbar, erfordert Benutzereingriff
Fehler immer anzeigen
KRITISCH: Fehler niemals stillschweigend verschlucken.
// RICHTIG – Fehler wird dem Benutzer immer angezeigt
@Component({...})
export class CreateItemComponent {
private store = inject(ItemStore);
private toast = inject(ToastService);
async create(data: CreateItemDto) {
try {
await this.store.create(data);
this.toast.success('Element erfolgreich erstellt');
this.router.navigate(['/items']);
} catch (error) {
console.error('createItem fehlgeschlagen:', error);
this.toast.error('Element konnte nicht erstellt werden. Bitte versuchen Sie es erneut.');
}
}
}
// FALSCH – Fehler stillschweigend abgefangen
async create(data: CreateItemDto) {
try {
await this.store.create(data);
} catch (error) {
console.error(error); // Benutzer sieht nichts!
}
}
Fehlerzustands-Komponentenmuster
@Component({
selector: "app-error-state",
standalone: true,
imports: [NgOptimizedImage],
template: `
<div class="error-state">
<img ngSrc="/assets/error-icon.svg" width="64" height="64" alt="" />
<h3>{{ title() }}</h3>
<p>{{ message() }}</p>
@if (retry.observed) {
<button (click)="retry.emit()" class="btn-primary">Erneut versuchen</button>
}
</div>
`,
})
export class ErrorStateComponent {
title = input("Etwas ist schiefgelaufen");
message = input("Ein unerwarteter Fehler ist aufgetreten");
retry = output<void>();
}
Button-Zustandsmuster
Button-Ladezustand
<button
(click)="handleSubmit()"
[disabled]="isSubmitting() || !form.valid"
class="btn-primary"
>
@if (isSubmitting()) {
<app-spinner size="small" class="mr-2" />
Speichern... } @else { Änderungen speichern }
</button>
Während Operationen deaktivieren
KRITISCH: Trigger während asynchroner Operationen immer deaktivieren.
// RICHTIG – Button während des Ladens deaktiviert
@Component({
template: `
<button
[disabled]="saving()"
(click)="save()"
>
@if (saving()) {
<app-spinner size="sm" /> Speichern...
} @else {
Speichern
}
</button>
`
})
export class SaveButtonComponent {
saving = signal(false);
async save() {
this.saving.set(true);
try {
await this.service.save();
} finally {
this.saving.set(false);
}
}
}
// FALSCH – Benutzer kann mehrmals klicken
<button (click)="save()">
{{ saving() ? 'Speichern...' : 'Speichern' }}
</button>
Leere Zustände
Anforderungen an leere Zustände
Jede Liste/Sammlung MUSS einen leeren Zustand haben:
@for (item of items(); track item.id) {
<app-item-card [item]="item" />
} @empty {
<app-empty-state
icon="folder-open"
title="Noch keine Elemente"
description="Erstellen Sie Ihr erstes Element, um loszulegen"
actionLabel="Element erstellen"
(action)="openCreateDialog()"
/>
}
Kontextbezogene leere Zustände
@Component({
selector: "app-empty-state",
template: `
<div class="empty-state">
<span class="icon" [class]="icon()"></span>
<h3>{{ title() }}</h3>
<p>{{ description() }}</p>
@if (actionLabel()) {
<button (click)="action.emit()" class="btn-primary">
{{ actionLabel() }}
</button>
}
</div>
`,
})
export class EmptyStateComponent {
icon = input("inbox");
title = input.required<string>();
description = input("");
actionLabel = input<string | null>(null);
action = output<void>();
}
Formularmuster
Formular mit Laden und Validierung
@Component({
template: `
<form [formGroup]="form" (ngSubmit)="onSubmit()">
<div class="form-field">
<label for="name">Name</label>
<input
id="name"
formControlName="name"
[class.error]="isFieldInvalid('name')"
/>
@if (isFieldInvalid("name")) {
<span class="error-text">
{{ getFieldError("name") }}
</span>
}
</div>
<div class="form-field">
<label for="email">E-Mail</label>
<input id="email" type="email" formControlName="email" />
@if (isFieldInvalid("email")) {
<span class="error-text">
{{ getFieldError("email") }}
</span>
}
</div>
<button type="submit" [disabled]="form.invalid || submitting()">
@if (submitting()) {
<app-spinner size="sm" /> Absenden...
} @else {
Absenden
}
</button>
</form>
`,
})
export class UserFormComponent {
private fb = inject(FormBuilder);
submitting = signal(false);
form = this.fb.group({
name: ["", [Validators.required, Validators.minLength(2)]],
email: ["", [Validators.required, Validators.email]],
});
isFieldInvalid(field: string): boolean {
const control = this.form.get(field);
return control ? control.invalid && control.touched : false;
}
getFieldError(field: string): string {
const control = this.form.get(field);
if (control?.hasError("required")) return "Dieses Feld ist erforderlich";
if (control?.hasError("email")) return "Ungültiges E-Mail-Format";
if (control?.hasError("minlength")) return "Zu kurz";
return "";
}
async onSubmit() {
if (this.form.invalid) return;
this.submitting.set(true);
try {
await this.service.submit(this.form.value);
this.toast.success("Erfolgreich abgesendet");
} catch {
this.toast.error("Absenden fehlgeschlagen");
} finally {
this.submitting.set(false);
}
}
}
Dialog-/Modalmuster
Bestätigungsdialog
// dialog.service.ts
@Injectable({ providedIn: 'root' })
export class DialogService {
private dialog = inject(Dialog); // CDK-Dialog oder individuell
async confirm(options: {
title: string;
message: string;
confirmText?: string;
cancelText?: string;
}): Promise<boolean> {
const dialogRef = this.dialog.open(ConfirmDialogComponent, {
data: options,
});
return await firstValueFrom(dialogRef.closed) ?? false;
}
}
// Verwendung
async deleteItem(item: Item) {
const confirmed = await this.dialog.confirm({
title: 'Element löschen',
message: `Sind Sie sicher, dass Sie "${item.name}" löschen möchten?`,
confirmText: 'Löschen',
});
if (confirmed) {
await this.store.delete(item.id);
}
}
Anti-Patterns
Ladezustände
// FALSCH – Spinner, obwohl Daten vorhanden sind (verursacht Blitz bei Neuabruf)
@if (loading()) {
<app-spinner />
}
// RICHTIG – Ladeanzeige nur ohne Daten
@if (loading() && !items().length) {
<app-spinner />
}
Fehlerbehandlung
// FALSCH – Fehler verschluckt
try {
await this.service.save();
} catch (e) {
console.log(e); // Benutzer hat keine Ahnung!
}
// RICHTIG – Fehler sichtbar gemacht
try {
await this.service.save();
} catch (e) {
console.error("Speichern fehlgeschlagen:", e);
this.toast.error("Speichern fehlgeschlagen. Bitte versuchen Sie es erneut.");
}
Button-Zustände
<!-- FALSCH – Button während der Absendung nicht deaktiviert -->
<button (click)="submit()">Absenden</button>
<!-- RICHTIG – Deaktiviert und zeigt Ladezustand -->
<button (click)="submit()" [disabled]="loading()">
@if (loading()) {
<app-spinner size="sm" />
} Absenden
</button>
UI-Zustands-Checkliste
Vor dem Abschluss einer UI-Komponente:
UI-Zustände
- Fehlerzustand behandelt und dem Benutzer angezeigt
- Ladezustand nur angezeigt, wenn keine Daten vorhanden sind
- Leerer Zustand für Sammlungen bereitgestellt (
@empty-Block) - Buttons während asynchroner Operationen deaktiviert
- Buttons zeigen bei Bedarf Ladeindikator
Daten & Mutationen
- Alle asynchronen Operationen haben Fehlerbehandlung
- Alle Benutzeraktionen haben Feedback (Toast/visuell)
- Optimistische Aktualisierungen werden bei Fehlschlag zurückgesetzt
Barrierefreiheit
- Ladezustände für Bildschirmlesegeräte angekündigt
- Fehlermeldungen mit Formularfeldern verknüpft
- Fokusverwaltung nach Zustandsänderungen
Integration mit anderen Skills
- angular-state-management: Signal Stores für den Zustand verwenden
- angular: Moderne Muster anwenden (Signals, @defer)
- testing-patterns: Alle UI-Zustände testen