Swift Academy · Pelajaran

Asas KeyPath

Rujuk sifat sebagai nilai kelas pertama.

Pelajaran 1 daripada 413 langkah

Asas KeyPath ialah pelajaran Swift Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Swift Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Swift Academy merangkumi sejumlah 4 pelajaran.

Apakah Laluan Kunci?

Laluan kunci ialah nilai yang menerangkan laluan kepada sesuatu sifat tanpa mengaksesnya. Anggaplah ia sebagai rujukan tersimpan yang boleh digunakan semula kepada sifat yang mana Anda inginkan, berasingan daripada kejadian yang mana sifat itu dibaca.

Anda menulis laluan kunci dengan tanda garis condong terbalik, nama jenis, titik dan nama sifat. Swift memberikan nilai KeyPath kepada ungkapan ini, yang boleh Anda hantarkan seperti mana-mana nilai lain.

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

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

Membaca Nilai

Untuk membaca sifat melalui laluan kunci, gunakan subskrip [keyPath:] pada sesuatu kejadian. Anda menghantar laluan kunci di dalam kurungan siku dan Swift mengembalikan nilai pada laluan tersebut.

Ini ialah padanan semasa jalan kepada penulisan nama sifat secara terus, tetapi kini sifat itu dipilih berdasarkan data dan bukannya ditetapkan dalam kod.

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

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

Sintaks Laluan Kunci secara Terperinci

Bentuk umumnya ialah tanda pelepasan garis condong terbalik, diikuti jenis akar, titik dan nama sifat. Garis condong terbalik memberitahu Swift bahawa Anda mahukan laluan kunci dan bukannya nilai sifat.

Jenis akar ialah jenis tempat laluan bermula. Jenis hasil ialah jenis sifat terakhir. Jadi, laluan daripada Person kepada sifat age mempunyai 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 Sifat Bersarang

Laluan kunci boleh menyusuri nilai bersarang. Jika sesuatu sifat itu sendiri ialah struktur, Anda boleh meneruskan laluan dengan titik lain untuk mencapai sifat yang lebih dalam.

Keseluruhan rangkaian itu masih merupakan satu nilai laluan kunci, dan jenis akar serta hasilnya mencerminkan permulaan dan penghujung 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 Laluan Kunci dalam Pemboleh Ubah

Oleh sebab laluan kunci hanyalah nilai, Anda boleh menyimpannya dalam pemboleh ubah, mengembalikannya daripada fungsi atau menyimpan koleksi laluan kunci. Dengan ini, Anda boleh menentukan sifat yang hendak dibaca semasa program berjalan.

Di sini, kami memilih salah satu daripada dua laluan kunci yang disimpan berdasarkan bendera.

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 mempunyai sekumpulan kecil jenis laluan kunci. KeyPath<Root, Value> mengetahui kedua-dua hujungnya. PartialKeyPath<Root> mengetahui akarnya tetapi memadamkan jenis nilainya. AnyKeyPath memadamkan kedua-duanya.

Lebih banyak maklumat jenis yang Anda kekalkan, lebih banyak perkara yang boleh diperiksa oleh pengkompil untuk Anda. Gunakan bentuk separa atau umum hanya apabila Anda benar-benar perlu mencampurkan laluan dengan jenis nilai yang berbeza.

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

Ringkasan dalam Jenis yang Diketahui

Apabila jenis akar sudah diketahui daripada konteks, Anda boleh menggugurkan nama jenis itu dan hanya menulis garis condong terbalik, titik serta sifat. Pengkompil membuat kesimpulan tentang akarnya.

Ringkasan ini memendekkan tapak panggilan, khususnya dalam operasi koleksi apabila jenis 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))

Laluan Kunci sebagai Argumen Fungsi

Corak yang biasa ialah fungsi generik yang menerima laluan kunci dan menggunakannya pada banyak kejadian. Ini mengasingkan perkara yang Anda baca daripada logik yang melakukan pembacaan.

Di sini, pembantu generik mengekstrak sebarang sifat daripada sebarang jenis dalam senarai 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))

Laluan Kunci dan Sifat Terhitung

Laluan kunci baca sahaja juga berfungsi dengan sifat terhitung. Laluan itu menangkap pengiraan, jadi pembacaan melaluinya akan menjalankan pengambil.

Ini bermakna laluan kunci tidak terhad kepada sifat tersimpan; sebarang sifat yang boleh dibaca juga layak digunakan.

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

Laluan Kunci Identiti

Terdapat laluan kunci khas yang merujuk kepada keseluruhan nilai itu sendiri, ditulis sebagai garis condong terbalik tunggal diikuti titik dan self. Membaca melaluinya mengembalikan kejadian tanpa perubahan.

Ia berguna apabila API memerlukan laluan kunci tetapi Anda mahukan elemen itu seadanya, seperti ketika mengisih nombor berdasarkan nombor itu sendiri.

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

Membandingkan Laluan Kunci

Laluan kunci mematuhi Hashable dan Equatable. Dua laluan kunci yang merujuk kepada sifat yang sama bagi jenis yang sama adalah setara, jadi Anda boleh menyimpannya dalam set atau menggunakannya sebagai kunci kamus.

Ini berguna untuk membina jadual yang memetakan sifat kepada 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")

Semakan Pantas: Membaca melalui Laluan Kunci

Uji pemahaman Anda tentang cara membaca sifat melalui laluan kunci.

Jawab dalam pelajaran interaktif

Ringkasan: Asas Laluan Kunci

Anda telah mempelajari asas laluan kunci:

Laluan kunci ditulis dengan garis condong terbalik, jenis akar, titik dan nama sifat, serta menerangkan sifat tanpa membacanya.
Baca nilai menggunakan subskrip [keyPath:] pada sesuatu kejadian.
Laluan boleh dirangkai ke dalam sifat bersarang dan menyasarkan sifat terhitung.
KeyPath, PartialKeyPath dan AnyKeyPath menukar keselamatan jenis demi fleksibiliti.
Laluan kunci ialah nilai: simpan, hantarkan, bandingkan dan gunakannya sebagai kunci kamus.

Seterusnya, Anda akan menggunakan laluan kunci untuk menjadikan 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])")

Percuma untuk bermula

Pelajari Swift dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 122
Pelajaran: 409

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Asas KeyPath” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Swift Academy, termasuk “Asas KeyPath”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Swift Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Asas KeyPath”?

Rujuk sifat sebagai nilai kelas pertama. Anda berlatih Swift Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Swift Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Swift Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Asas KeyPath” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Swift Academy