SwiftUI-Animation
Überblick
Umfassender Leitfaden zum Animationssystem von SwiftUI, von grundlegenden Konzepten bis zu fortgeschrittenen Techniken. Dieser Skill behandelt das Animatable-Protokoll, das @Animatable-Makro (iOS 26), Animationstypen und das Transaktionssystem.
Kernprinzip Animation in SwiftUI ist mathematische Interpolation über die Zeit, angetrieben durch das VectorArithmetic-Protokoll. Dieses Verständnis bildet die Grundlage für die volle Leistungsfähigkeit des deklarativen Animationssystems von SwiftUI.
Systemanforderungen
- iOS 13+: Animatable-Protokoll, Timing-/Spring-Animationen
- iOS 17+: Standard-Spring-Animationen, bereichsbezogene Animationen, PhaseAnimator, KeyframeAnimator
- iOS 18+: Zoom-Übergänge, UIKit/AppKit-Animationsbrücken
- iOS 26+: @Animatable-Makro
Teil 1: Animation verstehen
Was ist Interpolation
Animation ist der Prozess der Erzeugung von Zwischenwerten zwischen einem Start- und einem Endzustand.
Beispiel: Opazitätsanimation
.opacity(0) → .opacity(1)
Während diese Animation läuft, berechnet SwiftUI Zwischenwerte:
0.0 → 0.02 → 0.05 → 0.1 → 0.25 → 0.4 → 0.6 → 0.8 → 1.0
Wie Werte verteilt werden
- Bestimmt durch die Timingkurve oder Geschwindigkeitsfunktion der Animation
- Spring-Animationen verwenden eine physikalische Simulation
- Timingkurven verwenden Bézier-Kurven
- Jeder Animationstyp berechnet Werte unterschiedlich
VectorArithmetic-Protokoll
SwiftUI erfordert, dass animierte Daten dem VectorArithmetic-Protokoll entsprechen – das Subtraktion, Skalierung, Addition und einen Nullwert bereitstellt. Dies ermöglicht SwiftUI, zwischen zwei beliebigen Werten zu interpolieren.
Eingebaute konforme Typen: CGFloat, Double, Float, Angle (1D), CGPoint, CGSize (2D), CGRect (4D).
Wichtige Erkenntnis Vektorarithmetik abstrahiert über die Dimensionalität. SwiftUI animiert alle diese Typen mit einer einzigen generischen Implementierung.
Warum Int nicht animiert werden kann
Int entspricht nicht dem VectorArithmetic-Protokoll – es gibt keine fraktionalen Zwischenwerte zwischen 3 und 4. SwiftUI setzt den Wert einfach direkt.
Lösung: Verwende Float/Double und zeige sie als Int an:
@State private var count: Float = 0
// ...
Text("\(Int(count))").animation(.spring, value: count)
Modellwert vs. Darstellungswert
Animierbare Attribute haben konzeptionell zwei Werte:
Modellwert
- Der Zielwert, der von Ihrem Code gesetzt wird
- Wird sofort aktualisiert, wenn sich der Zustand ändert
- Das, was Sie im body Ihrer View schreiben
Darstellungswert
- Der aktuell interpolierte Wert, der gerendert wird
- Wird während der Animation Bild für Bild aktualisiert
- Das, was der Benutzer tatsächlich sieht
Beispiel
.scaleEffect(selected ? 1.5 : 1.0)
Wenn selected true wird:
- Modellwert: Wird sofort zu
1.5 - Darstellungswert: Interpoliert
1.0 → 1.1 → 1.2 → 1.3 → 1.4 → 1.5über die Zeit
Teil 2: Animatable-Protokoll
Überblick
Das Animatable-Protokoll ermöglicht es Views, ihre Eigenschaften zu animieren, indem es definiert, welche Daten interpoliert werden sollen.
protocol Animatable {
associatedtype AnimatableData: VectorArithmetic
var animatableData: AnimatableData { get set }
}
SwiftUI erstellt ein animierbares Attribut für jede View, die diesem Protokoll entspricht.
Integrierte animierbare Views
Viele SwiftUI-Modifier entsprechen dem Animatable-Protokoll:
Visuelle Effekte
.scaleEffect()— Animiert die Skalierungstransformation.rotationEffect()— Animiert die Rotation.offset()— Animiert den Positionsversatz.opacity()— Animiert die Transparenz.blur()— Animiert den Unschärferadius.shadow()— Animiert Schatteneigenschaften
Alle Shape-Typen
Circle,Rectangle,RoundedRectangleCapsule,Ellipse,Path- Benutzerdefinierte
Shape-Implementierungen
AnimatablePair für mehrdimensionale Daten
Verwende AnimatablePair, um Vektoren zu kombinieren, wenn mehrere Eigenschaften animiert werden. Beispielsweise kombiniert scaleEffect CGSize (2D) und UnitPoint (2D) zu einem 4D-Vektor über AnimatablePair<CGSize.AnimatableData, UnitPoint.AnimatableData>. Greife auf Komponenten über .first und .second zu. Das @Animatable-Makro (iOS 26+) eliminiert diesen Boilerplate-Code vollständig.
Benutzerdefinierte Animatable-Konformität
Wann verwenden
- Animieren eines benutzerdefinierten Layouts (z. B. RadialLayout)
- Animieren von benutzerdefiniertem Zeichencode
- Animieren von Eigenschaften, die Shape-Pfade beeinflussen
Beispiel: Animierte Zahlenansicht
struct AnimatableNumberView: View, Animatable {
var number: Double
var animatableData: Double {
get { number }
set { number = newValue }
}
var body: some View {
Text("\(Int(number))").font(.largeTitle)
}
}
// Verwendung
AnimatableNumberView(number: value).animation(.spring, value: value)
Wie es funktioniert
numberändert sich von 0 auf 100- SwiftUI ruft
bodyfür jedes Bild der Animation auf - Jedes Bild erhält einen neuen
number-Wert: 0 → 5 → 15 → 30 → 55 → 80 → 100 - Der Text wird aktualisiert, um die interpolierte Ganzzahl anzuzeigen
Leistungswarnung
Benutzerdefinierte Animatable-Konformität ist teuer — SwiftUI ruft body für jedes Bild im Hauptthread auf. Eingebaute Effekte (.scaleEffect(), .opacity()) laufen nebenläufig zum Hauptthread und rufen body nicht auf. Verwende benutzerdefinierte Konformität nur, wenn eingebaute Modifier den Effekt nicht erzielen können (z. B. beim Animieren eines benutzerdefinierten Layout, das Unterviews pro Bild neu positioniert).
Teil 3: @Animatable-Makro (iOS 26+)
Überblick
Das @Animatable-Makro eliminiert den Boilerplate-Code der manuellen Konformität zum Animatable-Protokoll.
Vor iOS 26 musstest du:
- Manuell
Animatablekonform sein animatableData-Getter und -Setter schreibenAnimatablePairfür mehrere Eigenschaften verwenden- Nicht-animierbare Eigenschaften manuell ausschließen
Ab iOS 26+ fügst du einfach @Animatable hinzu:
@MainActor
@Animatable
struct MyView: View {
var scale: CGFloat
var opacity: Double
var body: some View {
// ...
}
}
Das Makro automatisiert:
- Erzeugt
Animatable-Konformität - Untersucht alle gespeicherten Eigenschaften
- Erstellt
animatableDataaus VectorArithmetic-konformen Eigenschaften - Behandelt mehrdimensionale Daten mit
AnimatablePair
Vorher/Nachher-Vergleich
Vor dem @Animatable-Makro
struct HikingRouteShape: Shape {
var startPoint: CGPoint
var endPoint: CGPoint
var elevation: Double
var drawingDirection: Bool // Soll nicht animiert werden
// Mühsame manuelle animatableData-Deklaration
var animatableData: AnimatablePair<AnimatablePair<CGFloat, CGFloat>,
AnimatablePair<Double, AnimatablePair<CGFloat, CGFloat>>> {
get {
AnimatablePair(
AnimatablePair(startPoint.x, startPoint.y),
AnimatablePair(elevation, AnimatablePair(endPoint.x, endPoint.y))
)
}
set {
startPoint = CGPoint(x: newValue.first.first, y: newValue.first.second)
elevation = newValue.second.first
endPoint = CGPoint(x: newValue.second.second.first, y: newValue.second.second.second)
}
}
func path(in rect: CGRect) -> Path {
// Zeichencode
}
}
Nach dem @Animatable-Makro
@Animatable
struct HikingRouteShape: Shape {
var startPoint: CGPoint
var endPoint: CGPoint
var elevation: Double
@AnimatableIgnored
var drawingDirection: Bool // Von der Animation ausgeschlossen
func path(in rect: CGRect) -> Path {
// Zeichencode
}
}
Codezeilen: 20 → 12 (40% Reduktion)
@AnimatableIgnored
Verwende @AnimatableIgnored, um Eigenschaften von der Animation auszuschließen.
Wann verwenden
- Debug-Werte — Flags nur für die Entwicklung
- IDs — Bezeichner, die nicht animiert werden sollen
- Zeitstempel — Wann die View erstellt/aktualisiert wurde
- Interner Zustand — Nicht-visuelle Buchhaltung
- Nicht-VectorArithmetic-Typen — Farben, Zeichenketten, Boolesche Werte
Beispiel
@MainActor
@Animatable
struct ProgressView: View {
var progress: Double // Animiert
var totalItems: Int // Animiert (wenn Float, nicht wenn Int)
@AnimatableIgnored
var title: String // Nicht animiert
@AnimatableIgnored
var startTime: Date // Nicht animiert
@AnimatableIgnored
var debugEnabled: Bool // Nicht animiert
var body: some View {
VStack {
Text(title)
ProgressBar(value: progress)
if debugEnabled {
Text("Gestartet: \(startTime.formatted())")
}
}
}
}
Praxisnaher Anwendungsfall
@Animatable funktioniert für jede numerische Anzeige – Aktienkurse, Herzfrequenz, Punktzahlen, Timer, Fortschrittsbalken:
@MainActor
@Animatable
struct AnimatedValueView: View {
var value: Double
var changePercent: Double
@AnimatableIgnored
var label: String
var body: some View {
VStack(alignment: .trailing) {
Text("\(value, format: .number.precision(.fractionLength(2)))")
.font(.title)
Text("\(changePercent > 0 ? "+" : "")\(changePercent, format: .percent)")
.foregroundStyle(changePercent > 0 ? .green : .red)
}
}
}
// Verwendung
AnimatedValueView(value: currentPrice, changePercent: 0.025, label: "Preis")
.animation(.spring(duration: 0.8), value: currentPrice)
Teil 4: Animationstypen
Timingkurven-Animationen
Timingkurven-Animationen verwenden Bézier-Kurven, um die Geschwindigkeit der Animation über die Zeit zu steuern.
Integrierte Voreinstellungen
.animation(.linear) // Konstante Geschwindigkeit
.animation(.easeIn) // Startet langsam, endet schnell
.animation(.easeOut) // Startet schnell, endet langsam
.animation(.easeInOut) // Langsamer Start und Ende, schnelle Mitte
Benutzerdefinierte Timingkurven
let customCurve = UnitCurve(
startControlPoint: CGPoint(x: 0.2, y: 0),
endControlPoint: CGPoint(x: 0.8, y: 1)
)
.animation(.timingCurve(customCurve, duration: 0.5))
Dauer
Alle Timingkurven-Animationen akzeptieren eine optionale Dauer:
.animation(.easeInOut(duration: 0.3))
.animation(.linear(duration: 1.0))
Standard: 0,35 Sekunden
Spring-Animationen
Spring-Animationen verwenden eine physikalische Simulation, um natürliche, organische Bewegungen zu erzeugen.
Integrierte Voreinstellungen
.animation(.smooth) // Kein Hüpfen (Standard seit iOS 17)
.animation(.snappy) // Kleine Menge an Hüpfen
.animation(.bouncy) // Größere Menge an Hüpfen
Benutzerdefinierte Springs
.animation(.spring(duration: 0.6, bounce: 0.3))
Parameter
duration— Wahrgenommene Animationsdauerbounce— Menge an Hüpfen (0 = kein Hüpfen, 1 = sehr hüpfend)
Viel intuitiver als traditionelle Spring-Parameter (Masse, Steifigkeit, Dämpfung).
Höherwertige Animationen
Modifiziere Basisanimationen, um komplexe Effekte zu erzeugen.
Verzögerung
.animation(.spring.delay(0.5))
Wartet 0,5 Sekunden, bevor die Animation startet.
Wiederholung
.animation(.easeInOut.repeatCount(3, autoreverses: true))
.animation(.linear.repeatForever(autoreverses: false))
Wiederholt die Animation mehrmals oder unendlich oft.
Geschwindigkeit
.animation(.spring.speed(2.0)) // 2x schneller
.animation(.spring.speed(0.5)) // 2x langsamer
Multipliziert die Animationsgeschwindigkeit.
Änderungen der Standardanimation (iOS 17+)
Vor iOS 17
withAnimation {
// Verwendete standardmäßig Timingkurve
}
iOS 17+
withAnimation {
// Verwendet standardmäßig .smooth spring
}
Warum die Änderung: Spring-Animationen fühlen sich natürlicher an und bewahren die Geschwindigkeit, wenn sie unterbrochen werden.
Empfehlung: Setze auf Springs. Sie lassen deine UI reaktionsschneller und ausgefeilter wirken.
Teil 5: Transaktionssystem
withAnimation
Der gebräuchlichste Weg, eine Animation auszulösen.
Button("Vergrößern") {
withAnimation(.spring) {
scale = 1.5
}
}
Wie es funktioniert
withAnimationöffnet eine Transaktion- Setzt die Animation im Transaktionswörterbuch
- Führt den Closure aus (Statusänderungen)
- Die Transaktion propagiert die View-Hierarchie hinunter
- Animierbare Attribute prüfen auf Animation und interpolieren
Explizite Animation
withAnimation(.spring(duration: 0.6, bounce: 0.4)) {
isExpanded.toggle()
}
Keine Animation
withAnimation(nil) {
// Änderungen erfolgen sofort, keine Animation
resetState()
}
animation()-View-Modifier
Wende Animationen auf bestimmte Werte innerhalb einer View an.
Grundlegende Verwendung
Circle()
.fill(isActive ? .blue : .gray)
.animation(.spring, value: isActive)
Wie es funktioniert: Die Animation wird nur ausgelöst, wenn sich isActive ändert. Andere Statusänderungen lösen diese Animation nicht aus.
Mehrere Animationen auf derselben View
Circle()
.scaleEffect(scale)
.animation(.bouncy, value: scale)
.opacity(opacity)
.animation(.easeInOut, value: opacity)
Unterschiedliche Animationen für unterschiedliche Eigenschaften.
Bereichsbezogene Animationen (iOS 17+)
Beschränke Animationen eng auf bestimmte animierbare Attribute.
Problem mit dem alten Ansatz
struct AvatarView: View {
var selected: Bool
var body: some View {
Image("avatar")
.scaleEffect(selected ? 1.5 : 1.0)
.animation(.spring, value: selected)
// ⚠️ Wenn sich das Bild auch ändert, wenn selected
// geändert wird, wird der Bildübergang ebenfalls
// animiert (versehentlich)
}
}
Lösung: Bereichsbezogene Animation
struct AvatarView: View {
var selected: Bool
var body: some View {
Image("avatar")
.animation(.spring, value: selected) {
$0.scaleEffect(selected ? 1.5 : 1.0)
}
// ✅ Nur scaleEffect wird animiert, Bildübergang nicht
}
}
Wie es funktioniert
- Die Animation gilt nur für Attribute im Closure
- Andere Attribute sind nicht betroffen
- Verhindert versehentliche Animationen
Benutzerdefinierte Transaktionsschlüssel
Definiere benutzerdefinierte TransactionKey-Typen, um Kontext durch das Transaktionssystem zu propagieren. Verwende withTransaction, um Werte zu setzen, und den .transaction-Modifier, um sie zu lesen. Dies ermöglicht es, unterschiedliche Animationen basierend darauf anzuwenden, wie eine Statusänderung ausgelöst wurde (Tippen vs. programmatisch).
Teil 6: Fortgeschrittene Themen
CustomAnimation-Protokoll
Implementiere benutzerdefinierte Animationsalgorithmen, indem du dem CustomAnimation-Protokoll entspricht. Verwende es, um einzigartige zeitliche Abläufe zu erstellen, die über integrierte Timingkurven und Springs hinausgehen. Dies ist nützlich für Spezialeffekte wie Gummiband-Effekte, benutzerdefinierte Federn oder jede andere mathematische Funktion, die über die Zeit interpoliert. Sieh dir die SwiftUI-Dokumentation für Details zur Konformität an.