Swift Academy · Les

KeyPaths gebruiken in collecties

Sorteer collecties en pas map toe met een key path.

Les 2 van 413 stappen

KeyPaths gebruiken in collecties is een gratis Swift Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Swift Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Swift Academy bevat in totaal 4 lessen.

Sleutelpaden komen goed tot hun recht in verzamelingen

Verzamelingsbewerkingen zoals map, sorted en filter lezen vaak alleen één eigenschap van elk element. Met sleutelpaden druk je die bedoeling uit zonder een closure te schrijven.

Swift accepteert een sleutelpad overal waar een functie met één argument die een waarde retourneert wordt verwacht, omdat je een sleutelpad kunt gebruiken als een functie van Root naar Value.

struct Person {
    let name: String
    let age: Int
}

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
let names = people.map(\.name)
print(names)

map met verkorte sleutelpaden

map(\.property) doorgeven is gelijkwaardig aan een closure schrijven die die eigenschap retourneert, maar korter en duidelijker. Met de voorafgaande backslash en punt kan de compiler het elementtype afleiden.

Vergelijk de twee vormen hieronder; ze leveren hetzelfde resultaat op.

struct Person {
    let name: String
    let age: Int
}

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
let closureForm = people.map { $0.age }
let keyPathForm = people.map(\.age)
print(closureForm)
print(keyPathForm)

sorted(by:) met een vergelijking via een sleutelpad

Als je op een eigenschap wilt sorteren, schrijf je nog steeds een kleine vergelijkingsclosure, maar je kunt de eigenschap daarin via een sleutelpad lezen voor meer duidelijkheid.

Hier sorteren we mensen van jong naar oud door hun age-waarden te vergelijken.

struct Person {
    let name: String
    let age: Int
}

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
let path = \Person.age
let sorted = people.sorted { $0[keyPath: path] < $1[keyPath: path] }
print(sorted.map(\.name))

Een herbruikbare sorteerhulp

Je kunt een algemene hulp schrijven die elke array sorteert op basis van elke vergelijkbare eigenschap, waarbij je de eigenschap als sleutelpadargument doorgeeft. Zo wordt sorteren op een veld overal in je codebase een bewerking van één regel.

De beperking T: Comparable zorgt ervoor dat de eigenschap geordend kan worden.

func sorted<E, T: Comparable>(_ array: [E], by path: KeyPath<E, T>) -> [E] {
    array.sorted { $0[keyPath: path] < $1[keyPath: path] }
}

struct Person { let name: String; let age: Int }
let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
print(sorted(people, by: \.age).map(\.name))

Filteren via een sleutelpad

Voor filter heb je een predicaat nodig dat een Bool retourneert, dus een kaal sleutelpad naar een eigenschap werkt alleen rechtstreeks wanneer die eigenschap al een Bool is.

Hier heeft elke taak een isDone-vlag en filteren we daarop met de verkorte notatie voor een sleutelpad.

struct Task {
    let title: String
    let isDone: Bool
}

let tasks = [Task(title: "A", isDone: true), Task(title: "B", isDone: false)]
let finished = tasks.filter(\.isDone)
print(finished.map(\.title))

Filteren op een niet-Bool-eigenschap

Wanneer je filtert op een niet-Bool-eigenschap, lees je die via een sleutelpad binnen een closure en vergelijk je de waarde. Een algemene hulp kan dit patroon vastleggen voor elke vergelijkbare eigenschap.

Hier houden we alleen de mensen over van wie de stad overeenkomt met een doelwaarde.

struct Person { let name: String; let city: String }

func filter<E, T: Equatable>(_ array: [E], _ path: KeyPath<E, T>, equals value: T) -> [E] {
    array.filter { $0[keyPath: path] == value }
}

let people = [Person(name: "Ana", city: "Oslo"), Person(name: "Ben", city: "Rome")]
print(filter(people, \.city, equals: "Oslo").map(\.name))

max en min via een sleutelpad

De methoden max(by:) en min(by:) nemen net als sorted een vergelijkingsclosure. Lees de eigenschap via een sleutelpad om het element met de grootste of kleinste waarde te vinden.

Hier vinden we de oudste persoon.

struct Person { let name: String; let age: Int }

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25), Person(name: "Cy", age: 41)]
let path = \Person.age
if let oldest = people.max(by: { $0[keyPath: path] < $1[keyPath: path] }) {
    print(oldest.name)
}

