Swift Academy · Pelajaran

KeyPath Boleh Tulis dan Rujukan

Baca dan tulis melalui laluan kunci.

Pelajaran 3 daripada 413 langkah

KeyPath Boleh Tulis dan Rujukan ialah pelajaran Swift Academy percuma di CoddyKit. Ini ialah pelajaran 3 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.

Laluan Kunci Baca Sahaja berbanding Boleh Tulis

KeyPath biasa hanya boleh membaca nilai. Untuk menulis melalui laluan kunci, anda memerlukan varian boleh tulis. Swift mempunyai dua varian: satu untuk jenis nilai dan satu lagi untuk jenis rujukan.

Pelajaran ini merangkumi WritableKeyPath untuk struktur dan ReferenceWritableKeyPath untuk kelas, serta cara subskrip [keyPath:] menjadi boleh ditetapkan.

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

let writable: WritableKeyPath<Person, Int> = \Person.age
print(type(of: writable))

WritableKeyPath untuk Jenis Nilai

WritableKeyPath menyasarkan sifat tersimpan yang boleh diubah bagi jenis nilai. Untuk menetapkan nilai melaluinya, tika itu sendiri mestilah pemboleh ubah, kerana mengubah sifat struktur turut mengubah keseluruhan nilai.

Gunakan subskrip [keyPath:] di sebelah kiri tugasan untuk menulis nilai.

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

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

Mengapa Tika Mesti Boleh Diubah

Untuk jenis nilai, penulisan melalui laluan kunci mengubah salinan di tempatnya. Jika tika itu tidak boleh diubah, tiada apa-apa yang boleh diubah, jadi tugasan tersebut tidak akan dikompil.

Peraturan ini sama seperti pengubahan sifat biasa: anda hanya boleh menetapkan sifat tersimpan struktur apabila struktur itu disimpan dalam pemboleh ubah.

struct Point {
    var x: Int
    var y: Int
}

var p = Point(x: 1, y: 2)
p[keyPath: \Point.x] = 10
p[keyPath: \Point.y] = 20
print(p)

Pembantu Generik untuk Penetap

Oleh sebab laluan kunci boleh tulis menyimpan maklumat tentang sifat yang hendak diubah, anda boleh menulis fungsi generik yang mengemas kini sebarang sifat bagi sebarang jenis nilai. Hantar tika itu sebagai inout supaya perubahan ditulis semula.

Inilah asas utiliti kemas kini berfungsi yang kecil.

func update<Root, Value>(_ root: inout Root, _ path: WritableKeyPath<Root, Value>, to value: Value) {
    root[keyPath: path] = value
}

struct Person { var name: String; var age: Int }
var bob = Person(name: "Bob", age: 40)
update(&bob, \.age, to: 41)
print(bob.age)

ReferenceWritableKeyPath untuk Kelas

Untuk kelas, Swift menyediakan ReferenceWritableKeyPath. Oleh sebab tika kelas ialah rujukan, anda boleh menulis melaluinya walaupun tika itu disimpan dalam pemalar let; rujukan itu tidak berubah, hanya objek yang ditunjuknya berubah.

Inilah perbezaan utama daripada laluan kunci boleh tulis untuk jenis nilai.

class Counter {
    var value: Int = 0
}

let counter = Counter()
let path: ReferenceWritableKeyPath<Counter, Int> = \Counter.value
counter[keyPath: path] = 5
print(counter.value)

Rujukan Kekal, Objek Boleh Diubah

Perhatikan bahawa tika kelas di bawah ialah pemalar let, namun kita masih boleh menetapkan sifatnya melalui laluan kunci. Dengan struktur, ini akan menjadi ralat pengompilan.

Hal ini demikian kerana mengubah sifat kelas tidak memerlukan rujukan itu boleh diubah, sebaliknya hanya sifat tersebut yang perlu boleh diubah.

class Profile {
    var nickname: String = ""
}

let profile = Profile()
let nickPath = \Profile.nickname
profile[keyPath: nickPath] = "Ace"
print(profile.nickname)

Hierarki Jenis Laluan Kunci

Jenis laluan kunci boleh tulis membentuk satu hierarki. ReferenceWritableKeyPath ialah subjenis WritableKeyPath, yang pula merupakan subjenis KeyPath. Oleh itu, laluan kunci yang lebih khusus boleh digunakan di mana-mana laluan yang lebih umum dijangka.

Ini bermakna anda boleh menghantar ReferenceWritableKeyPath kepada fungsi yang hanya perlu membaca melalui KeyPath.

class Box { var size: Int = 1 }

