Swift Academy · Lektion

Map, Filter und Reduce auf Arrays

Transformieren Sie Arrays mit funktionalen Funktionen höherer Ordnung.

Map, Filter und Reduce auf Arrays 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

Swifts Funktionen höherer Ordnung — `map`, `filter` und `reduce` — transformieren Sammlungen, ohne sie zu verändern. Sie machen Ihre Absichten deutlich und vermeiden fehleranfällige Schleifen.

map — Jedes Element transformieren

```swift let nums = [1, 2, 3, 4] let doubled = nums.map { $0 * 2 } // [2,4,6,8] let strings = nums.map { "Item \($0)" } // ["Item 1","Item 2",...] ``` `map` wendet auf jedes Element eine Closure an und gibt ein neues Array mit den Ergebnissen zurück.

filter — Passende Elemente behalten

```swift let scores = [45, 80, 92, 37, 68] let passing = scores.filter { $0 >= 60 } // [80,92,68] let even = (1...10).filter { $0 % 2 == 0 } // [2,4,6,8,10] ``` `filter` gibt ein neues Array zurück, das nur die Elemente enthält, für die die Closure `true` zurückgibt.

reduce — Zu einem Wert zusammenführen

```swift let nums = [1, 2, 3, 4, 5] let sum = nums.reduce(0) { $0 + $1 } // 15 let product = nums.reduce(1, *) // 120 let joined = ["a","b","c"].reduce("") { $0 + $1 } // "abc" ```

map, filter und reduce verketten

```swift let result = (1...10) .filter { $0 % 2 == 0 } // [2,4,6,8,10] .map { $0 * $0 } // [4,16,36,64,100] .reduce(0, +) // 220 ``` Die Verkettung wird von links nach rechts gelesen und beschreibt die Datenverarbeitung übersichtlich.

compactMap — Abbilden und Entpacken

```swift let strings = ["1","two","3","four","5"] let nums = strings.compactMap { Int($0) } // [1,3,5] ``` `compactMap` transformiert Werte und entfernt nil-Ergebnisse — ideal für Konvertierungen, die fehlschlagen können.

flatMap — Verschachtelte Arrays abflachen

```swift let nested = [[1,2,3],[4,5],[6]] let flat = nested.flatMap { $0 } // [1,2,3,4,5,6] let words = ["hello world","foo bar"] let all = words.flatMap { $0.split(separator: " ") } // ["hello","world","foo","bar"] ```

forEach — Nur Seiteneffekte

```swift [1, 2, 3].forEach { print($0) } ``` `forEach` ähnelt einer `for-in`-Schleife, kann aber `break` oder `continue` nicht verwenden. Nutzen Sie es nur, wenn Sie Seiteneffekte benötigen und die Schleife nicht vorzeitig verlassen müssen.

reduce(into:) für Dictionaries

```swift let words = ["apple","banana","apricot","blueberry"] let grouped = words.reduce(into: [Character:[String]]()) { dict, word in let key = word.first! dict[key, default: []].append(word) } // ["a":["apple","apricot"],"b":["banana","blueberry"]] ```

Lazy-Verkettungen für bessere Leistung

```swift let lazyResult = (1...1_000_000) .lazy .filter { $0 % 7 == 0 } .map { $0 * 2 } .prefix(5) // No intermediate arrays created! ``` Fügen Sie am Anfang einer Verkettung `.lazy` hinzu, um die Auswertung erst bei Bedarf durchzuführen.

Kurzer Test

Welche Funktion transformiert jedes Element und entfernt nil-Ergebnisse?

Zusammenfassung

Wichtigste Erkenntnisse: • `map` — jedes Element in ein neues Array transformieren • `filter` — Elemente behalten, die ein Prädikat erfüllen • `reduce` — zu einem einzelnen akkumulierten Wert zusammenführen • `compactMap` — transformieren und nil-Werte verwerfen • `flatMap` — transformieren und verschachtelte Sequenzen abflachen • Mit `.lazy` verketten, um temporäre Speicherbelegungen zu vermeiden Als Nächstes: 2D-Arrays und verschachtelte Sammlungen.

Häufig gestellte Fragen

Ist die Lektion „Map, Filter und Reduce auf Arrays“ kostenlos?

Ja — der vollständige Text von „Map, Filter und Reduce auf Arrays“ 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 „Map, Filter und Reduce auf Arrays“?

Transformieren Sie Arrays mit funktionalen Funktionen höherer Ordnung. 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 „Map, Filter und Reduce auf Arrays“?

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

Arrays erstellen und verändern
Sortieren, suchen und Teilbereiche bilden
Map, Filter und Reduce auf Arrays
2D-Arrays und verschachtelte Sammlungen

← Zurück zu Swift Academy