Swift Academy · Pelajaran

Dasar-Dasar KeyPath

Gunakan referensi properti sebagai nilai kelas satu.

Dasar-Dasar KeyPath adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Swift Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Swift Academy mencakup 4 pelajaran total.

Apa Itu Jalur Kunci?

Jalur kunci adalah nilai yang menjelaskan jalur menuju sebuah properti tanpa benar-benar mengaksesnya. Anggaplah ini sebagai referensi tersimpan yang dapat digunakan kembali untuk properti mana yang Anda inginkan, terpisah dari instans mana tempat Anda membacanya.

Anda menulis jalur kunci dengan garis miring terbalik, nama tipe, titik, dan nama properti. Swift memberikan nilai KeyPath pada ekspresi ini, yang dapat Anda teruskan seperti nilai lainnya.

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

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

Membaca Nilai

Untuk membaca properti melalui jalur kunci, gunakan subskrip [keyPath:] pada sebuah instans. Anda meneruskan jalur kunci di dalam tanda kurung siku, lalu Swift mengembalikan nilai pada jalur tersebut.

Ini adalah padanan saat program berjalan dari menulis nama properti secara langsung, tetapi sekarang properti dipilih berdasarkan data, bukan ditetapkan langsung dalam kode.

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

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

Sintaks Jalur Kunci secara Mendetail

Bentuk umumnya adalah notasi escape garis miring terbalik, lalu tipe akar, titik, dan nama properti. Garis miring terbalik memberi sinyal kepada Swift bahwa Anda menginginkan jalur kunci, bukan nilai properti.

Tipe akar adalah tipe tempat jalur dimulai. Tipe hasil adalah tipe properti terakhir. Jadi, jalur dari Person ke properti age memiliki akar Person dan nilai 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])

Merangkai Melalui Properti Bertingkat

Jalur kunci dapat menelusuri nilai yang bertingkat. Jika sebuah properti sendiri merupakan struktur, Anda dapat melanjutkan jalur dengan titik lain untuk mencapai properti yang lebih dalam.

Seluruh rangkaian tersebut tetap merupakan satu nilai jalur kunci, dan tipe akar serta hasilnya mencerminkan awal dan akhir rangkaian.

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

Menyimpan Jalur Kunci dalam Variabel

Karena jalur kunci hanyalah sebuah nilai, Anda dapat menyimpannya dalam variabel, mengembalikannya dari fungsi, atau menyimpan koleksi jalur kunci. Dengan demikian, Anda dapat menentukan properti mana yang akan dibaca saat program berjalan.

Di sini kita memilih salah satu dari dua jalur kunci yang tersimpan berdasarkan flag.

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

Swift memiliki kelompok kecil tipe jalur kunci. KeyPath<Root, Value> mengetahui kedua ujungnya. PartialKeyPath<Root> mengetahui akarnya, tetapi menghilangkan tipe nilainya. AnyKeyPath menghilangkan keduanya.

Semakin banyak informasi tipe yang Anda pertahankan, semakin banyak hal yang dapat diperiksa oleh kompiler untuk Anda. Gunakan bentuk parsial atau umum hanya ketika Anda benar-benar perlu mencampurkan jalur dengan tipe nilai yang berbeda.

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

Singkatan dalam Tipe yang Diketahui

Ketika tipe akar sudah diketahui dari konteks, Anda dapat menghilangkan nama tipe dan cukup menulis garis miring terbalik, titik, dan properti. Kompiler menyimpulkan akarnya.

Singkatan ini membuat titik pemanggilan tetap ringkas, terutama di dalam operasi koleksi ketika tipe elemen sudah jelas.

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

Jalur Kunci sebagai Argumen Fungsi

Pola yang umum adalah fungsi generik yang menerima jalur kunci dan menerapkannya pada banyak instans. Ini memisahkan apa yang Anda baca dari logika yang melakukan pembacaan.

Di sini, pembantu generik mengekstrak properti apa pun dari tipe apa pun dalam daftar orang.

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

Jalur Kunci dan Properti Terhitung

Jalur kunci hanya baca juga berfungsi dengan properti terhitung. Jalur tersebut menyimpan perhitungannya, sehingga membaca melalui jalur itu akan menjalankan pengambilnya.

Artinya, jalur kunci tidak terbatas pada properti tersimpan; properti apa pun yang dapat dibaca memenuhi syarat.

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

Jalur Kunci Identitas

Ada jalur kunci khusus yang merujuk pada seluruh nilai itu sendiri, ditulis sebagai garis miring terbalik tunggal yang diikuti titik dan self. Membaca melalui jalur ini mengembalikan instans tanpa perubahan.

Jalur ini berguna ketika sebuah API mengharapkan jalur kunci tetapi Anda menginginkan elemennya apa adanya, seperti saat mengurutkan angka berdasarkan nilainya sendiri.

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

Membandingkan Jalur Kunci

Jalur kunci bersifat Hashable dan Equatable. Dua jalur kunci yang menunjuk ke properti yang sama dengan tipe yang sama dianggap setara, sehingga Anda dapat menyimpannya dalam himpunan atau menggunakannya sebagai kunci kamus.

Ini berguna untuk membuat tabel yang memetakan properti ke label atau pemformat.

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

Pemeriksaan Cepat: Membaca melalui Jalur Kunci

Uji pemahaman Anda tentang cara membaca properti melalui jalur kunci.

Rangkuman: Dasar-Dasar Jalur Kunci

Anda telah mempelajari dasar-dasar jalur kunci:

Jalur kunci ditulis dengan garis miring terbalik, tipe akar, titik, dan nama properti, serta menjelaskan sebuah properti tanpa membacanya.
Baca nilai menggunakan subskrip [keyPath:] pada sebuah instans.
Jalur dapat dirangkai ke properti bertingkat dan menargetkan properti terhitung.
KeyPath, PartialKeyPath, dan AnyKeyPath menukar keamanan tipe dengan fleksibilitas.
Jalur kunci adalah nilai: simpan, teruskan, bandingkan, dan gunakan sebagai kunci kamus.

Selanjutnya, Anda akan menggunakan jalur kunci untuk membuat operasi koleksi jauh lebih ringkas.

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

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Dasar-Dasar KeyPath” gratis?

Ya — teks lengkap “Dasar-Dasar KeyPath” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Swift Academy, upgrade ke CoddyKit PRO. Kursus Swift Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Dasar-Dasar KeyPath”?

Gunakan referensi properti sebagai nilai kelas satu. Kamu berlatih Swift Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Swift Academy?

Tidak diperlukan pengalaman sebelumnya. Swift Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Dasar-Dasar KeyPath” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Dasar-Dasar KeyPath
Menggunakan KeyPaths dalam Koleksi
KeyPath yang Dapat Ditulis dan Referensi
@dynamicMemberLookup

← Kembali ke Swift Academy