Swift Academy · Lektion

Sammlungen mit for-in durchlaufen

Durchlaufen Sie Arrays, Dictionaries und Sets mit enumerated und zip.

Sammlungen mit for-in durchlaufen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Die `for-in`-Schleife funktioniert mit jeder `Sequence` – Arrays, Dictionaries, Sets, Strings und Ihren eigenen benutzerdefinierten Typen. Sehen wir uns die nützlichsten Muster an.

Ein Array durchlaufen

```swift let fruits = ["apple", "banana", "cherry"] for fruit in fruits { print(fruit) } // apple, banana, cherry ``` Bei jeder Iteration wird ein Element an `fruit` gebunden.

enumerated() – Index und Wert

Wenn Sie sowohl den Index als auch den Wert benötigen, verwenden Sie `.enumerated()`: ```swift for (index, fruit) in fruits.enumerated() { print("\(index): \(fruit)") } // 0: apple // 1: banana // 2: cherry ``` `enumerated()` gibt eine Sequenz aus `(offset, element)`-Tupeln zurück.

Ein Dictionary durchlaufen

Bei der Iteration über ein Dictionary erhalten Sie `(key, value)`-Tupel in nicht festgelegter Reihenfolge: ```swift let scores = ["Alice": 95, "Bob": 87] for (name, score) in scores { print("\(name): \(score)") } ``` Sortieren Sie die Schlüssel zuerst, wenn Sie eine deterministische Reihenfolge benötigen.

Ein Set durchlaufen

Sets werden in einer nicht festgelegten Reihenfolge durchlaufen: ```swift let colors: Set = ["red", "green", "blue"] for color in colors.sorted() { print(color) } ``` Rufen Sie `.sorted()` auf, wenn Sie eine alphabetische oder aufsteigende Reihenfolge benötigen.

zip() – Parallele Iteration

Durchlaufen Sie zwei Sequenzen parallel mit `zip()`: ```swift let names = ["Alice", "Bob", "Carol"] let scores = [95, 87, 92] for (name, score) in zip(names, scores) { print("\(name): \(score)") } ``` `zip` endet, sobald die kürzere Sequenz erschöpft ist.

Filtern während der Iteration: where-Klausel

Fügen Sie eine `where`-Klausel hinzu, um Elemente direkt bei der Iteration zu überspringen: ```swift for n in 1...20 where n % 3 == 0 { print(n) // 3, 6, 9, 12, 15, 18 } ``` Das ist übersichtlicher, als den Schleifenkörper in eine `if`-Anweisung einzuschließen.

Mit Indizes iterieren

Greifen Sie mit `.indices` auf den ursprünglichen Indexbereich zu: ```swift var arr = [10, 20, 30] for i in arr.indices { arr[i] *= 2 } // arr is now [20, 40, 60] ``` Verwenden Sie dies, wenn Sie Elemente direkt an ihrer Stelle *mutieren* müssen.

Tupel in for-in destrukturieren

Sequenzen aus Tupeln können direkt in der Schleife destrukturiert werden: ```swift let points = [(1, 2), (3, 4), (5, 6)] for (x, y) in points { print("x=\(x), y=\(y)") } ``` Übersichtlich und prägnant – Sie benötigen keine Subskripte wie `.0` und `.1`.

Lazy-Sequenzen in Schleifen

Setzen Sie `.lazy` voran, um die Berechnung aufzuschieben und Zwischenarrays zu vermeiden: ```swift let total = (1...1_000_000) .lazy .filter { $0 % 2 == 0 } .prefix(5) .reduce(0, +) print(total) // 30 ``` `.lazy` ist besonders nützlich, wenn Sie Operationen auf großen Sequenzen verketten.

Schnelltest

Welche Methode liefert Ihnen bei der Iteration über ein Array sowohl den Index als auch den Wert?

Zusammenfassung

Die wichtigsten Punkte: • `for elem in collection` – grundlegende Iteration • `.enumerated()` – Paare aus Index und Wert • `zip(a, b)` – parallele Iteration über zwei Sequenzen • `for x in seq where condition` – Inline-Filter • `.indices` – beim Mutieren von Elementen verwenden • `.lazy` – Arbeit bei großen Sequenzen aufschieben Als Nächstes: break, continue und Schleifen mit Labels.

Häufig gestellte Fragen

Ist die Lektion „Sammlungen mit for-in durchlaufen“ kostenlos?

Ja — der vollständige Text von „Sammlungen mit for-in durchlaufen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Sammlungen mit for-in durchlaufen“?

Durchlaufen Sie Arrays, Dictionaries und Sets mit enumerated und zip. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Sammlungen mit for-in durchlaufen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

for-in-Schleifen mit Bereichen
while- und repeat-while-Schleifen
Sammlungen mit for-in durchlaufen
break, continue und markierte Anweisungen

← Zurück zu Swift Academy