0Pricing
Swift Academy · Pelajaran

KeyPath yang Dapat Ditulis dan Referensi

Baca dan tulis melalui jalur kunci.

KeyPath yang Dapat Ditulis dan Referensi adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 3 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.

Jalur Kunci Hanya-Baca vs Jalur Kunci yang Dapat Ditulis

KeyPath biasa hanya dapat membaca nilai. Untuk menulis melalui jalur kunci, Anda memerlukan varian yang dapat ditulis. Swift memiliki dua jenis: satu untuk tipe nilai dan satu untuk tipe referensi.

Pelajaran ini membahas WritableKeyPath untuk struktur dan ReferenceWritableKeyPath untuk kelas, serta cara subskrip [keyPath:] menjadi dapat diatur nilainya.

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

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

WritableKeyPath untuk Tipe Nilai

WritableKeyPath menunjuk ke properti tersimpan yang dapat diubah dari suatu tipe nilai. Untuk mengaturnya melalui jalur kunci, instansnya sendiri harus berupa var, karena mengubah properti struktur berarti mengubah seluruh nilainya.

Gunakan subskrip [keyPath:] di sisi kiri penugasan 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 Instans Harus Berupa var

Untuk tipe nilai, penulisan melalui jalur kunci mengubah salinan secara langsung. Jika instansnya berupa let, tidak ada yang dapat diubah, sehingga penugasan tersebut tidak akan berhasil dikompilasi.

Aturan ini sama seperti perubahan properti biasa: Anda hanya dapat mengatur properti tersimpan suatu struktur ketika struktur tersebut disimpan dalam sebuah variabel.

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)

Fungsi Pembantu Penyetel Generik

Karena jalur kunci yang dapat ditulis menyimpan informasi tentang properti yang harus diubah, Anda dapat menulis fungsi generik yang memperbarui properti apa pun dari tipe nilai apa pun. Teruskan instans sebagai inout agar perubahannya ditulis kembali.

Inilah dasar dari berbagai utilitas kecil untuk pembaruan fungsional.

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. Karena instans kelas merupakan referensi, Anda dapat menulis melaluinya bahkan ketika instans tersebut disimpan dalam konstanta let; referensinya tidak berubah, hanya objek yang ditunjuknya yang berubah.

Inilah perbedaan utama dari jalur kunci yang dapat ditulis untuk tipe nilai.

class Counter {
    var value: Int = 0
}

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

Referensi Konstan, Objek yang Dapat Diubah

Perhatikan bahwa instans kelas di bawah ini berupa let, tetapi kita tetap dapat mengatur propertinya melalui jalur kunci. Dengan struktur, hal ini akan menjadi kesalahan kompilasi.

Itu karena mengubah properti kelas tidak mengharuskan referensinya dapat diubah, melainkan hanya propertinya.

class Profile {
    var nickname: String = ""
}

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

Hierarki Tipe Jalur Kunci

Tipe jalur kunci yang dapat ditulis membentuk sebuah hierarki. ReferenceWritableKeyPath adalah subtipe dari WritableKeyPath, yang merupakan subtipe dari KeyPath. Jadi, jalur kunci yang lebih spesifik dapat digunakan di mana pun jalur kunci yang lebih umum diharapkan.

Artinya, Anda dapat meneruskan ReferenceWritableKeyPath ke 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))

Memperbarui Tipe Nilai Bertingkat

Jalur kunci yang dapat ditulis dapat dirangkai melalui struktur bertingkat. Menetapkan properti yang sangat dalam akan menulis ulang setiap nilai yang membungkusnya hingga ke atas rantai, semuanya dalam satu penugasan.

Di sini kita mengubah kota di dalam alamat bertingkat.

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)

Menerapkan Banyak Pembaruan

Karena jalur kunci yang dapat ditulis merupakan nilai, Anda dapat menyimpan daftar pembaruan sebagai pasangan jalur kunci dan nilai, lalu menerapkannya dalam perulangan. Ini adalah sistem penerapan perubahan kecil.

Di sini kita menerapkan dua perubahan pada struktur pengaturan.

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 Bergaya Pengikatan

Salah satu penggunaan nyata yang umum adalah fungsi pembantu configure yang mengatur properti pada objek yang baru dibuat dan mengembalikan objek tersebut, sehingga memungkinkan gaya berantai. Dengan kelas, cara ini dapat digunakan pada hasil let.

Di sini kita mengatur teks label melalui jalur kunci referensi yang dapat ditulis.

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 Tipe Jalur Kunci yang Tepat

Gunakan KeyPath ketika Anda hanya membaca, WritableKeyPath untuk mengatur properti tipe nilai yang disimpan dalam var, dan ReferenceWritableKeyPath untuk mengatur properti kelas bahkan melalui let.

Memilih tipe paling spesifik yang sesuai membuat API Anda tetap jelas dalam menyatakan apakah API tersebut hanya membaca atau juga 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))

Pemeriksaan Singkat: Jalur Kunci yang Dapat Ditulis

Ingatlah tipe jalur kunci yang memungkinkan Anda mengatur properti kelas meskipun instansnya merupakan konstanta let.

Ringkasan: Jalur Kunci yang Dapat Ditulis dan Jalur Kunci Referensi

Anda telah mempelajari cara menulis melalui jalur kunci:

  • WritableKeyPath mengatur properti tersimpan dari tipe nilai dan memerlukan instans var.
  • ReferenceWritableKeyPath mengatur properti kelas dan tetap berfungsi melalui let.
  • Subskrip [keyPath:] muncul di sisi kiri penugasan untuk menulis nilai.
  • Tipe-tipe tersebut membentuk hierarki, sehingga jalur kunci yang dapat ditulis dapat digunakan sebagai pengganti jalur kunci hanya-baca.
  • Penyetel generik inout dan fungsi pembantu configure dibangun berdasarkan konsep-konsep ini.

Selanjutnya Anda akan melihat @dynamicMemberLookup, yang menggunakan jalur kunci untuk menyediakan akses dengan sintaks titik ke dalam data dinamis.

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

Pertanyaan yang Sering Diajukan

Apakah pelajaran “KeyPath yang Dapat Ditulis dan Referensi” gratis?

Ya — teks lengkap “KeyPath yang Dapat Ditulis dan Referensi” 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 “KeyPath yang Dapat Ditulis dan Referensi”?

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

Berapa lama pelajaran “KeyPath yang Dapat Ditulis dan Referensi” 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

  1. Dasar-Dasar KeyPath
  2. Menggunakan KeyPaths dalam Koleksi
  3. KeyPath yang Dapat Ditulis dan Referensi
  4. @dynamicMemberLookup
← Kembali ke Swift Academy