Swift Academy · Leçon

La propriété lazy

Différez les transformations jusqu’à ce qu’elles soient nécessaires.

La propriété lazy est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Évaluation immédiate par défaut

Les méthodes standard des collections sont immédiates : map, filter, etc. s’exécutent immédiatement et construisent aussitôt un nouveau tableau complet, même si vous ne lisez que le premier élément.

Le travail immédiat se fait maintenant

Cela construit d’avance l’intégralité du tableau transformé :

let nums = [1, 2, 3, 4, 5]
let doubled = nums.map { $0 * 2 }  // whole array built now
print(doubled.first!)  // 2

La propriété lazy

Chaque collection expose une vue .lazy. Les opérations sur une vue différée sont reportées : elles ne s’exécutent que lorsque vous parcourez réellement la collection ou demandez un élément précis.

Créer une vue différée

Il suffit de préfixer la chaîne avec .lazy :

let nums = [1, 2, 3, 4, 5]
let view = nums.lazy.map { $0 * 2 }
// nothing computed yet
print(Array(view))  // [2, 4, 6, 8, 10]

Preuve de l’exécution différée

Les effets de bord montrent que la fermeture ne s’exécute qu’à la demande :

let nums = [1, 2, 3]
let lazyMapped = nums.lazy.map { n -> Int in
    print("transforming \(n)")
    return n * 2
}
print("created view")
print(lazyMapped.first!)  // prints "transforming 1" then 2

lazy renvoie un type différent

Une chaîne différée est une enveloppe légère, pas un tableau :

let nums = [1, 2, 3]
let view = nums.lazy.map { $0 + 1 }
print(type(of: view).self != [Int].self)  // true -- it is a LazyMapSequence

Concrétiser une vue différée

Revenez à un tableau concret avec Array(...) lorsque vous devez le stocker ou le renvoyer :

let nums = [1, 2, 3]
let result: [Int] = Array(nums.lazy.map { $0 * 10 })
print(result)  // [10, 20, 30]

lazy et first(where:)

Le traitement différé est avantageux lorsque vous vous arrêtez tôt. Seul le nombre d’éléments nécessaire pour trouver une correspondance est traité :

let nums = [1, 2, 3, 4, 5, 6]
let firstBig = nums.lazy.map { $0 * $0 }.first { $0 > 10 }
print(firstBig!)  // 16  (stops at 4*4)

lazy sur un intervalle

Les intervalles fonctionnent également avec lazy, ce qui est utile pour les séquences volumineuses ou quasi infinies :

let firstThree = (1...1000).lazy.map { $0 * $0 }.prefix(3)
print(Array(firstThree))  // [1, 4, 9]

Quand la vue est réévaluée

Une vue différée recalcule le résultat chaque fois que vous la parcourez — elle ne stocke aucun résultat. Parcourez-la deux fois et la transformation s’exécute deux fois :

var calls = 0
let view = [1, 2].lazy.map { (n: Int) -> Int in calls += 1; return n }
_ = Array(view)
_ = Array(view)
print(calls)  // 4

Quand utiliser lazy

Ajoutez .lazy lorsque vous avez une longue chaîne mais ne consommez qu’une partie du résultat — la première correspondance, un préfixe ou un seul reduce. Pour les petits tableaux parcourus entièrement, le traitement immédiat est plus simple.

let nums = Array(1...100)
let result = nums.lazy.filter { $0 % 7 == 0 }.first
print(result!)  // 7

Vérification rapide

Que change la propriété .lazy pour map et filter ?

Récapitulatif

Vous avez appris les bases du traitement différé :

Les méthodes standard des collections sont immédiates — elles construisent les tableaux sans attendre
.lazy renvoie une vue différée (un type de séquence spécial)
Le travail ne s’effectue que lorsque vous parcourez la collection ou demandez un élément
Concrétisez la vue avec Array(...) ; elle est réexécutée à chaque parcours

Ensuite : les chaînes lazy avec map et filter.

Questions Fréquemment Posées

La leçon « La propriété lazy » est-elle gratuite ?

Oui — le texte complet de « La propriété lazy » 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 « La propriété lazy » ?

Différez les transformations jusqu’à ce qu’elles soient nécessaires. 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 1 sur 4.

Combien de temps prend la leçon « La propriété lazy » ?

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