func readSize(_ box: Box, _ path: KeyPath<Box, Int>) -> Int {
    box[keyPath: path]
}

let writable: ReferenceWritableKeyPath<Box, Int> = \Box.size
print(readSize(Box(), writable))

Mengemas Kini Jenis Nilai Bersarang

Laluan kunci boleh tulis boleh dirangkaikan melalui struktur bersarang. Menetapkan sifat yang sangat bersarang akan membina semula setiap nilai yang mengandunginya sepanjang rantaian, semuanya dalam satu tugasan.

Di sini, kita menukar bandar di dalam alamat bersarang.

struct Address { var city: String }
struct Person { var name: String; var address: Address }

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

Menggunakan Banyak Kemas Kini

Oleh sebab laluan kunci boleh tulis ialah nilai, anda boleh menyimpan senarai kemas kini sebagai pasangan laluan kunci dan nilai, kemudian menggunakannya dalam gelung. Ini ialah sistem tampalan kecil.

Di sini, kita menggunakan dua perubahan pada struktur tetapan.

struct Settings { var volume: Int; var brightness: Int }

var settings = Settings(volume: 5, brightness: 5)
func apply(_ s: inout Settings, _ path: WritableKeyPath<Settings, Int>, _ v: Int) {
    s[keyPath: path] = v
}
apply(&settings, \.volume, 8)
apply(&settings, \.brightness, 3)
print(settings)

Konfigurasi Gaya Pengikatan

Kegunaan biasa dalam dunia sebenar ialah pembantu configure yang menetapkan sifat pada objek yang baru dicipta dan mengembalikannya, sekali gus membolehkan gaya yang lancar. Dengan kelas, cara ini boleh digunakan pada hasil let.

Di sini, kita menetapkan teks label melalui laluan kunci rujukan boleh tulis.

class Label { var text: String = "" }

func configure<T: AnyObject, V>(_ object: T, _ path: ReferenceWritableKeyPath<T, V>, _ value: V) -> T {
    object[keyPath: path] = value
    return object
}

let label = configure(Label(), \.text, "Hello")
print(label.text)

Memilih Jenis Laluan Kunci yang Tepat

Gunakan KeyPath apabila anda hanya membaca, WritableKeyPath untuk menetapkan sifat jenis nilai yang disimpan dalam pemboleh ubah, dan ReferenceWritableKeyPath untuk menetapkan sifat kelas walaupun melalui pemalar let.

Memilih jenis paling khusus yang sesuai menjadikan API anda jelas tentang sama ada ia hanya membaca atau turut mengubah.

struct S { var n: Int }
class C { var n: Int = 0 }

let read: KeyPath<S, Int> = \S.n
let writeStruct: WritableKeyPath<S, Int> = \S.n
let writeClass: ReferenceWritableKeyPath<C, Int> = \C.n
print(type(of: read), type(of: writeStruct), type(of: writeClass))

Semakan Pantas: Laluan Kunci Boleh Tulis

Ingat jenis laluan kunci yang membolehkan anda menetapkan sifat kelas walaupun tika itu ialah pemalar let.

Jawab dalam pelajaran interaktif

Imbas Kembali: Laluan Kunci Boleh Tulis dan Rujukan

Anda telah mempelajari cara menulis melalui laluan kunci:

WritableKeyPath menetapkan sifat tersimpan bagi jenis nilai dan memerlukan tika pemboleh ubah.
ReferenceWritableKeyPath menetapkan sifat kelas dan berfungsi walaupun melalui let.
Subskrip [keyPath:] muncul di sebelah kiri tugasan untuk menulis nilai.
Jenis-jenis ini membentuk hierarki, jadi laluan kunci boleh tulis boleh menggantikan laluan kunci baca sahaja.
Penetap generik inout dan pembantu configure dibina berdasarkan ciri-ciri ini.

Seterusnya, anda akan melihat @dynamicMemberLookup, yang menggunakan laluan kunci untuk menawarkan capaian menggunakan sintaks titik kepada data dinamik.

struct Person { var name: String; var age: Int }

var dave = Person(name: "Dave", age: 27)
dave[keyPath: \Person.age] = 28
print("Updated age: \(dave.age)")

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 “KeyPath Boleh Tulis dan Rujukan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Swift Academy, termasuk “KeyPath Boleh Tulis dan Rujukan”, 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 “KeyPath Boleh Tulis dan Rujukan”?

Baca dan tulis melalui laluan kunci. 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 3 daripada 4.

Berapa lamakah pelajaran “KeyPath Boleh Tulis dan Rujukan” 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