0Pricing
Swift Academy · Leçon

Séquences différées pour plus d’efficacité

Utiliser .lazy pour différer les calculs et éviter de créer des tableaux intermédiaires.

Séquences différées pour plus d’efficacité 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.

Bienvenue

Les séquences paresseuses reportent les calculs jusqu'à ce que les résultats soient nécessaires, ce qui évite de créer des tableaux intermédiaires lors de l'enchaînement d'opérations.

Le problème de l'évaluation immédiate

```swift let result = (1...1_000_000) .filter { $0 % 7 == 0 } // creates array of ~142857 elements .map { $0 * 2 } // creates another 142857-element array .prefix(5) // Wasteful — only 5 elements needed! ```

Ajouter .lazy

```swift let result = (1...1_000_000) .lazy .filter { $0 % 7 == 0 } .map { $0 * 2 } .prefix(5) // Only computes what prefix(5) needs — no intermediate arrays! print(Array(result)) // [14,28,42,56,70] ```

Types de collections paresseuses

Lorsque vous appelez `.lazy` sur une séquence, Swift renvoie une `LazySequence` qui l'enveloppe : ```swift let lazyArr = [1,2,3].lazy // LazySequence<[Int]> let lazyMap = lazyArr.map { $0*2 } // LazyMapSequence ```

Quand l'évaluation paresseuse est avantageuse

L'évaluation paresseuse est avantageuse lorsque : • Vous n'avez besoin que d'un préfixe d'une grande séquence • La source est infinie (générateurs personnalisés) • Vous enchaînez de nombreuses transformations sur de grandes collections

Séquences infinies

```swift struct Fibonacci: Sequence { func makeIterator() -> some IteratorProtocol { var a = 0, b = 1 return AnyIterator { let next = a; a = b; b = next + b; return next } } } let first10 = Array(Fibonacci().prefix(10)) ```

Évaluation paresseuse avec first(where:)

```swift let firstEven = (1...Int.max) .lazy .first { $0 % 2 == 0 } // Returns 2 immediately — doesn't iterate the whole range ```

Forcer l'évaluation

Pour matérialiser une séquence paresseuse, enveloppez-la dans Array : ```swift let eager = Array((1...100).lazy.filter { $0 % 3 == 0 }.map { $0*2 }) ```

L'évaluation paresseuse n'est pas toujours avantageuse

Pour les petites collections, l'évaluation paresseuse entraîne un surcoût dû aux types d'enveloppe. Mesurez les performances avant d'appliquer `.lazy` à chaque chaîne d'opérations. Utilisez-la lorsque la collection est grande et que vous avez besoin d'un arrêt anticipé.

Générateur paresseux personnalisé

```swift func naturals() -> AnyIterator { var n = 0 return AnyIterator { n += 1; return n } } Array(naturals().prefix(5)) // [1,2,3,4,5] ```

Vérification rapide

Que permet le préfixe `.lazy` dans une chaîne d'opérations sur une collection ?

Récapitulatif

Points essentiels : • `.lazy` reporte les calculs de map et filter jusqu'à leur consommation • Évite les allocations de tableaux intermédiaires • Utile pour les grandes séquences lorsqu'un préfixe בלבד est nécessaire • À combiner avec `prefix` et `first(where:)` pour un arrêt anticipé • Matérialisez avec `Array(lazySeq)` lorsque c'est nécessaire Cours terminé !

Questions Fréquemment Posées

La leçon « Séquences différées pour plus d’efficacité » est-elle gratuite ?

Oui — le texte complet de « Séquences différées pour plus d’efficacité » 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 « Séquences différées pour plus d’efficacité » ?

Utiliser .lazy pour différer les calculs et éviter de créer des tableaux intermédiaires. 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 « Séquences différées pour plus d’efficacité » ?

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

  1. Fonctions pures et conception sans effets de bord
  2. Fonctions d’ordre supérieur : map, flatMap, compactMap
  3. Composition de fonctions et pipelines
  4. Séquences différées pour plus d’efficacité
← Retour à Swift Academy