Swift Academy · Leçon

Cache de mise en page et performances

Utilisez le cache de mise en page pour gagner en efficacité.

Cache de mise en page et performances est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Pourquoi utiliser un cache d’agencement ?

SwiftUI peut appeler sizeThatFits et placeSubviews de nombreuses fois au cours d’une seule passe d’agencement.

Si vos calculs sont coûteux, un cache vous permet de les effectuer une fois puis de réutiliser le résultat, en évitant le travail répétitif.

Le type associé Cache

Le protocole Layout possède un type associé Cache, dont la valeur par défaut est Void. Définissez votre propre structure pour stocker les résultats précalculés.

struct FlowLayout: Layout {
    struct CacheData {
        var sizes: [CGSize] = []
    }
    typealias Cache = CacheData
}

makeCache

Implémentez makeCache(subviews:) pour créer le cache initial. SwiftUI l’appelle une fois avant les méthodes d’agencement, ce qui vous permet d’effectuer les mesures préalables.

func makeCache(subviews: Subviews) -> CacheData {
    let sizes = subviews.map { $0.sizeThatFits(.unspecified) }
    return CacheData(sizes: sizes)
}

Lecture du cache

Les méthodes d’agencement reçoivent désormais cache comme paramètre inout. Lisez vos valeurs précalculées au lieu de mesurer à nouveau chaque enfant.

func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout CacheData) -> CGSize {
    let height = cache.sizes.map(\.height).max() ?? 0
    let width = cache.sizes.reduce(0) { $0 + $1.width }
    return CGSize(width: width, height: height)
}

updateCache

Lorsque l’ensemble des sous-vues change, SwiftUI appelle updateCache(_:subviews:). L’implémentation par défaut reconstruit le cache via makeCache, mais vous pouvez la remplacer pour effectuer une mise à jour incrémentielle.

func updateCache(_ cache: inout CacheData, subviews: Subviews) {
    cache.sizes = subviews.map { $0.sizeThatFits(.unspecified) }
}

Déclenchement de updateCache

updateCache s’exécute lorsque le nombre ou l’identité des sous-vues change, et non à chaque modification de la géométrie. Ne mettez en cache que les données qui dépendent des sous-vues, pas celles qui dépendent de la taille proposée.

Mettre en cache uniquement les données indépendantes de la proposition

Une erreur courante consiste à mettre en cache des résultats qui dépendent de la taille proposée. La proposition peut changer entre deux appels : les résultats dépendant de la taille doivent donc être recalculés et non mis en cache sans discernement.

// OK to cache: intrinsic child sizes
// NOT OK to cache: row breaks (depend on proposed width)

Mise en cache des tailles intrinsèques

La méthode sûre consiste à mettre en cache les résultats coûteux de sizeThatFits(.unspecified), puis à effectuer à chaque appel les calculs rapides du retour à la ligne avec la proposition actuelle.

struct CacheData { var intrinsic: [CGSize] = [] }
// wrapping uses cache.intrinsic + current maxWidth

Éviter l’optimisation prématurée

Pour quelques enfants simples, la mesure est peu coûteuse et un cache ajoute de la complexité. Commencez par mesurer les performances : utilisez un cache uniquement lorsque la mesure est réellement coûteuse (texte, images, agencements imbriqués).

Cache et sémantique de valeur

SwiftUI possède le cache et le transmet avec inout. Conservez-le sous la forme d’un type valeur simple, sans références vers des vues, afin que SwiftUI puisse gérer sa durée de vie en toute sécurité.

struct CacheData {
    var sizes: [CGSize] // value types only
}

Mesurer le gain

Utilisez l’instrument SwiftUI ou de simples compteurs pour confirmer que le cache réduit réellement le nombre d’appels de mesure. Optimiser sans mesurer revient à deviner.

Vérification rapide : cache d’agencement

Vérifiez votre compréhension de la mise en cache de l’agencement.

Récapitulatif : cache d’agencement et performances

Le type associé Cache du protocole Layout, créé par makeCache et actualisé par updateCache, stocke les opérations coûteuses indépendantes de la proposition, comme les tailles intrinsèques des enfants.

Effectuez à chaque appel les calculs rapides qui dépendent de la proposition. Conservez le cache comme un type valeur sans référence, évitez la mise en cache prématurée et vérifiez le gain par un profilage avant d’ajouter de la complexité.

Questions Fréquemment Posées

La leçon « Cache de mise en page et performances » est-elle gratuite ?

Oui — le texte complet de « Cache de mise en page et performances » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Cache de mise en page et performances » ?

Utilisez le cache de mise en page pour gagner en efficacité. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Cache de mise en page et performances » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Swift Academy