Swift Academy · Lektion

Grundlagen von KeyPaths

Behandeln Sie Eigenschaften als Werte erster Klasse.

Grundlagen von KeyPaths ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Was ist ein Key Path?

Ein Key Path ist ein Wert, der einen Pfad zu einer Eigenschaft beschreibt, ohne auf diese tatsächlich zuzugreifen. Stellen Sie ihn sich als gespeicherte, wiederverwendbare Referenz darauf vor, welche Eigenschaft Sie benötigen – getrennt davon, aus welcher Instanz Sie sie lesen.

Sie schreiben einen Key Path mit einem Backslash, dem Typnamen, einem Punkt und dem Eigenschaftsnamen. Swift gibt diesem Ausdruck einen KeyPath-Wert, den Sie wie jeden anderen Wert weitergeben können.

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

let nameKeyPath = \Person.name
print(type(of: nameKeyPath))

Einen Wert lesen

Um eine Eigenschaft über einen Key Path zu lesen, verwenden Sie den Subscript [keyPath:] einer Instanz. Übergeben Sie den Key Path in den eckigen Klammern, und Swift gibt den Wert an diesem Pfad zurück.

Das ist das Laufzeit-Gegenstück dazu, den Eigenschaftsnamen direkt zu schreiben. Nun wird die Eigenschaft jedoch anhand von Daten statt fest im Code ausgewählt.

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

let alice = Person(name: "Alice", age: 30)
let path = \Person.name
print(alice[keyPath: path])

Die Syntax von Key Paths im Detail

Die allgemeine Form besteht aus dem Backslash, dem Root-Typ, einem Punkt und dem Eigenschaftsnamen. Der Backslash signalisiert Swift, dass Sie einen Key Path und nicht den Wert der Eigenschaft erstellen möchten.

Der Root-Typ ist der Typ, von dem der Pfad ausgeht. Der Ergebnistyp ist der Typ der letzten Eigenschaft. Ein Pfad von Person zu seiner Eigenschaft age hat also den Root-Typ Person und den Werttyp Int.

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

let ageKeyPath: KeyPath<Person, Int> = \Person.age
let bob = Person(name: "Bob", age: 42)
print(bob[keyPath: ageKeyPath])

Durch verschachtelte Eigenschaften navigieren

Key Paths können in verschachtelte Werte hineinreichen. Wenn eine Eigenschaft selbst eine Struktur ist, können Sie den Pfad mit einem weiteren Punkt fortsetzen, um eine tiefer liegende Eigenschaft zu erreichen.

Die gesamte Kette ist weiterhin ein einzelner Key-Path-Wert. Sein Root- und Ergebnistyp entsprechen dem Anfang und dem Ende der Kette.

struct Address {
    let city: String
}
struct Person {
    let name: String
    let address: Address
}

let cityPath = \Person.address.city
let carol = Person(name: "Carol", address: Address(city: "Oslo"))
print(carol[keyPath: cityPath])

Key Paths in Variablen speichern

Da ein Key Path einfach ein Wert ist, können Sie ihn in einer Variablen speichern, aus einer Funktion zurückgeben oder eine Sammlung von Key Paths anlegen. So können Sie zur Laufzeit entscheiden, welche Eigenschaft gelesen werden soll.

Hier wählen wir anhand eines Flags einen von zwei gespeicherten Key Paths aus.

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

let showAge = true
let chosen: PartialKeyPath<Person> = showAge ? \Person.age : \Person.name
let dave = Person(name: "Dave", age: 27)
print(dave[keyPath: chosen])

PartialKeyPath und AnyKeyPath

Swift bietet eine kleine Familie von Key-Path-Typen. KeyPath<Root, Value> kennt beide Enden. PartialKeyPath<Root> kennt den Root-Typ, blendet aber den Werttyp aus. AnyKeyPath blendet beide aus.

Je mehr Typinformationen Sie beibehalten, desto mehr kann der Compiler für Sie prüfen. Verwenden Sie die partiellen oder allgemeinen Formen nur, wenn Sie tatsächlich Key Paths mit unterschiedlichen Werttypen mischen müssen.

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

let paths: [PartialKeyPath<Person>] = [\.name, \.age]
let eve = Person(name: "Eve", age: 19)
for p in paths {
    print(eve[keyPath: p])
}

Kurzform bei bekanntem Typ

Wenn der Root-Typ bereits aus dem Kontext bekannt ist, können Sie den Typnamen weglassen und nur den Backslash, einen Punkt und die Eigenschaft schreiben. Der Compiler leitet den Root-Typ ab.

