Optimisation des Performances SwiftUI
Quand Utiliser Cette Compétence
Utilisez quand :
- L'application semble moins réactive (à-coups, blocages, défilement retardé)
- Les animations font une pause ou sautent pendant l'exécution
- Les performances de défilement sont médiocres
- Le profilage révèle que SwiftUI est le goulot d'étranglement
- Les bodies des vues prennent trop de temps à s'exécuter
- Les vues se mettent à jour plus souvent que nécessaire
- Vous devez comprendre la cause et l'effet des mises à jour SwiftUI
Exemples de Prompts
Voici des questions réelles que les développeurs posent et auxquelles cette compétence est conçue pour répondre :
1. "Mon application a un défilement saccadé et les animations bégayent. Comment puis-je savoir si SwiftUI en est la cause ?"
→ La compétence montre comment utiliser le nouvel instrument SwiftUI dans Instruments 26 pour identifier si SwiftUI est le goulot d'étranglement par rapport aux autres couches
2. "J'utilise le nouvel instrument SwiftUI et je vois des barres orange/rouges indiquant des mises à jour longues. Comment savoir ce qui les cause ?"
→ La compétence couvre les patterns du Graphique Cause & Effet qui montrent le flux de données à travers votre application et quels changements d'état déclenchent des mises à jour coûteuses
3. "Certaines vues se mettent à jour beaucoup trop souvent même si leurs données n'ont pas changé. Comment trouver quelles vues sont le problème ?"
→ La compétence démontre la détection des mises à jour inutiles et le dépannage d'identité avec la chronologie visuelle
4. "J'ai de grandes structures de données et des hiérarchies de vues complexes. Comment les optimiser pour les performances SwiftUI ?"
→ La compétence couvre les patterns de performance : décomposer les hiérarchies de vues, minimiser la complexité du body et utiliser la liste de vérification d'optimisation @Sendable
5. "Nous avons une date limite de performance et j'ai besoin de comprendre ce qui est lent dans SwiftUI. Quelles sont les métriques critiques ?"
→ La compétence fournit l'arbre de décision pour prioriser les optimisations et comprend les scénarios de pression avec des conseils professionnels pour les compromis
Aperçu
Principe de Base : Assurez-vous que les bodies de vos vues se mettent à jour rapidement et seulement lorsque c'est nécessaire pour obtenir d'excellentes performances SwiftUI.
NOUVEAU dans WWDC 2025 : L'instrument SwiftUI de nouvelle génération dans Instruments 26 fournit une analyse complète des performances avec :
- Chronologie visuelle des mises à jour longues (codées en couleur orange/rouge selon la gravité)
- Graphique Cause & Effet montrant le flux de données dans votre application
- Intégration avec le Profileur Temporel pour l'analyse CPU
- Suivi des Blocages et des À-coups
Problèmes de Performance Clés :
- Mises à jour Longues du Body de la Vue — Les bodies des vues prennent trop de temps à s'exécuter
- Mises à jour Inutiles de la Vue — Les vues se mettent à jour alors que les données n'ont pas réellement changé
Améliorations des Performances du Framework iOS 26
"Les améliorations de performances du framework profitent aux applications sur toutes les plateformes Apple, de notre application à la vôtre." — WWDC 2025-256
SwiftUI dans iOS 26 inclut des gains de performance majeurs qui profitent automatiquement à toutes les applications. Ces améliorations fonctionnent parallèlement aux nouveaux outils de profilage pour rendre SwiftUI plus rapide dès le départ.
Performances de List (Focus macOS)
Gains massifs pour les grandes listes
- Chargement 6x plus rapide pour les listes de 100 000+ éléments sur macOS
- Mises à jour 16x plus rapides pour les grandes listes
- Gains encore plus importants pour les listes plus grandes
- Les améliorations profitent à toutes les plateformes (iOS, iPadOS, watchOS, pas seulement macOS)
List(trips) { trip in // 100k+ éléments
TripRow(trip: trip)
}
// iOS 26 : Chargement 6x plus rapide, mises à jour 16x plus rapides sur macOS
// Toutes les plateformes bénéficient des améliorations de performances
Impact sur votre application
- Les grands ensembles de données (10k+ éléments) voient des améliorations notables
- Les opérations de filtrage et de tri s'effectuent plus rapidement
- Les mises à jour en temps réel des listes sont plus réactives
- Profite aux applications comme les navigateurs de fichiers, les listes de contacts, les tableaux de données
Performances de Défilement
Réduction des images perdues lors du défilement à grande vitesse
SwiftUI a amélioré la planification des mises à jour de l'interface utilisateur sur iOS et macOS. Cela améliore la réactivité et permet à SwiftUI de faire encore plus de travail pour préparer les images à venir. Dans l'ensemble, cela réduit le risque que votre application perde une image lors d'un défilement rapide à des fréquences d'images élevées.
Améliorations clés
- Meilleure planification des images — SwiftUI a plus de temps pour préparer les images à venir
- Réactivité améliorée — Les mises à jour de l'interface utilisateur sont planifiées plus efficacement
- Moins d'images perdues — Surtout lors d'un défilement rapide à 120 Hz (ProMotion)
Quand vous le remarquerez
- Défilement dans du contenu riche en images
- Appareils à haute fréquence d'images (iPhone Pro, iPad Pro avec ProMotion)
- Lignes de liste complexes avec plusieurs vues
ScrollViews Imbriquées avec Piles Paresseuses
Les carrousels de photos et le défilement multi-axes sont maintenant correctement optimisés
ScrollView(.horizontal) {
LazyHStack {
ForEach(photoSets) { photoSet in
ScrollView(.vertical) {
LazyVStack {
ForEach(photoSet.photos) { photo in
PhotoView(photo: photo)
}
}
}
}
}
}
// iOS 26 : Les scrollviews imbriquées retardent maintenant correctement le chargement avec les piles paresseuses
// Idéal pour les carrousels de photos, les mises en page de type Netflix, le contenu multi-axes
Avant iOS 26 Les ScrollViews imbriquées ne retardaient pas correctement le chargement du contenu des piles paresseuses, ce qui faisait que tout le contenu imbriqué se chargeait immédiatement.
Après iOS 26 Les piles paresseuses dans les ScrollViews imbriquées retardent maintenant le chargement jusqu'à ce que le contenu soit sur le point d'apparaître, correspondant au comportement des ScrollViews à un seul niveau.
Cas d'utilisation
- Galeries de photos avec défilement horizontal/vertical
- Lignes de catégories de type Netflix
- Navigateurs de données multidimensionnels
- Carrousels d'images avec défilement vertical détaillé
Améliorations de l'Instrument de Performance SwiftUI
Nouvelles pistes dans Instruments 26
L'instrument SwiftUI inclut maintenant des pistes dédiées pour :
- Mises à jour Longues du Body de la Vue — Identifiez les calculs de body coûteux
- Mises à jour Longues de la Vue Plateforme — Suivez les performances de pontage UIKit/AppKit (Mises à jour Longues Représentables)
- Autres Mises à jour Longues — Tous les autres types de travail long SwiftUI
Ces pistes sont couvertes en détail dans la section suivante.
Résumé des Améliorations de Performance
Gains automatiques (recompilation uniquement)
- ✅ Chargement 6x plus rapide des listes (100k+ éléments, macOS)
- ✅ Mises à jour 16x plus rapides des listes (macOS)
- ✅ Réduction des images perdues lors du défilement
- ✅ Meilleure planification des images sur iOS/macOS
- ✅ Optimisation du chargement paresseux des ScrollViews imbriquées
Aucune modification de code nécessaire — reconstruisez avec le SDK iOS 26 pour obtenir ces améliorations.
Référence croisée Compétence SwiftUI 26 Features (swiftui-26-ref) — Guide complet de tous les changements SwiftUI iOS 26
L'Instrument SwiftUI (Instruments 26)
Pour Commencer
Prérequis :
- Installez Xcode 26
- Mettez à jour les appareils vers les dernières versions du système d'exploitation (support pour l'enregistrement des traces SwiftUI)
- Compilez l'application en mode Release pour un profilage précis
Lancement :
- Ouvrez le projet dans Xcode
- Appuyez sur Commande-I pour profiler
- Choisissez le modèle SwiftUI dans le sélecteur de modèles
- Cliquez sur le bouton Enregistrer
Contenu du Modèle
Le modèle SwiftUI inclut trois instruments :
- Instrument SwiftUI (NOUVEAU) — Identifie les problèmes de performance dans le code SwiftUI
- Profileur Temporel — Affiche les échantillons de travail CPU au fil du temps
- Blocages et À-coups — Suit la réactivité de l'application
Pistes de l'Instrument SwiftUI
Piste 1 : Groupes de Mise à Jour
- Montre quand SwiftUI travaille activement
- Vide pendant les pics CPU ? → Le problème vient probablement de l'extérieur de SwiftUI
Piste 2 : Mises à jour Longues du Body de la Vue
- Met en évidence quand la propriété
bodyprend trop de temps - Problème de performance le plus courant — commencez ici
Piste 3 : Mises à jour Longues Représentables
- Identifie les mises à jour lentes de UIViewRepresentable/NSViewRepresentable
- Performances d'intégration UIKit/AppKit
Piste 4 : Autres Mises à jour Longues
- Tous les autres types de travail long SwiftUI
Système de Codage Couleur
Les mises à jour sont affichées en orange et rouge en fonction de la probabilité de provoquer des à-coups :
- Rouge — Très susceptible de contribuer à un à-coup/blocage (enquêtez en premier)
- Orange — Modérément susceptible de causer des problèmes
- Gris — Mises à jour normales, pas inquiétantes
Remarque : Le fait que les mises à jour entraînent ou non des à-coups dépend des conditions de l'appareil, mais les mises à jour rouges sont la priorité la plus élevée.
Comprendre la Boucle de Rendu
Rendu d'Image Normal
Image 1 :
├─ Gérer les événements (touchers, pressions de touches)
├─ Mettre à jour l'interface utilisateur (exécuter les bodies des vues)
│ └─ Terminé avant l'échéance de l'image ✅
├─ Transférer au système
└─ Le système rend → Visible à l'écran
Image 2 :
├─ Gérer les événements
├─ Mettre à jour l'interface utilisateur
│ └─ Terminé avant l'échéance de l'image ✅
├─ Transférer au système
└─ Le système rend → Visible à l'écran
Résultat : Animations fluides
Image avec À-coup (Body de Vue Long)
Image 1 :
├─ Gérer les événements
├─ Mettre à jour l'interface utilisateur
│ └─ UN BODY DE VUE TROP LENT
│ └─ Dépasse l'échéance de l'image ❌
├─ Échéance manquée
└─ L'image précédente reste visible (À-COUP)
Image 2 : (Retardée)
├─ Gérer les événements (retardés d'1 image)
├─ Mettre à jour l'interface utilisateur
├─ Transférer au système
└─ Le système rend → Enfin visible
Résultat : Image précédente visible pendant 2+ images = animation saccadée
Image avec À-coup (Trop de Mises à Jour)
Image 1 :
├─ Gérer les événements
├─ Mettre à jour l'interface utilisateur
│ ├─ Mise à jour 1 (rapide)
│ ├─ Mise à jour 2 (rapide)
│ ├─ Mise à jour 3 (rapide)
│ ├─ ... (100 autres mises à jour rapides)
│ └─ Temps total dépasse l'échéance ❌
├─ Échéance manquée
└─ L'image précédente reste visible (À-COUP)
Résultat : De nombreuses petites mises à jour s'additionnent pour manquer l'échéance
Aperçu Clé : Le temps d'exécution du body de la vue est important car le fait de manquer les échéances des images provoque des à-coups, rendant les animations moins fluides.
Référence :
- Comprendre les à-coups dans votre application
- Tech Talk sur la boucle de rendu et la résolution des à-coups
Problème 1 : Mises à jour Longues du Body de la Vue
Identifier les Mises à jour Longues
- Enregistrez une trace dans Instruments avec le modèle SwiftUI
- Regardez la piste Mises à jour Longues du Body de la Vue — y a-t-il des barres orange/rouges ?
- Développez la piste SwiftUI pour voir les sous-pistes
- Sélectionnez la sous-piste Mises à jour du Body de la Vue
- Filtrez pour les mises à jour longues :
- Volet Détail → Menu déroulant → Choisissez "Résumé des mises à jour longues du body de la Vue"
Analyser avec le Profileur Temporel
Flux de travail :
- Trouvez une mise à jour longue dans le Résumé des mises à jour longues du body de la Vue
- Survolez le nom de la vue → Cliquez sur la flèche → "Afficher les mises à jour"
- Faites un clic droit sur la mise à jour longue → "Définir la plage d'inspection et zoomer"
- Basculez vers la piste de l'instrument Profileur Temporel
Ce que vous voyez :
- Piles d'appels pour les échantillons enregistrés pendant l'exécution du body de la vue
- Temps passé dans chaque image (colonne la plus à gauche)
- Votre body de vue imbriqué dans la pile d'appels SwiftUI profonde
Trouver le goulot d'étranglement :
- Option-clic pour développer la pile d'appels du thread principal
- Commande-F pour rechercher le nom de votre vue (par exemple, "LandmarkListItemView")
- Identifiez les opérations coûteuses dans la colonne de temps
Opérations Coûteuses Courantes
Création de Formatters (Très Coûteux)
❌ MAUVAIS - Créer des formatters dans le body de la vue :
struct LandmarkListItemView: View {
let landmark: Landmark
@State private var userLocation: CLLocation
var distance: String {
// ❌ Création de formatters à chaque exécution du body
let numberFormatter = NumberFormatter()
numberFormatter.maximumFractionDigits = 1
let measurementFormatter = MeasurementFormatter()
measurementFormatter.numberFormatter = numberFormatter
let meters = userLocation.distance(from: landmark.location)
let measurement = Measurement(value: meters, unit: UnitLength.meters)
return measurementFormatter.string(from: measurement)
}
var body: some View {
HStack {
Text(landmark.name)
Text(distance) // Appelle la propriété distance coûteuse
}
}
}
Pourquoi c'est lent :
- Les formatters sont coûteux à créer (millisecondes chacun)
- Créés chaque fois que le body de la vue s'exécute
- S'exécute sur le thread principal → l'application attend avant de continuer les mises à jour de l'interface utilisateur
- Plusieurs vues → le temps s'accumule rapidement
✅ CORRECT - Mettre en cache les formatters de manière centralisée :
@Observable
class LocationFinder {
private let formatter: MeasurementFormatter
private let landmarks: [Landmark]
private var distanceCache: [Landmark.ID: String] = [:]
init(landmarks: [Landmark]) {
self.landmarks = landmarks
// Créez les formatters UNE FOIS pendant l'initialisation
let numberFormatter = NumberFormatter()
numberFormatter.maximumFractionDigits = 1
self.formatter = MeasurementFormatter()
self.formatter.numberFormatter = numberFormatter
updateDistances()
}
func didUpdateLocations(_ locations: [CLLocation]) {
guard let location = locations.last else { return }
updateDistances(from: location)
}
private func updateDistances(from location: CLLocation? = nil) {
guard let location else { return }
for landmark in landmarks {
let meters = location.distance(from: landmark.location)
let measurement = Measurement(value: meters, unit: UnitLength.meters)
distanceCache[landmark.id] = formatter.string(from: measurement)
}
}
func distanceString(for landmarkID: Landmark.ID) -> String {
distanceCache[landmarkID] ?? "Inconnu"
}
}
struct LandmarkListItemView: View {
let landmark: Landmark
@Environment(LocationFinder.self) private var locationFinder
var body: some View {
HStack {
Text(landmark.name)
Text(locationFinder.distanceString(for: landmark.id)) // ✅ Recherche rapide
}
}
}
Avantages :
- Formatters créés une fois, réutilisés pour tous les points de repère
- Chaînes pré-calculées lorsque la localisation change
- Le body de la vue lit simplement la valeur mise en cache (instantané)
- Mises à jour longues du body de la vue éliminées
Autres Opérations Coûteuses
Calculs Complexes :
// ❌ Ne calculez pas dans le body de la vue
var body: some View {
let result = expensiveAlgorithm(data) // Calculs complexes, tris, etc.
Text("\(result)")
}
// ✅ Calculez dans le modèle, mettez en cache le résultat
@Observable
class ViewModel {
private(set) var result: Int = 0
func updateData(_ data: [Int]) {
result = expensiveAlgorithm(data) // Calculez une fois
}
}
E/S Réseau/Fichier :
// ❌ Ne JAMAIS faire d'E/S dans le body de la vue
var body: some View {
let data = try? Data(contentsOf: fileURL) // ❌ E/S synchrone
// ...
}
// ✅ Chargez de manière asynchrone
Identité et AnyView
AnyView efface les informations de type, ce qui empêche SwiftUI de suivre correctement l'identité de la vue, entraînant des mises à jour inutiles.
Mauvais - Utiliser AnyView :
var body: some View {
if condition {
AnyView(Text("Condition vraie"))
} else {
AnyView(Text("Condition fausse"))
}
}
Bon - Utiliser ViewBuilder :
@ViewBuilder
var body: some View {
if condition {
Text("Condition vraie")
} else {
Text("Condition fausse")
}
}
Problème 2 : Mises à jour Inutiles
Comprendre quand les vues se mettent à jour
SwiftUI met à jour une vue lorsque sa dépendance change. Cependant, les mises à jour peuvent se propager de manière excessive.
Pourquoi les vues se mettent à jour
- Changement d'état -> @State, @Binding, @StateObject, @ObservedObject
- Propriété d'entrée ->
letouvarde la vue parente - Environnement -> @EnvironmentObject, @Environment
- Mise à jour forcée ->
.id()change
Détecter les mises à jour inutiles
- Enregistrez une trace
- Regardez la piste Groupes de Mise à Jour
- Développez-la pour voir le nombre de mises à jour par vue
- Cherchez les vues avec un nombre élevé de mises à jour mais peu de changements de données
Patterns Courants de Mises à jour Inutiles
Vue avec @ObservedObject redondant
Mauvais :
struct ChildView: View {
@ObservedObject var viewModel: ViewModel // Observe TOUT l'objet
var body: some View {
Text(viewModel.title) // Se met à jour même si seulement `otherProperty` change
}
}
Bon :
struct ChildView: View {
let title: String // Passez uniquement ce dont vous avez besoin
var body: some View {
Text(title)
}
}
Identité et Clés
Une mauvaise gestion de l'identité peut faire que SwiftUI reconstruise des vues entières au lieu de les mettre à jour.
Mauvais - Identité instable :
ForEach(items, id: \.self) { item in // Utiliser l'identité implicite
ItemView(item: item)
}
Bon - Identité stable :
ForEach(items, id: \.id) { item in // Utiliser un identifiant explicite unique
ItemView(item: item)
}
Recherche d'identité dans Instruments :
- Piste "Identité de la Vue" (si disponible) montre quand les vues sont déplacées, supprimées ou réinsérées
- Cherchez des reconstructions inutiles
Arbre de Décision pour l'Optimisation
Processus de Priorisation
- Exécutez Instruments 26 avec le modèle SwiftUI
- Cherchez les barres ROUGES sur la piste Mises à jour Longues du Body de la Vue
- Si trouvé ROUGE :
- Utilisez le Profileur Temporel pour identifier l'opération coûteuse
- Corrigez en déplaçant le travail coûteux hors du body de la vue
- Si seulement ORANGE :
- Combien de pics orange ? Beaucoup (10+) ou peu (1-2) ?
- Beaucoup : concentrez-vous sur la réduction du nombre de mises à jour
- Peu : concentrez-vous sur l'accélération de chaque mise à jour
- Si les barres sont GRISES :
- Le problème n'est probablement pas dans SwiftUI
- Cherchez des problèmes d'E/S, de réseau ou de rendu personnalisé
Scénarios de Pression
Application avec des données volumineuses (10k+ éléments) :
- Assurez-vous d'utiliser
LazyVStack/LazyHStack - Envisagez de paginer les données
- Utilisez une identification stable pour les listes
Application avec des animations complexes :
- Utilisez
.drawingGroup()pour le rendu GPU si approprié - Limitez les vues modifiées par des animations
- Utilisez
.animation(nil, value: ...)pour éviter des animations inutiles
Application avec des mises à jour fréquentes (ex. données en temps réel) :
- Regroupez les mises à jour
- Utilisez
.debounce()ou.throttle()sur les éditeurs - Envisagez
DispatchQueue.main.asyncpour les mises à jour non urgentes
Références
- WWDC 2025 Session 256 : Performances SwiftUI — Le tableau de bord complet
- Instruments 26 Documentation : Profilage des performances de l'interface utilisateur
- Comprendre les à-coups dans votre application
- Compétence SwiftUI 26 Features (swiftui-26-ref) — Changements de l'API SwiftUI iOS 26