Animation SwiftUI
Aperçu
Guide complet du système d'animation de SwiftUI, des concepts fondamentaux aux techniques avancées. Cette compétence couvre le protocole Animatable, la macro @Animatable d'iOS 26, les types d'animations et le système Transaction.
Principe fondamental L'animation dans SwiftUI est une interpolation mathématique dans le temps, alimentée par le protocole VectorArithmetic. Comprendre cette base débloque toute la puissance du système d'animation déclarative de SwiftUI.
Quand utiliser cette compétence
- Implémenter des vues ou formes animées personnalisées
- Comprendre pourquoi une propriété ne s'anime pas (Int vs Float/Double)
- Choisir entre animations spring et timing curve
- Utiliser la macro @Animatable (iOS 26+)
- Conformer des vues au protocole Animatable
- Déboguer le comportement de fusion des animations
- Optimiser les performances des animations
- Créer des animations complexes ou multi-étapes
- Comprendre les valeurs modèle vs présentation
- Implémenter des algorithmes d'animation personnalisés
Configuration système requise
iOS 13+ pour le protocole Animatable
iOS 17+ pour les animations spring par défaut, animations limitées
iOS 26+ pour la macro @Animatable
Partie 1 : Comprendre l'animation
Qu'est-ce que l'interpolation
L'animation est le processus de génération de valeurs intermédiaires entre un état de départ et un état d'arrivée.
Exemple : Animation d'opacité
.opacity(0) → .opacity(1)
Pendant l'exécution de cette animation, SwiftUI calcule des valeurs intermédiaires :
0.0 → 0.02 → 0.05 → 0.1 → 0.25 → 0.4 → 0.6 → 0.8 → 1.0
Comment les valeurs sont distribuées
- Déterminé par la courbe de timing ou la fonction de vélocité de l'animation
- Les animations spring utilisent une simulation physique
- Les courbes de timing utilisent des courbes de Bézier
- Chaque type d'animation calcule les valeurs différemment
Protocole VectorArithmetic
SwiftUI exige que les données animées soient conformes à VectorArithmetic, qui fournit :
protocol VectorArithmetic {
// Calculer la différence entre deux valeurs
static func - (lhs: Self, rhs: Self) -> Self
// Mettre à l'échelle les valeurs
static func * (lhs: Self, rhs: Double) -> Self
// Additionner les valeurs
static func + (lhs: Self, rhs: Self) -> Self
// Valeur zéro
static var zero: Self { get }
}
Types conformes intégrés
- 1 dimension :
CGFloat,Double,Float,Angle - 2 dimensions :
CGPoint,CGSize - 4 dimensions :
CGRect
Point clé L'arithmétique vectorielle abstrait la dimensionnalité des données animées. SwiftUI peut animer tous ces types avec une seule implémentation générique.
Pourquoi Int ne peut pas être animé
Int n'est pas conforme à VectorArithmetic car :
- Pas de valeurs intermédiaires fractionnaires — Il n'y a pas de « 3,5 » entre 3 et 4
- Pas continu — Les entiers sont des valeurs discrètes
- La mise à l'échelle n'a pas de sens — Que signifie 5 × 0,5 pour un entier ?
Ce qui se passe quand on essaie
struct CounterView: View {
@State private var count: Int = 0
var body: some View {
Text("\(count)")
.animation(.spring, value: count)
}
}
Résultat : SwiftUI remplace simplement l'ancien texte par le nouveau. Aucune interpolation n'a lieu.
Solution : Utiliser Float ou Double
struct AnimatedCounterView: View {
@State private var count: Float = 0
var body: some View {
Text("\(Int(count))")
.animation(.spring, value: count)
}
}
Résultat : SwiftUI interpole 0.0 → ... → 100.0, et vous affichez l'entier arrondi à chaque frame.
Valeurs modèle vs présentation
Les attributs animables ont conceptuellement deux valeurs :
Valeur modèle
- La valeur cible définie par votre code
- Mise à jour immédiatement lors du changement d'état
- Ce que vous écrivez dans le corps de votre vue
Valeur de présentation
- La valeur interpolée actuelle en cours de rendu
- Mise à jour image par image pendant l'animation
- Ce que l'utilisateur voit réellement
Exemple
.scaleEffect(selected ? 1.5 : 1.0)
Quand selected devient true :
- Valeur modèle : Devient immédiatement
1.5 - Valeur de présentation : Interpole
1.0 → 1.1 → 1.2 → 1.3 → 1.4 → 1.5dans le temps
Partie 2 : Protocole Animatable
Aperçu
Le protocole Animatable permet aux vues d'animer leurs propriétés en définissant quelles données doivent être interpolées.
protocol Animatable {
associatedtype AnimatableData: VectorArithmetic
var animatableData: AnimatableData { get set }
}
SwiftUI crée un attribut animable pour toute vue conforme à ce protocole.
Vues animables intégrées
De nombreux modificateurs SwiftUI sont conformes à Animatable :
Effets visuels
.scaleEffect()— Anime la transformation d'échelle.rotationEffect()— Anime la rotation.offset()— Anime le décalage de position.opacity()— Anime la transparence.blur()— Anime le rayon de flou.shadow()— Anime les propriétés d'ombre
Tous les types de forme
Circle,Rectangle,RoundedRectangleCapsule,Ellipse,Path- Implémentations personnalisées de
Shape
AnimatablePair pour les données multidimensionnelles
Pour animer plusieurs propriétés, utilisez AnimatablePair pour combiner des vecteurs.
Exemple : Implémentation de scaleEffect
struct ScaleEffectModifier: ViewModifier, Animatable {
var scale: CGSize
var anchor: UnitPoint
// Combiner deux vecteurs 2D en un vecteur 4D
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)
}
}
Comment ça marche
CGSizeest à 2 dimensions (largeur, hauteur)UnitPointest à 2 dimensions (x, y)AnimatablePairles fusionne en un vecteur à 4 dimensions- SwiftUI interpole les 4 valeurs ensemble
Conformité Animatable personnalisée
Quand l'utiliser
- Animer une mise en page personnalisée (comme RadialLayout)
- Animer du code de dessin personnalisé
- Animer des propriétés qui affectent les chemins de formes
Exemple : Vue de nombre animée
struct AnimatableNumberView: View, Animatable {
var number: Double
var animatableData: Double {
get { number }
set { number = newValue }
}
var body: some View {
Text("\(Int(number))")
.font(.largeTitle)
}
}
// Utilisation
AnimatableNumberView(number: value)
.animation(.spring, value: value)
Comment ça marche
numberpasse de 0 à 100- SwiftUI appelle
bodypour chaque image de l'animation - Chaque image reçoit une nouvelle valeur de
number: 0 → 5 → 15 → 30 → 55 → 80 → 100 - Le texte se met à jour pour afficher l'entier interpolé
Avertissement sur les performances
La conformité Animatable personnalisée peut être coûteuse.
Quand vous conformez une vue à Animatable :
- SwiftUI appelle le
bodyde votre vue pour chaque image de l'animation - La mise en page est recalculée à chaque image
- Cela se produit sur le thread principal
Les effets animables intégrés (comme .scaleEffect(), .opacity()) sont beaucoup plus efficaces :
- Ils s'exécutent hors du thread principal
- Ils n'appellent pas le body de votre vue
- Ils mettent à jour uniquement la couche de rendu
Recommandation
- Utilisez les effets intégrés autant que possible
- N'utilisez la conformité Animatable personnalisée que si vous ne pouvez pas obtenir l'effet avec les modificateurs intégrés
- Profilez avec Instruments si vous avez des problèmes de performances
Exemple : Animation de mise en page circulaire
// Ceci est coûteux mais nécessaire pour animer le long d'un chemin circulaire
@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)
}
}
}
Pourquoi nécessaire : Animer offsetAngle nécessite de recalculer les positions à chaque image. Aucun modificateur intégré ne peut le faire.
Partie 3 : Macro @Animatable (iOS 26+)
Aperçu
La macro @Animatable élimine le code boilerplate nécessaire pour se conformer manuellement au protocole Animatable.
Avant iOS 26, vous deviez :
- Vous conformer manuellement à
Animatable - Écrire le getter et le setter de
animatableData - Utiliser
AnimatablePairpour plusieurs propriétés - Exclure manuellement les propriétés non animables
iOS 26+, il suffit d'ajouter @Animatable :
@MainActor
@Animatable
struct MyView: View {
var scale: CGFloat
var opacity: Double
var body: some View {
// ...
}
}
La macro automatiquement :
- Génère la conformité à
Animatable - Inspecte toutes les propriétés stockées
- Crée
animatableDataà partir des propriétés conformes à VectorArithmetic - Gère les données multidimensionnelles avec
AnimatablePair
Comparaison avant/après
Avant la macro @Animatable
struct HikingRouteShape: Shape {
var startPoint: CGPoint
var endPoint: CGPoint
var elevation: Double
var drawingDirection: Bool // On ne veut pas animer ceci
// Déclaration manuelle fastidieuse de animatableData
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 {
// Code de dessin
}
}
Après la macro @Animatable
@Animatable
struct HikingRouteShape: Shape {
var startPoint: CGPoint
var endPoint: CGPoint
var elevation: Double
@AnimatableIgnored
var drawingDirection: Bool // Exclu de l'animation
func path(in rect: CGRect) -> Path {
// Code de dessin
}
}
Lignes de code : 20 → 12 (réduction de 40%)
@AnimatableIgnored
Utilisez @AnimatableIgnored pour exclure des propriétés de l'animation.
Quand l'utiliser
- Valeurs de débogage — Drapeaux pour le développement uniquement
- IDs — Identifiants qui ne doivent pas être animés
- Horodatages — Quand la vue a été créée/mise à jour
- État interne — Comptabilité non visuelle
- Types non VectorArithmetic — Couleurs, chaînes, booléens
Exemple
@MainActor
@Animatable
struct ProgressView: View {
var progress: Double // Animé
var totalItems: Int // Animé (si Float, pas si Int)
@AnimatableIgnored
var title: String // Pas animé
@AnimatableIgnored
var startTime: Date // Pas animé
@AnimatableIgnored
var debugEnabled: Bool // Pas animé
var body: some View {
VStack {
Text(title)
ProgressBar(value: progress)
if debugEnabled {
Text("Démarré : \(startTime.formatted())")
}
}
}
}
Cas d'utilisation concrets
Les animations numériques sont extrêmement courantes dans toutes les catégories d'applications :
Applications Fintech
@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)
}
}
}
Cas d'usage : Animer les variations de prix d'actions, la valeur du portefeuille, les transitions de solde de compte
Santé et forme physique
@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)
}
}
}
Cas d'usage : Indicateurs de fréquence cardiaque, compteurs de pas, calculs de calories, distance parcourue
Jeux
@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)
}
}
}
Cas d'usage : Animations de score, transitions XP, progression de niveau, multiplicateurs de combo
Applications de productivité
@MainActor
@Animatable
struct TimerView: View {
var remainingSeconds: Double
…
[La suite du contenu original est tronquée dans la demande de traduction.]