Diese Kurzform hält Aufrufstellen kompakt, insbesondere innerhalb von Collection-Operationen, bei denen der Elementtyp offensichtlich ist.

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

func value(of person: Person, at path: KeyPath<Person, Int>) -> Int {
    person[keyPath: path]
}

let frank = Person(name: "Frank", age: 55)
print(value(of: frank, at: \.age))

Key Paths als Funktionsargumente

Ein häufig verwendetes Muster ist eine generische Funktion, die einen Key Path akzeptiert und ihn auf viele Instanzen anwendet. Dadurch wird was Sie lesen, von der Logik getrennt, die den Lesevorgang ausführt.

Hier extrahiert eine generische Hilfsfunktion aus einer Personenliste eine beliebige Eigenschaft eines beliebigen Typs.

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

func extract<T>(_ people: [Person], _ path: KeyPath<Person, T>) -> [T] {
    people.map { $0[keyPath: path] }
}

let people = [Person(name: "Ana", age: 21), Person(name: "Ben", age: 34)]
print(extract(people, \.name))
print(extract(people, \.age))

Key Paths und berechnete Eigenschaften

Schreibgeschützte Key Paths funktionieren auch mit berechneten Eigenschaften. Der Pfad kapselt die Berechnung, sodass beim Lesen über den Key Path der Getter ausgeführt wird.

Ein Key Path ist daher nicht auf gespeicherte Eigenschaften beschränkt; jede lesbare Eigenschaft kommt infrage.

struct Rectangle {
    let width: Double
    let height: Double
    var area: Double { width * height }
}

let areaPath = \Rectangle.area
let r = Rectangle(width: 3, height: 4)
print(r[keyPath: areaPath])

Identitäts-Key-Path

Es gibt einen speziellen Key Path, der den gesamten Wert selbst bezeichnet. Er wird als einzelner Backslash gefolgt von einem Punkt und self geschrieben. Beim Lesen über diesen Key Path wird die Instanz unverändert zurückgegeben.

Das ist praktisch, wenn eine API einen Key Path erwartet, Sie aber das Element unverändert verwenden möchten, etwa um Zahlen nach ihrem eigenen Wert zu sortieren.

let numbers = [3, 1, 2]
let identity = \Int.self
for n in numbers {
    print(n[keyPath: identity])
}

Key Paths vergleichen

Key Paths sind Hashable und Equatable. Zwei Key Paths, die auf dieselbe Eigenschaft desselben Typs verweisen, sind gleich. Daher können Sie sie in Sets speichern oder als Schlüssel für Dictionaries verwenden.

Das ist nützlich, um Tabellen zu erstellen, die eine Eigenschaft einer Bezeichnung oder einem Formatter zuordnen.

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

let labels: [PartialKeyPath<Person>: String] = [
    \Person.name: "Full Name",
    \Person.age: "Years Old"
]
print(labels[\Person.age] ?? "unknown")

Kurzer Check: Lesen über einen Key Path

Testen Sie Ihr Verständnis davon, wie Sie eine Eigenschaft über einen Key Path lesen.

Zusammenfassung: Grundlagen der Key Paths

Sie haben die Grundlagen der Key Paths gelernt:

Ein Key Path wird mit einem Backslash, dem Root-Typ, einem Punkt und einem Eigenschaftsnamen geschrieben. Er beschreibt eine Eigenschaft, ohne sie zu lesen.
Lesen Sie einen Wert mit dem Subscript [keyPath:] einer Instanz.
Key Paths können in verschachtelte Eigenschaften hineinreichen und auf berechnete Eigenschaften verweisen.
KeyPath, PartialKeyPath und AnyKeyPath tauschen Typsicherheit gegen Flexibilität.
Key Paths sind Werte: Sie können sie speichern, weitergeben, vergleichen und als Dictionary-Schlüssel verwenden.

Als Nächstes verwenden Sie Key Paths, um Collection-Operationen deutlich kompakter zu schreiben.

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

let path = \Person.age
let gina = Person(name: "Gina", age: 48)
print("Read via key path: \(gina[keyPath: path])")

Häufig gestellte Fragen

Ist die Lektion „Grundlagen von KeyPaths“ kostenlos?

Ja — der vollständige Text von „Grundlagen von KeyPaths“ 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 „Grundlagen von KeyPaths“?

Behandeln Sie Eigenschaften als Werte erster Klasse. 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 1 von 4.

Wie lange dauert die Lektion „Grundlagen von KeyPaths“?

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

← Zurück zu Swift Academy