Swift Academy · Leçon

Parcourir des collections avec for-in

Parcourez des tableaux, dictionnaires et ensembles avec enumerated et zip.

Leçon 3 sur 412 étapes

Parcourir des collections avec for-in est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 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

La boucle `for-in` fonctionne avec toute `Sequence` — tableaux, dictionnaires, ensembles, chaînes et types personnalisés. Découvrons les schémas les plus utiles.

Parcourir un tableau

```swift let fruits = ["apple", "banana", "cherry"] for fruit in fruits { print(fruit) } // apple, banana, cherry ``` À chaque itération, un élément est associé à `fruit`.

enumerated() — index et valeur

Lorsque vous avez besoin à la fois de l'index et de la valeur, utilisez `.enumerated()` : ```swift for (index, fruit) in fruits.enumerated() { print("\(index): \(fruit)") } // 0: apple // 1: banana // 2: cherry ``` `enumerated()` renvoie une séquence de tuples `(offset, element)`.

Parcourir un dictionnaire

L'itération d'un dictionnaire fournit des tuples `(key, value)` dans un ordre non spécifié : ```swift let scores = ["Alice": 95, "Bob": 87] for (name, score) in scores { print("\(name): \(score)") } ``` Triez d'abord les clés si vous avez besoin d'un ordre déterministe.

Parcourir un ensemble

Les ensembles sont parcourus dans un ordre non spécifié : ```swift let colors: Set = ["red", "green", "blue"] for color in colors.sorted() { print(color) } ``` Appelez `.sorted()` lorsque vous avez besoin d'un ordre alphabétique ou croissant.

zip() — parcours parallèle

Parcourez deux séquences en parallèle avec `zip()` : ```swift let names = ["Alice", "Bob", "Carol"] let scores = [95, 87, 92] for (name, score) in zip(names, scores) { print("\(name): \(score)") } ``` `zip` s'arrête au niveau de la séquence la plus courte.

Filtrer pendant l’itération : clause where

Ajoutez une clause `where` pour ignorer des éléments directement dans la boucle : ```swift for n in 1...20 where n % 3 == 0 { print(n) // 3, 6, 9, 12, 15, 18 } ``` Cette approche est plus claire que de placer une condition `if` dans le corps de la boucle.

Itération avec des indices

Accédez à la plage d’indices brute avec `.indices` : ```swift var arr = [10, 20, 30] for i in arr.indices { arr[i] *= 2 } // arr is now [20, 40, 60] ``` Utilisez cette approche lorsque vous devez *modifier* les éléments directement.

Déstructuration de tuples dans les boucles for-in

Les séquences de tuples peuvent être déstructurées directement dans la boucle : ```swift let points = [(1, 2), (3, 4), (5, 6)] for (x, y) in points { print("x=\(x), y=\(y)") } ``` C’est clair et concis : il n’est pas nécessaire d’utiliser les sous-scripts `.0` et `.1`.

Séquences paresseuses dans les boucles

Préfixez `.lazy` pour différer le calcul et éviter les tableaux intermédiaires : ```swift let total = (1...1_000_000) .lazy .filter { $0 % 2 == 0 } .prefix(5) .reduce(0, +) print(total) // 30 ``` `.lazy` est particulièrement puissant lorsque vous enchaînez des opérations sur de grandes séquences.

Vérification rapide

Quelle méthode vous fournit à la fois l’indice et la valeur lors de l’itération sur un tableau ?

Réponds-y dans la leçon interactive

Récapitulatif

Points essentiels : • `for elem in collection` — itération de base • `.enumerated()` — paires indice-valeur • `zip(a, b)` — itération parallèle de deux séquences • `for x in seq where condition` — filtre intégré • `.indices` — à utiliser lorsque vous modifiez des éléments • `.lazy` — diffère le traitement sur les grandes séquences Ensuite : break, continue et instructions étiquetées.

Gratuit pour commencer

Apprends Swift avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 122
Leçons: 409

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Parcourir des collections avec for-in » est-elle gratuite ?

Oui — le texte complet de « Parcourir des collections avec for-in » 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 « Parcourir des collections avec for-in » ?

Parcourez des tableaux, dictionnaires et ensembles avec enumerated et zip. 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 3 sur 4.

Combien de temps prend la leçon « Parcourir des collections avec for-in » ?

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

Boucles for-in avec des intervalles
Boucles while et repeat-while
Parcourir des collections avec for-in
Instructions break, continue et étiquetées

← Retour à Swift Academy