SwiftUI View Refactor
Übersicht
Wende eine konsistente Struktur und ein einheitliches Abhängigkeitsmuster auf SwiftUI-Views an, mit Fokus auf Reihenfolge, Model-View (MV)-Muster, sorgfältige Handhabung von View-Modellen und korrekte Observation-Nutzung.
Kernrichtlinien
1) View-Reihenfolge (oben → unten)
- Environment
private/publiclet@State/ andere gespeicherte Eigenschaften- berechnete
var(nicht-View) initbody- berechnete View-Builder / andere View-Helfer
- Helfer- / asynchrone Funktionen
2) MV (Model-View)-Muster bevorzugen
- Standardmäßig MV: Views sind leichtgewichtige Zustandsausdrücke; Modelle/Services besitzen die Geschäftslogik.
- Bevorzuge
@State,@Environment,@Queryundtask/onChangefür die Orchestrierung. - Injiziere Services und gemeinsam genutzte Modelle über
@Environment; halte Views klein und zusammensetzbar. - Teile große Views in Unterviews auf, anstatt ein View-Modell einzuführen.
3) Große Bodies und View-Eigenschaften aufteilen
- Wenn
bodylänger als ein Bildschirm wird oder mehrere logische Abschnitte hat, teile ihn in kleinere Unterviews auf. - Extrahiere große berechnete View-Eigenschaften (
var header: some View { ... }) in dedizierteView-Typen, wenn sie Zustand oder komplexe Verzweigungen tragen. - Es ist in Ordnung, verwandte Unterviews als berechnete View-Eigenschaften in derselben Datei zu behalten; extrahiere sie nur dann in eine eigenständige
View-Struktur, wenn es strukturell sinnvoll ist oder wenn eine Wiederverwendung beabsichtigt ist. - Bevorzuge die Übergabe kleiner Eingaben (Daten, Bindungen, Callbacks) gegenüber der Wiederverwendung des gesamten übergeordneten View-Status.
Beispiel (Extrahieren eines Abschnitts):
var body: some View {
VStack(alignment: .leading, spacing: 16) {
HeaderSection(title: title, isPinned: isPinned)
DetailsSection(details: details)
ActionsSection(onSave: onSave, onCancel: onCancel)
}
}
Beispiel (langer Body → kürzerer Body + berechnete Views in derselben Datei):
var body: some View {
List {
header
filters
results
footer
}
}
private var header: some View {
VStack(alignment: .leading, spacing: 6) {
Text(title).font(.title2)
Text(subtitle).font(.subheadline)
}
}
private var filters: some View {
ScrollView(.horizontal, showsIndicators: false) {
HStack {
ForEach(filterOptions, id: \.self) { option in
FilterChip(option: option, isSelected: option == selectedFilter)
.onTapGesture { selectedFilter = option }
}
}
}
}
Beispiel (Extrahieren einer komplexen berechneten View):
private var header: some View {
HeaderSection(title: title, subtitle: subtitle, status: status)
}
private struct HeaderSection: View {
let title: String
let subtitle: String?
let status: Status
var body: some View {
VStack(alignment: .leading, spacing: 4) {
Text(title).font(.headline)
if let subtitle { Text(subtitle).font(.subheadline) }
StatusBadge(status: status)
}
}
}
4) View-Modell-Handhabung (nur wenn bereits vorhanden)
- Führe kein View-Modell ein, es sei denn, die Anfrage oder der vorhandene Code erfordert dies eindeutig.
- Wenn ein View-Modell existiert, mache es nach Möglichkeit nicht-optional.
- Übergib Abhängigkeiten an die View über
initund gib sie dann iminitder View an das View-Modell weiter. - Vermeide
bootstrapIfNeeded-Muster.
Beispiel (Observationsbasiert):
@State private var viewModel: SomeViewModel
init(dependency: Dependency) {
_viewModel = State(initialValue: SomeViewModel(dependency: dependency))
}
5) Observation-Nutzung
- Speichere
@Observable-Referenztypen als@Statein der Basis-View. - Gib Observablen explizit bei Bedarf weiter; vermeide optionalen Zustand, es sei denn, es ist erforderlich.
Arbeitsablauf
- Ordne die View neu an, um den Reihenfolgeregeln zu entsprechen.
- Bevorzuge MV: Verlagere leichte Orchestrierung in die View unter Verwendung von
@State,@Environment,@Query,taskundonChange. - Wenn ein View-Modell existiert, ersetze optionale View-Modelle durch ein nicht-optionales
@State-View-Modell, das iminitdurch Übergabe von Abhängigkeiten aus der View initialisiert wird. - Bestätige die Observation-Nutzung:
@Statefür Basis-@Observable-View-Modelle, keine redundanten Wrapper. - Bewahre das Verhalten: Ändere kein Layout oder Geschäftslogik, es sei denn, es wird angefordert.
Hinweise
- Bevorzuge kleine, explizite Helfer gegenüber großen bedingten Blöcken.
- Halte berechnete View-Builder unterhalb von
bodyund nicht-View berechnete Variablen oberhalb voninit. - Eine Anleitung und Begründung für das MV-First-Prinzip findest du in
references/mv-patterns.md.
Handhabung großer Views
- Wenn eine SwiftUI-View-Datei etwa 300 Zeilen überschreitet, teile sie mithilfe von Extensions auf, um verwandte Helfer zu gruppieren. Verschiebe asynchrone Funktionen und Hilfsfunktionen in dedizierte
private-Extensions, getrennt durch// MARK: --Kommentare, die ihren Zweck beschreiben (z. B.// MARK: - Actions,// MARK: - Subviews,// MARK: - Helpers). Halte die Hauptstrukturstructfokussiert auf gespeicherte Eigenschaften, init undbody, wobei View-erstellende berechnete Variablen bei langen Dateien ebenfalls über Marks gruppiert werden.