Een eigenschap optellen met reduce

Je kunt map(\.property) combineren met reduce om een numeriek veld op te tellen. Projecteer elk element eerst naar het getal dat je nodig hebt en tel die getallen daarna bij elkaar op.

Hier tellen we alle leeftijden op in één verwerkingsketen.

struct Person { let name: String; let age: Int }

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
let totalAge = people.map(\.age).reduce(0, +)
print(totalAge)

Groeperen op een sleutelpad

Dictionary(grouping:by:) groepeert elementen op basis van het resultaat van een closure. Lees een eigenschap via een sleutelpad om op dat veld te groeperen.

Hier worden mensen op stad gegroepeerd in een woordenboek met arrays.

struct Person { let name: String; let city: String }

let people = [
    Person(name: "Ana", city: "Oslo"),
    Person(name: "Ben", city: "Rome"),
    Person(name: "Cy", city: "Oslo")
]
let path = \Person.city
let byCity = Dictionary(grouping: people, by: { $0[keyPath: path] })
print(byCity["Oslo"]?.map(\.name) ?? [])

Sorteren op meerdere velden

Als je op één veld wilt sorteren en gelijke waarden met een ander veld wilt onderscheiden, vergelijk je eerst het primaire sleutelpad en gebruik je het secundaire als terugvaloptie wanneer de primaire waarden gelijk zijn.

Hier sorteren we op leeftijd en daarna op naam bij gelijke leeftijden.

struct Person { let name: String; let age: Int }

let people = [
    Person(name: "Zoe", age: 30),
    Person(name: "Ana", age: 30),
    Person(name: "Ben", age: 25)
]
let sorted = people.sorted {
    if $0[keyPath: \Person.age] != $1[keyPath: \Person.age] {
        return $0.age < $1.age
    }
    return $0.name < $1.name
}
print(sorted.map(\.name))

Waarom sleutelpaden hier beter zijn dan closures

Het gebruik van sleutelpaden in verzamelingsaanroepen vermindert overbodige code, voorkomt typefouten in de closure-body en maakt de bedoeling direct duidelijk: je projecteert één veld.

Voor complexe transformaties is een closure nog steeds het juiste hulpmiddel, maar voor het eenvoudig lezen van een eigenschap is \.property de duidelijkste keuze.

struct Product { let name: String; let price: Double }

let products = [Product(name: "Pen", price: 2), Product(name: "Pad", price: 5)]
let names = products.map(\.name)
let prices = products.map(\.price)
print(names)
print(prices)

Korte controle: sleutelpad in map

Kies de beknopte notatie met een sleutelpad om één eigenschap uit elk element te halen.

Beantwoord dit in de interactieve les

Samenvatting: sleutelpaden in verzamelingen

Je hebt gezien hoe sleutelpaden code voor verzamelingen beknopt maken:

map(\.property) projecteert één veld zonder closure.
filter(\.boolProperty) werkt rechtstreeks voor Bool-velden; gebruik voor andere velden een closure met [keyPath:].
Sorteren en max en min lezen de eigenschap via een sleutelpad binnen hun vergelijkingsclosures.
Algemene hulpen die een KeyPath accepteren, maken sorteren en filteren op een veld tot herbruikbare bewerkingen van één regel.

Vervolgens leer je over beschrijfbare sleutelpaden, waarmee je waarden kunt instellen in plaats van ze alleen te lezen.

struct Person { let name: String; let age: Int }

let people = [Person(name: "Ana", age: 30), Person(name: "Ben", age: 25)]
let youngestFirst = people.sorted { $0[keyPath: \Person.age] < $1[keyPath: \Person.age] }
print(youngestFirst.map(\.name))

Gratis beginnen

Leer Swift met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 122
Lessen: 409

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “KeyPaths gebruiken in collecties” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Swift Academy, waaronder “KeyPaths gebruiken in collecties”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Swift Academy bevat in totaal 4 lessen.

Wat leer ik in “KeyPaths gebruiken in collecties”?

Sorteer collecties en pas map toe met een key path. Je oefent met Swift Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Swift Academy te beginnen?

Ervaring vooraf is niet nodig. Swift Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “KeyPaths gebruiken in collecties”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Swift Academy?

Ja. Elke les over Swift Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Swift Academy