Swift Academy · Ders

Yazılabilir ve Başvuru KeyPaths'leri

Anahtar yolları üzerinden okuyun ve yazın.

Yazılabilir ve Başvuru KeyPaths'leri, CoddyKit'te ücretsiz bir Swift Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Swift Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Swift Academy kursu toplamda 4 dersten oluşur.

Salt Okunur ve Yazılabilir Anahtar Yolları

Yalın bir KeyPath yalnızca bir değeri okuyabilir. Bir anahtar yolu üzerinden yazmak için yazılabilir bir türe ihtiyacınız vardır. Swift'te biri değer türleri, diğeri referans türleri için olmak üzere iki yazılabilir tür bulunur.

Bu derste yapılar için WritableKeyPath, sınıflar için ReferenceWritableKeyPath ve [keyPath:] alt indisinin nasıl atanabilir hâle geldiği ele alınır.

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

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

Değer Türleri için WritableKeyPath

Bir WritableKeyPath, bir değer türünün değiştirilebilir depolanmış özelliğini hedefler. Bu yol üzerinden değer atamak için örneğin kendisi bir var olmalıdır; çünkü bir yapı özelliğini değiştirmek değerin tamamını değiştirir.

Yazmak için atamanın sol tarafında [keyPath:] alt indisini kullanın.

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)

Örneğin Neden var Olması Gerekir

Değer türlerinde bir anahtar yolu üzerinden yazmak, bir kopyayı yerinde değiştirir. Örnek bir let ise değiştirilecek bir şey yoktur; bu nedenle atama derlenmez.

Bu kural, normal özellik değişikliğiyle aynıdır: Bir yapının depolanmış özelliğini yalnızca yapı bir değişkende tutuluyorsa ayarlayabilirsiniz.

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)

Genel Bir Ayarlayıcı Yardımcı

Yazılabilir bir anahtar yolu hangi özelliğin değiştirileceğini içerdiğinden, herhangi bir değer türünün herhangi bir özelliğini güncelleyen genel bir işlev yazabilirsiniz. Değişikliğin geri yazılması için örneği inout olarak geçirin.

Bu, küçük işlevsel güncelleme araçlarının temelini oluşturur.

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)

Sınıflar için ReferenceWritableKeyPath

Sınıflar için Swift, ReferenceWritableKeyPath sağlar. Bir sınıf örneği referans olduğundan, örnek bir let sabitinde tutulsa bile onun üzerinden yazabilirsiniz; değişen referans değil, referansın gösterdiği nesnedir.

Değer türleri için yazılabilir anahtar yollarından temel fark budur.

class Counter {
    var value: Int = 0
}

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

let Referansı, Değiştirilebilir Nesne

Aşağıdaki sınıf örneğinin bir let olduğunu, yine de anahtar yolu üzerinden özelliğini ayarlayabildiğimizi fark ediniz. Bir yapıyla bu işlem derleme hatası verirdi.

Bunun nedeni, bir sınıf özelliğini değiştirmenin referansın değiştirilebilir olmasını değil, yalnızca özelliğin kendisinin değiştirilebilir olmasını gerektirmesidir.

class Profile {
    var nickname: String = ""
}

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

Anahtar Yollarının Tür Hiyerarşisi

Yazılabilir anahtar yolu türleri bir hiyerarşi oluşturur. ReferenceWritableKeyPath, WritableKeyPath türünün; WritableKeyPath ise KeyPath türünün alt türüdür. Bu nedenle daha özel bir anahtar yolu, daha genel bir anahtar yolunun beklendiği her yerde kullanılabilir.

Bu, yalnızca bir KeyPath aracılığıyla okuma gerektiren bir işleve ReferenceWritableKeyPath geçebileceğiniz anlamına gelir.

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

İç İçe Değer Türlerini Güncelleme

Yazılabilir anahtar yolları, iç içe yapıların içinden zincirlenebilir. Derinlerdeki bir özelliği ayarlamak, her kapsayıcı değeri zincir boyunca yeniden yazar ve bunu tek bir atamayla yapar.

Burada iç içe bir adresin içindeki şehri değiştiriyoruz.

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)

Birçok Güncelleme Uygulama

Yazılabilir anahtar yolları değer olduğundan, güncellemelerin listesini anahtar yolu ve değer çiftleri olarak saklayabilir ve bunları bir döngüde uygulayabilirsiniz. Bu, küçük bir yama sistemidir.

Burada bir ayar yapısına iki değişiklik uyguluyoruz.

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)

Bağlama Tarzı Yapılandırma

Yaygın bir gerçek dünya kullanımı, yeni oluşturulmuş bir nesnenin özelliğini ayarlayıp nesneyi geri döndüren bir yapılandırma yardımcısıdır; bu, akıcı bir kullanım tarzı sağlar. Sınıflarda bu işlem bir let sonucu üzerinde çalışır.

Burada bir etiketin metnini, başvuru yazılabilir anahtar yolu aracılığıyla ayarlıyoruz.

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)

Doğru Anahtar Yolu Türünü Seçme

Yalnızca okuma yapıyorsanız KeyPath kullanın; bir var içinde tutulan değer türünün özelliğini ayarlamak için WritableKeyPath, bir sınıfın özelliğini let üzerinden bile ayarlamak için ReferenceWritableKeyPath kullanın.

Uyan en özel türü seçmek, API'lerinizin okuma mı yoksa değiştirme mi yaptığını doğru biçimde belirtmesini sağlar.

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

Hızlı Kontrol: Yazılabilir Anahtar Yolları

Örnek bir let sabiti olsa bile sınıf özelliğini ayarlamanızı sağlayan anahtar yolu türünü hatırlayınız.

Özet: Yazılabilir ve Başvuru Anahtar Yolları

Anahtar yolları üzerinden nasıl yazacağınızı öğrendiniz:

WritableKeyPath, bir değer türünün depolanmış özelliğini ayarlar ve var türünde bir örnek gerektirir.
ReferenceWritableKeyPath, bir sınıfın özelliğini ayarlar ve let üzerinden bile çalışır.
[keyPath:] alt indisi, yazmak için bir atamanın sol tarafında görünür.
Türler bir hiyerarşi oluşturur; bu nedenle yazılabilir bir anahtar yolu salt okunur bir anahtar yolunun yerine kullanılabilir.
Genel inout ayarlayıcılar ve yapılandırma yardımcıları bunların üzerine kuruludur.

Sırada, anahtar yollarını kullanarak dinamik verilere nokta sözdizimiyle erişim sunan @dynamicMemberLookup özelliğini göreceksiniz.

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

Sıkça Sorulan Sorular

“Yazılabilir ve Başvuru KeyPaths'leri” dersi ücretsiz mi?

Evet — “Yazılabilir ve Başvuru KeyPaths'leri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Swift Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Swift Academy kursu toplamda 4 dersten oluşur.

“Yazılabilir ve Başvuru KeyPaths'leri” dersinde ne öğreneceğim?

Anahtar yolları üzerinden okuyun ve yazın. Swift Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Swift Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Swift Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Yazılabilir ve Başvuru KeyPaths'leri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Swift Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Swift Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Swift Academy Sayfasına Dön