Map, Filter i Reduce na tablicach

Funkcje wyższego rzędu języka Swift — `map`, `filter` i `reduce` — przekształcają kolekcje bez ich modyfikowania. Dzięki nim intencje kodu są wyraźniejsze, a podatne na błędy pętle stają się zbędne.

```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` stosuje closure do każdego elementu i zwraca nową tablicę wyników.

```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` zwraca nową tablicę zawierającą wyłącznie elementy, dla których closure zwraca `true`.

```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" ```

```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 ``` Łańcuchowanie czyta się od lewej do prawej, dzięki czemu potok danych jest jasno przedstawiony.

```swift let strings = ["1","two","3","four","5"] let nums = strings.compactMap { Int($0) } // [1,3,5] ``` `compactMap` przekształca wartości i usuwa wyniki nil — doskonale nadaje się do konwersji, które mogą się nie powieść.

```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"] ```

```swift [1, 2, 3].forEach { print($0) } ``` `forEach` przypomina pętlę `for-in`, ale nie można w nim używać `break` ani `continue`. Należy go używać tylko wtedy, gdy potrzebne są efekty uboczne i nie trzeba wcześniej przerywać działania.

```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"]] ```

```swift let lazyResult = (1...1_000_000) .lazy .filter { $0 % 7 == 0 } .map { $0 * 2 } .prefix(5) // No intermediate arrays created! ``` Dodaj `.lazy` na początku łańcucha, aby obliczenia były wykonywane na żądanie.

Najważniejsze informacje: • `map` — przekształca każdy element w nową tablicę • `filter` — zachowuje elementy pasujące do predykatu • `reduce` — składa elementy w pojedynczą wartość akumulowaną • `compactMap` — przekształca elementy i odrzuca wartości nil • `flatMap` — przekształca elementy i spłaszcza zagnieżdżone sekwencje • Łańcuchuj operacje z `.lazy`, aby uniknąć tworzenia pośrednich kolekcji Dalej: tablice 2D i zagnieżdżone kolekcje.