Was macht SwiftUI-Animation?
Übersicht
Umfassender Leitfaden zum Animationssystem von SwiftUI, von grundlegenden Konzepten bis zu fortgeschrittenen Techniken. Dieses Skill behandelt das Animatable-Protokoll, das iOS 26 @Animatable-Makro, Animationstypen und das Transaktionssystem.
Kernprinzip Animation in SwiftUI ist mathematische Interpolation über die Zeit, angetrieben durch das VectorArithmetic-Protokoll. Dieses Verständnis erschließt die volle Leistungsfähigkeit des deklarativen Animationssystems von SwiftUI.
Wann dieses Skill verwendet werden sollte
- Implementierung benutzerdefinierter animierter Views oder Shapes
- Verstehen, warum eine Eigenschaft nicht animiert wird (Int vs. Float/Double)
- Wahl zwischen Feder- und Timingkurven-Animationen
- Verwendung des @Animatable-Makros (iOS 26+)
- Konformität von Views mit dem Animatable-Protokoll
- Debugging des Merging-Verhaltens von Animationen
- Optimierung der Animationsleistung
- Erstellung von mehrstufigen oder komplexen Animationen
- Verständnis von Modell- vs. Präsentationswerten
- Implementierung benutzerdefinierter Animationsalgorithmen
Systemanforderungen
iOS 13+ für Animatable-Protokoll
iOS 17+ für Standard-Feder-Animationen, begrenzte Animationen
iOS 26+ für @Animatable-Makro
Teil 1: Animation verstehen
Was ist Interpolation
Animation ist der Prozess der Generierung 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
- Feder-Animationen nutzen die Physiksimulation
- Timingkurven nutzen Bézierkurven
- Jeder Animationstyp berechnet Werte anders
VectorArithmetic-Protokoll
SwiftUI erfordert, dass animierte Daten dem Protokoll VectorArithmetic entsprechen, das Folgendes bereitstellt:
protocol VectorArithmetic {
// Differenz zwischen zwei Werten berechnen
static func - (lhs: Self, rhs: Self) -> Self
// Werte skalieren
static func * (lhs: Self, rhs: Double) -> Self
// Werte addieren
static func + (lhs: Self, rhs: Self) -> Self
// Nullwert
static var zero: Self { get }
}
Integrierte konforme Typen
- 1-dimensional:
CGFloat,Double,Float,Angle - 2-dimensional:
CGPoint,CGSize - 4-dimensional:
CGRect
Wichtige Erkenntnis Die Vektorarithmetik abstrahiert die Dimensionalität animierter Daten. SwiftUI kann alle diese Typen mit einer einzigen generischen Implementierung animieren.
Warum Int nicht animiert werden kann
Int entspricht nicht VectorArithmetic, weil:
- Keine gebrochenen Zwischenwerte — Es gibt keine „3,5“ zwischen 3 und 4
- Nicht stetig — Ganzzahlen sind diskrete Werte
- Skalierung ist sinnlos — Was bedeutet 5 × 0,5 für eine ganze Zahl?
Was passiert, wenn man es versucht
struct CounterView: View {
@State private var count: Int = 0
var body: some View {
Text("\(count)")
.animation(.spring, value: count)
}
}
Ergebnis: SwiftUI ersetzt einfach den alten Text durch den neuen. Es findet keine Interpolation statt.
Lösung: Verwende Float oder Double
struct AnimatedCounterView: View {
@State private var count: Float = 0
var body: some View {
Text("\(Int(count))")
.animation(.spring, value: count)
}
}
Ergebnis: SwiftUI interpoliert 0.0 → ... → 100.0, und du zeigst die gerundete Ganzzahl bei jedem Frame an.
Modell- vs. Präsentationswerte
Animierbare Attribute haben konzeptionell zwei Werte:
Modellwert
- Der Zielwert, der von Ihrem Code gesetzt wird
- Wird sofort aktualisiert, wenn sich der Zustand ändert
- Was Sie in den Body Ihrer View schreiben
Präsentationswert
- Der aktuell interpolierte Wert, der gerendert wird
- Aktualisiert sich Frame für Frame während der Animation
- Was der Benutzer tatsächlich sieht
Beispiel
.scaleEffect(selected ? 1.5 : 1.0)
Wenn selected true wird:
- Modellwert: Wird sofort zu
1.5 - Präsentationswert: Interpoliert
1.0 → 1.1 → 1.2 → 1.3 → 1.4 → 1.5über die Zeit
Teil 2: Animatable-Protokoll
Übersicht
Das Animatable-Protokoll erlaubt 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 Animatable:
Visuelle Effekte
.scaleEffect()— Animiert die Skalierungstransformation.rotationEffect()— Animiert die Rotation.offset()— Animiert den Positionsversatz.opacity()— Animiert die Transparenz.blur()— Animiert den Weichzeichnungsradius.shadow()— Animiert Schatteneigenschaften
Alle Shape-Typen
Circle,Rectangle,RoundedRectangleCapsule,Ellipse,Path- Benutzerdefinierte
Shape-Implementierungen
AnimatablePair für mehrdimensionale Daten
Verwende AnimatablePair, um mehrere Eigenschaften zu animieren und Vektoren zu kombinieren.
Beispiel: scaleEffect-Implementierung
struct ScaleEffectModifier: ViewModifier, Animatable {
var scale: CGSize
var anchor: UnitPoint
// Kombiniere zwei 2D-Vektoren zu einem 4D-Vektor
var animatableData: AnimatablePair<CGSize.AnimatableData, UnitPoint.AnimatableData> {
get {
AnimatablePair(scale.animatableData, anchor.animatableData)
}
set {
scale.animatableData = newValue.first
anchor.animatableData = newValue.second
}
}
func body(content: Content) -> some View {
content.scaleEffect(scale, anchor: anchor)
}
}
Wie es funktioniert
CGSizeist 2-dimensional (Breite, Höhe)UnitPointist 2-dimensional (x, y)AnimatablePairvereint sie zu einem 4-dimensionalen Vektor- SwiftUI interpoliert alle 4 Werte zusammen
Benutzerdefinierte Animatable-Konformität
Wann verwenden
- Animation benutzerdefinierter Layouts (wie RadialLayout)
- Animation benutzerdefinierten Zeichencodes
- Animation 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 jeden Frame der Animation auf - Jeder Frame erhält einen neuen
number-Wert: 0 → 5 → 15 → 30 → 55 → 80 → 100 - Text wird aktualisiert, um den interpolierten Integer anzuzeigen
Leistungswarnung
Benutzerdefinierte Animatable-Konformität kann teuer sein.
Wenn Sie eine View konform zu Animatable machen:
- SwiftUI ruft den
bodyIhrer View für jeden Frame der Animation auf - Layout wird bei jedem Frame neu berechnet
- Dies geschieht auf dem Hauptthread
Integrierte animierbare Effekte (wie .scaleEffect(), .opacity()) sind viel effizienter:
- Sie laufen außerhalb des Hauptthreads
- Sie rufen den body Ihrer View nicht auf
- Sie aktualisieren nur die Rendering-Ebene
Richtlinie
- Verwende nach Möglichkeit integrierte Effekte
- Verwende benutzerdefinierte Animatable-Konformität nur, wenn du den Effekt nicht mit integrierten Modifiern erzielen kannst
- Bei Leistungsproblemen mit Instruments profilieren
Beispiel: Kreis-Layout-Animation
// Dies ist teuer, aber notwendig, um entlang eines kreisförmigen Pfades zu animieren
@Animatable
struct RadialLayout: Layout {
var offsetAngle: Angle
var animatableData: Angle.AnimatableData {
get { offsetAngle.animatableData }
set { offsetAngle.animatableData = newValue }
}
func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
proposal.replacingUnspecifiedDimensions()
}
func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
let radius = min(bounds.width, bounds.height) / 2
let center = CGPoint(x: bounds.midX, y: bounds.midY)
let angleStep = Angle.degrees(360.0 / Double(subviews.count))
for (index, subview) in subviews.enumerated() {
let angle = offsetAngle + angleStep * Double(index)
let x = center.x + radius * cos(angle.radians)
let y = center.y + radius * sin(angle.radians)
subview.place(at: CGPoint(x: x, y: y), anchor: .center, proposal: .unspecified)
}
}
}
Warum notwendig: Das Animieren von offsetAngle erfordert eine Neuberechnung der Positionen bei jedem Frame. Kein integrierter Modifier kann dies leisten.
Teil 3: @Animatable-Makro (iOS 26+)
Übersicht
Das @Animatable-Makro eliminiert den Boilerplate-Code für die manuelle Konformität mit dem Animatable-Protokoll.
Vor iOS 26 musstest du:
- Manuell
Animatablekonform machen animatableData-Getter und -Setter schreibenAnimatablePairfür mehrere Eigenschaften verwenden- Nicht animierbare Eigenschaften manuell ausschließen
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:
- Generiert die
Animatable-Konformität - Untersucht alle gespeicherten Eigenschaften
- Erstellt
animatableDataaus VectorArithmetic-konformen Eigenschaften - Behandelt mehrdimensionale Daten mit
AnimatablePair
Vorher/Nachher-Vergleich
Vor @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 @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 % Reduzierung)
@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())")
}
}
}
}
Anwendungsfälle aus der Praxis
Numerische Animationen sind in allen App-Kategorien sehr verbreitet:
Fintech-Apps
@MainActor
@Animatable
struct StockPriceView: View {
var price: Double
var changePercent: Double
var body: some View {
VStack(alignment: .trailing) {
Text("$\(price, format: .number.precision(.fractionLength(2)))")
.font(.title)
Text("\(changePercent > 0 ? "+" : "")\(changePercent, format: .percent)")
.foregroundColor(changePercent > 0 ? .green : .red)
}
}
}
Anwendungsfall: Aktienkursänderungen, Portfoliowert, Kontostand-Übergänge animieren
Gesundheit & Fitness
@MainActor
@Animatable
struct HeartRateView: View {
var bpm: Double
@AnimatableIgnored
var timestamp: Date
var body: some View {
VStack {
Text("\(Int(bpm))")
.font(.system(size: 60, weight: .bold))
Text("BPM")
.font(.caption)
.foregroundColor(.secondary)
}
}
}
Anwendungsfall: Herzfrequenzanzeigen, Schrittzähler, Kalorienberechnungen, zurückgelegte Strecke
Spiele
@MainActor
@Animatable
struct ScoreView: View {
var score: Float
var multiplier: Float
var body: some View {
HStack {
Text("\(Int(score))")
.font(.largeTitle)
Text("×\(multiplier, format: .number.precision(.fractionLength(1)))")
.font(.title2)
.foregroundColor(.orange)
}
}
}
Anwendungsfall: Punktzahlenanimationen, XP-Übergänge, Level-Fortschritt, Combo-Multiplikatoren
Produktivitäts-Apps
@MainActor
@Animatable
struct TimerView: View {
var remainingSeconds: Double