Swift Academy · Lektion

Map, filter och reduce på arrayer

Omforma arrayer med funktionella higher-order-funktioner.

Lektion 3 av 412 steg

Map, filter och reduce på arrayer är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Swift Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Swift Academy innehåller totalt 4 lektioner.

Välkommen

Swifts funktioner av högre ordning — `map`, `filter` och `reduce` — transformerar samlingar utan att ändra dem. De gör avsikten tydlig och eliminerar loopar som lätt leder till fel.

map — Transformera varje element

```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` tillämpar en closure på varje element och returnerar en ny array med resultaten.

filter — Behåll matchande element

```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` returnerar en ny array som endast innehåller element där closure-resultatet är `true`.

reduce — Kombinera till ett värde

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

Kedja map, filter och reduce

```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 ``` Kedjningen läses från vänster till höger och uttrycker datapipelinen tydligt.

compactMap — Omvandla och packa upp

```swift let strings = ["1","two","3","four","5"] let nums = strings.compactMap { Int($0) } // [1,3,5] ``` `compactMap` transformerar och tar bort nil-resultat — perfekt för konverteringar som kan misslyckas.

flatMap — Platta ut nästlade arrayer

```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 — Endast sidoeffekter

```swift [1, 2, 3].forEach { print($0) } ``` `forEach` fungerar som en `for-in`-loop men kan inte använda `break` eller `continue`. Använd den endast när Du behöver sidoeffekter och inte behöver avsluta i förtid.

reduce(into:) för ordböcker

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

Lata kedjor för bättre prestanda

```swift let lazyResult = (1...1_000_000) .lazy .filter { $0 % 7 == 0 } .map { $0 * 2 } .prefix(5) // No intermediate arrays created! ``` Lägg till `.lazy` i början av en kedja för att utvärdera den vid behov.

Snabb kontroll

Vilken funktion transformerar varje element och tar bort nil-resultat?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Viktigaste punkterna: • `map` — transformera varje element till en ny array • `filter` — behåll element som matchar ett predikat • `reduce` — vik ihop till ett enda ackumulerat värde • `compactMap` — transformera och ta bort nil-värden • `flatMap` — transformera och platta ut nästlade sekvenser • Kedja med `.lazy` för att undvika mellanliggande allokeringar Nästa avsnitt: 2D-arrayer och nästlade samlingar.

Gratis att börja

Lär dig Swift med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 122
Lektioner: 409

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Map, filter och reduce på arrayer” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Swift Academy, inklusive ”Map, filter och reduce på arrayer”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Swift Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Map, filter och reduce på arrayer”?

Omforma arrayer med funktionella higher-order-funktioner. Ni övar på Swift Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Swift Academy?

Du behöver inga förkunskaper. Utbildningen i Swift Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Map, filter och reduce på arrayer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Swift Academy-lektionen?

Ja. Varje Swift Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Swift Academy