Podstawy KeyPath
Traktowanie właściwości jako wartości pierwszej klasy.
Podstawy KeyPath to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.
Czym jest ścieżka klucza
Ścieżka klucza to wartość opisująca drogę do właściwości bez faktycznego uzyskiwania do niej dostępu. Można myśleć o niej jak o przechowywanym, wielokrotnego użytku odwołaniu wskazującym, którą właściwość wybrać, niezależnie od tego, z której instancji jest ona odczytywana.
Ścieżkę klucza zapisuje się za pomocą ukośnika odwrotnego, nazwy typu, kropki i nazwy właściwości. Swift nadaje temu wyrażeniu wartość typu KeyPath, którą można przekazywać tak jak każdą inną wartość.
struct Person {
let name: String
let age: Int
}
let nameKeyPath = \Person.name
print(type(of: nameKeyPath))Odczytywanie wartości
Aby odczytać właściwość za pomocą ścieżki klucza, należy użyć subskryptu [keyPath:] na instancji. Ścieżkę klucza przekazuje się w nawiasach kwadratowych, a Swift zwraca wartość znajdującą się na końcu tej ścieżki.
Jest to odpowiednik bezpośredniego zapisania nazwy właściwości wykonywany w czasie działania, ale teraz właściwość jest wybierana na podstawie danych, a nie zapisana na stałe w kodzie.
struct Person {
let name: String
let age: Int
}
let alice = Person(name: "Alice", age: 30)
let path = \Person.name
print(alice[keyPath: path])Szczegółowa składnia ścieżek kluczy
Ogólna postać obejmuje zapis z ukośnikiem odwrotnym, następnie typ główny, kropkę i nazwę właściwości. Ukośnik odwrotny informuje Swift, że chodzi o ścieżkę klucza, a nie o wartość właściwości.
Typ główny to typ, od którego rozpoczyna się ścieżka. Typ wyniku to typ końcowej właściwości. Ścieżka od Person do właściwości age ma więc typ główny Person i typ wartości 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])Łączenie zagnieżdżonych właściwości
Ścieżki kluczy mogą zagłębiać się w zagnieżdżone wartości. Jeśli właściwość jest strukturą, można kontynuować ścieżkę, dodając kolejną kropkę, aby dotrzeć do głębiej położonej właściwości.
Cały łańcuch nadal jest pojedynczą wartością ścieżki klucza, a jego typ główny i typ wyniku odpowiadają początkowi i końcowi łańcucha.
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])Przechowywanie ścieżek kluczy w zmiennych
Ponieważ ścieżka klucza jest zwykłą wartością, można przechowywać ją w zmiennej, zwracać z funkcji lub przechowywać kolekcję ścieżek kluczy. Pozwala to zdecydować w czasie działania, którą właściwość odczytać.
W tym przypadku jedna z dwóch przechowywanych ścieżek kluczy jest wybierana na podstawie flagi.
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 i AnyKeyPath
Swift udostępnia niewielką rodzinę typów ścieżek kluczy. KeyPath<Root, Value> zna oba końce ścieżki. PartialKeyPath<Root> zna typ główny, ale usuwa informację o typie wartości. AnyKeyPath usuwa informacje o obu typach.
Im więcej informacji o typie zostanie zachowanych, tym więcej kompilator może sprawdzić. Po formy częściowe lub ogólne należy sięgać tylko wtedy, gdy rzeczywiście trzeba łączyć ścieżki o różnych typach wartości.
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])
}Skrócona składnia w znanym typie
Gdy typ główny jest już znany z kontekstu, można pominąć nazwę typu i zapisać tylko ukośnik odwrotny, kropkę oraz właściwość. Kompilator wywnioskuje typ główny.
Ta skrócona składnia pozwala skrócić miejsca wywołań, szczególnie w operacjach na kolekcjach, w których typ elementu jest oczywisty.
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))Ścieżki kluczy jako argumenty funkcji
Często stosuje się funkcję generyczną, która przyjmuje ścieżkę klucza i wykorzystuje ją dla wielu instancji. Oddziela to to, co jest odczytywane, od logiki wykonującej odczyt.
W tym przypadku generyczna funkcja pomocnicza wyodrębnia dowolną właściwość dowolnego typu z listy osób.
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))Ścieżki kluczy i właściwości obliczane
Ścieżki kluczy tylko do odczytu działają również z właściwościami obliczanymi. Ścieżka przechwytuje obliczenie, więc odczyt za jej pomocą uruchamia getter.
Oznacza to, że ścieżka klucza nie ogranicza się do właściwości przechowywanych — może wskazywać dowolną właściwość, którą można odczytać.
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])Ścieżka klucza tożsamości
Istnieje specjalna ścieżka klucza odwołująca się do całej wartości, zapisywana jako samotny zapis \., po którym następuje self. Odczyt za jej pomocą zwraca instancję bez zmian.
Jest przydatna, gdy API wymaga ścieżki klucza, ale potrzebna jest wartość elementu bez modyfikacji, na przykład podczas sortowania liczb według nich samych.
let numbers = [3, 1, 2]
let identity = \Int.self
for n in numbers {
print(n[keyPath: identity])
}Porównywanie ścieżek kluczy
Ścieżki kluczy są zgodne z Hashable i Equatable. Dwie ścieżki kluczy wskazujące tę samą właściwość tego samego typu są równe, dlatego można przechowywać je w zbiorach lub używać ich jako kluczy słownika.
Jest to przydatne podczas tworzenia tabel mapujących właściwość na etykietę lub formatter.
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")Szybki test: odczytywanie za pomocą ścieżki klucza
Proszę sprawdzić zrozumienie odczytywania właściwości za pomocą ścieżki klucza.
Podsumowanie: podstawy ścieżek kluczy
Poznali Państwo podstawy ścieżek kluczy:
- Ścieżkę klucza zapisuje się za pomocą ukośnika odwrotnego, typu głównego, kropki i nazwy właściwości; opisuje ona właściwość bez jej odczytywania.
- Wartość można odczytać za pomocą subskryptu
[keyPath:]na instancji. - Ścieżki mogą zagłębiać się w zagnieżdżone właściwości i wskazywać właściwości obliczane.
KeyPath,PartialKeyPathiAnyKeyPathstanowią kompromis między bezpieczeństwem typów a elastycznością.- Ścieżki kluczy są wartościami: można je przechowywać, przekazywać, porównywać i używać jako kluczy słownika.
Następnie wykorzystają Państwo ścieżki kluczy, aby znacznie uprościć operacje na kolekcjach.
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])")Często zadawane pytania
Czy lekcja „Podstawy KeyPath” jest bezpłatna?
Tak — pełny tekst „Podstawy KeyPath” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Podstawy KeyPath”?
Traktowanie właściwości jako wartości pierwszej klasy. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Swift Academy?
Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Podstawy KeyPath”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?
Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.