React-UI-Muster
Kernprinzipien
- Zeige niemals veraltete UI – Lade-Spinner nur, wenn tatsächlich geladen wird
- Fehler immer anzeigen – Benutzer müssen wissen, wenn etwas fehlschlägt
- Optimistische Aktualisierungen – Die UI fühlt sich sofort an
- Progressive Offenlegung – Zeige Inhalte an, sobald sie verfügbar sind
- Sanfte Degradierung – Teilweise Daten sind besser als keine Daten
Muster für Ladezustände
Die goldene Regel
Zeige Ladeindikator NUR, wenn keine Daten zum Anzeigen vorhanden sind.
// RICHTIG – Ladevorgang nur anzeigen, wenn keine Daten vorhanden sind
const { data, loading, error } = useGetItemsQuery();
if (error) return <ErrorState error={error} onRetry={refetch} />;
if (loading && !data) return <LoadingState />;
if (!data?.items.length) return <EmptyState />;
return <ItemList items={data.items} />;
// FALSCH – Zeigt Spinner, obwohl zwischengespeicherte Daten vorhanden sind
if (loading) return <LoadingState />; // Blitzt beim erneuten Abruf auf!
Entscheidungsbaum für Ladezustände
Gibt es einen Fehler?
→ Ja: Fehlerzustand mit Wiederholungsoption anzeigen
→ Nein: Weiter
Wird gerade geladen UND haben wir 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 (Fallback)
Skelett vs. Spinner
| Skelett verwenden, wenn | Spinner verwenden, wenn |
|---|---|
| Bekannte Inhaltsform | Unbekannte Inhaltsform |
| Listen-/Kartenlayouts | Modale Aktionen |
| Initialer Seitenaufruf | Schaltflächenübermittlungen |
| Inhaltsplatzhalter | Inline-Operationen |
Muster für Fehlerbehandlung
Die Fehlerbehandlungshierarchie
1. Inline-Fehler (Feldebene) → Formularvalidierungsfehler
2. Toast-Benachrichtigung → Behebbare Fehler, Benutzer kann wiederholen
3. Fehlerbanner → Seitenebenenfehler, Daten noch teilweise verwendbar
4. Vollbild-Fehlerbildschirm → Nicht behebbar, erfordert Benutzereingriff
Fehler immer anzeigen
KRITISCH: Fehler niemals stillschweigend verschlucken.
// RICHTIG – Fehler wird dem Benutzer immer angezeigt
const [createItem, { loading }] = useCreateItemMutation({
onCompleted: () => {
toast.success({ title: 'Element erstellt' });
},
onError: (error) => {
console.error('createItem fehlgeschlagen:', error);
toast.error({ title: 'Element konnte nicht erstellt werden' });
},
});
// FALSCH – Fehler stillschweigend abgefangen, Benutzer hat keine Ahnung
const [createItem] = useCreateItemMutation({
onError: (error) => {
console.error(error); // Benutzer sieht nichts!
},
});
Komponentenmuster für Fehlerzustand
interface ErrorStateProps {
error: Error;
onRetry?: () => void;
title?: string;
}
const ErrorState = ({ error, onRetry, title }: ErrorStateProps) => (
<div className="error-state">
<Icon name="exclamation-circle" />
<h3>{title ?? 'Etwas ist schief gelaufen'}</h3>
<p>{error.message}</p>
{onRetry && (
<Button onClick={onRetry}>Erneut versuchen</Button>
)}
</div>
);
Muster für Schaltflächenzustände
Ladezustand der Schaltfläche
<Button
onClick={handleSubmit}
isLoading={isSubmitting}
disabled={!isValid || isSubmitting}
>
Absenden
</Button>
Während Operationen deaktivieren
KRITISCH: Trigger während asynchroner Operationen immer deaktivieren.
// RICHTIG – Schaltfläche während des Ladens deaktiviert
<Button
disabled={isSubmitting}
isLoading={isSubmitting}
onClick={handleSubmit}
>
Absenden
</Button>
// FALSCH – Benutzer kann mehrmals tippen
<Button onClick={handleSubmit}>
{isSubmitting ? 'Wird gesendet...' : 'Absenden'}
</Button>
Leere Zustände
Anforderungen an leere Zustände
Jede Liste/Sammlung MUSS einen leeren Zustand haben:
// FALSCH – Kein leerer Zustand
return <FlatList data={items} />;
// RICHTIG – Expliziter leerer Zustand
return (
<FlatList
data={items}
ListEmptyComponent={<EmptyState />}
/>
);
Kontextbezogene leere Zustände
// Suche ohne Ergebnisse
<EmptyState
icon="search"
title="Keine Ergebnisse gefunden"
description="Versuchen Sie andere Suchbegriffe"
/>
// Liste noch ohne Elemente
<EmptyState
icon="plus-circle"
title="Noch keine Elemente"
description="Erstellen Sie Ihr erstes Element"
action={{ label: 'Element erstellen', onClick: handleCreate }}
/>
Muster für Formularübermittlung
const MyForm = () => {
const [submit, { loading }] = useSubmitMutation({
onCompleted: handleSuccess,
onError: handleError,
});
const handleSubmit = async () => {
if (!isValid) {
toast.error({ title: 'Bitte beheben Sie die Fehler' });
return;
}
await submit({ variables: { input: values } });
};
return (
<form>
<Input
value={values.name}
onChange={handleChange('name')}
error={touched.name ? errors.name : undefined}
/>
<Button
type="submit"
onClick={handleSubmit}
disabled={!isValid || loading}
isLoading={loading}
>
Absenden
</Button>
</form>
);
};
Anti-Patterns
Ladezustände
// FALSCH – Spinner, wenn Daten vorhanden sind (verursacht Aufblitzen)
if (loading) return <Spinner />;
// RICHTIG – Nur Ladevorgang anzeigen, wenn keine Daten vorhanden sind
if (loading && !data) return <Spinner />;
Fehlerbehandlung
// FALSCH – Fehler verschluckt
try {
await mutation();
} catch (e) {
console.log(e); // Benutzer hat keine Ahnung!
}
// RICHTIG – Fehler angezeigt
onError: (error) => {
console.error('Vorgang fehlgeschlagen:', error);
toast.error({ title: 'Vorgang fehlgeschlagen' });
}
Schaltflächenzustände
// FALSCH – Schaltfläche während der Übermittlung nicht deaktiviert
<Button onClick={submit}>Absenden</Button>
// RICHTIG – Deaktiviert und zeigt Ladevorgang an
<Button onClick={submit} disabled={loading} isLoading={loading}>
Absenden
</Button>
Checkliste
Bevor Sie eine UI-Komponente abschließen:
UI-Zustände:
- Fehlerzustand behandelt und dem Benutzer angezeigt
- Ladezustand nur angezeigt, wenn keine Daten vorhanden sind
- Leerer Zustand für Sammlungen bereitgestellt
- Schaltflächen während asynchroner Operationen deaktiviert
- Schaltflächen zeigen bei Bedarf Ladeindikator an
Daten & Mutationen:
- Mutationen haben onError-Handler
- Alle Benutzeraktionen haben Feedback (Toast/visuell)
Integration mit anderen Fähigkeiten
- graphql-schema: Mutationsmuster mit korrekter Fehlerbehandlung verwenden
- testing-patterns: Alle UI-Zustände testen (Laden, Fehler, leer, Erfolg)
- formik-patterns: Formularübertragungsmuster anwenden