Swift Academy · Leçon

Bases de KeyPath

Référencez des propriétés comme des valeurs de première classe.

Bases de KeyPath est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Qu’est-ce qu’un chemin de clé ?

Un chemin de clé est une valeur qui décrit le chemin vers une propriété sans y accéder réellement. Considérez-le comme une référence enregistrée et réutilisable à quelle propriété vous voulez accéder, indépendamment de quelle instance vous la lisez.

Vous écrivez un chemin de clé avec une barre oblique inverse, le nom du type, un point et le nom de la propriété. Swift attribue à cette expression une valeur KeyPath que vous pouvez transmettre comme n’importe quelle autre valeur.

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

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

Lire une valeur

Pour lire une propriété au moyen d’un chemin de clé, utilisez le sous-script [keyPath:] sur une instance. Vous placez le chemin de clé entre les crochets et Swift renvoie la valeur située à ce chemin.

C’est l’équivalent à l’exécution de l’écriture directe du nom de la propriété, mais la propriété est maintenant choisie à partir de données plutôt que codée en dur.

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

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

Syntaxe détaillée des chemins de clés

La forme générale consiste en une barre oblique inverse d’échappement, suivie du type racine, d’un point, puis du nom de la propriété. La barre oblique inverse indique à Swift que vous voulez un chemin de clé plutôt que la valeur de la propriété.

Le type racine est le type à partir duquel le chemin commence. Le type résultat est celui de la propriété finale. Ainsi, un chemin allant de Person à sa propriété age a pour racine Person et pour valeur 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])

Parcourir des propriétés imbriquées

Les chemins de clés peuvent accéder à des valeurs imbriquées. Si une propriété est elle-même une structure, vous pouvez poursuivre le chemin avec un autre point pour atteindre une propriété plus profonde.

L’ensemble de la chaîne reste une seule valeur de chemin de clé, dont les types racine et résultat correspondent au début et à la fin de la chaîne.

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])

Stocker des chemins de clés dans des variables

Comme un chemin de clé n’est qu’une valeur, vous pouvez le stocker dans une variable, le renvoyer depuis une fonction ou conserver une collection de chemins de clés. Vous pouvez ainsi décider à l’exécution quelle propriété lire.

Ici, nous choisissons l’un de deux chemins de clés stockés en fonction d’un indicateur.

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 et AnyKeyPath

Swift possède une petite famille de types de chemins de clés. KeyPath<Root, Value> connaît les deux extrémités. PartialKeyPath<Root> connaît la racine, mais efface le type de la valeur. AnyKeyPath efface les deux.

Plus vous conservez d’informations de type, plus le compilateur peut effectuer de vérifications à votre place. N’utilisez les formes partielles ou générales que lorsque vous devez réellement mélanger des chemins dont les types de valeurs diffèrent.

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])
}

Notation abrégée dans un type connu

Lorsque le type racine est déjà connu grâce au contexte, vous pouvez omettre son nom et écrire simplement la barre oblique inverse, un point et la propriété. Le compilateur déduit la racine.

Cette notation abrégée raccourcit les points d’appel, notamment dans les opérations sur les collections où le type de l’élément est évident.

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))

Chemins de clés comme arguments de fonction

Un modèle courant consiste à utiliser une fonction générique qui accepte un chemin de clé et l’applique à plusieurs instances. Cela sépare ce que vous lisez de la logique qui effectue la lecture.

Ici, un utilitaire générique extrait n’importe quelle propriété de n’importe quel type depuis une liste de personnes.

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))

Chemins de clés et propriétés calculées

Les chemins de clés en lecture seule fonctionnent également avec les propriétés calculées. Le chemin capture le calcul ; sa lecture exécute donc l’accesseur.

Un chemin de clé ne se limite donc pas aux propriétés stockées : toute propriété lisible convient.

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])

Chemin de clé d’identité

Il existe un chemin de clé spécial qui désigne la valeur entière elle-même. Il s’écrit avec une simple barre oblique inverse suivie d’un point et de self. Sa lecture renvoie l’instance sans la modifier.

Il est pratique lorsqu’une API attend un chemin de clé, mais que vous voulez conserver l’élément tel quel, par exemple pour trier des nombres selon leur propre valeur.

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

Comparer des chemins de clés

Les chemins de clés peuvent être hachés et comparés. Deux chemins de clés qui désignent la même propriété du même type sont égaux ; vous pouvez donc les stocker dans des ensembles ou les utiliser comme clés de dictionnaire.

C’est utile pour créer des tableaux qui associent une propriété à une étiquette ou à un formateur.

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

Vérification rapide : lire via un chemin de clé

Vérifiez votre compréhension de la lecture d’une propriété au moyen d’un chemin de clé.

Récapitulatif : notions de base des chemins de clés

Vous avez appris les bases des chemins de clés :

Un chemin de clé s’écrit avec une barre oblique inverse, le type racine, un point et le nom d’une propriété ; il décrit une propriété sans la lire.
Lisez une valeur à l’aide du sous-script [keyPath:] sur une instance.
Les chemins peuvent se prolonger dans des propriétés imbriquées et cibler des propriétés calculées.
KeyPath, PartialKeyPath et AnyKeyPath offrent différents compromis entre sécurité des types et flexibilité.
Les chemins de clés sont des valeurs : stockez-les, transmettez-les, comparez-les et utilisez-les comme clés de dictionnaire.

Ensuite, vous utiliserez les chemins de clés pour rendre les opérations sur les collections beaucoup plus concises.

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

Questions Fréquemment Posées

La leçon « Bases de KeyPath » est-elle gratuite ?

Oui — le texte complet de « Bases de KeyPath » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Bases de KeyPath » ?

Référencez des propriétés comme des valeurs de première classe. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Bases de KeyPath » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Swift Academy