Swift Academy · Ders

@dynamicMemberLookup

Dinamik ve tür güvenli üye erişimi oluşturun.

4. ders / 413 adım

@dynamicMemberLookup, CoddyKit'te ücretsiz bir Swift Academy dersidir. Bu, 4 dersinin 4. 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.

Dinamik Üye Araması Nedir

@dynamicMemberLookup özelliği, bir türün gerçek bir özellik olarak tanımlanmamış nokta sözdizimli üye erişimine yanıt vermesini sağlar. value.something yazdığınızda Swift, bunu tanımladığınız özel bir alt indise yönlendirir.

Bu, sarmalayıcı türlerin doğal bir kullanım sunmasını sağlarken erişimi tek bir yerde tutar.

@dynamicMemberLookup
struct Settings {
    private var storage: [String: String] = ["theme": "dark"]
    subscript(dynamicMember key: String) -> String? {
        storage[key]
    }
}

let s = Settings()
print(s.theme ?? "none")

Gerekli Alt İndis

@dynamicMemberLookup ile işaretlenmiş bir tür, subscript(dynamicMember:) uygulamalıdır. Parametre bir String olduğunda, yazdığınız üye adı çalışma zamanında bu dizeye dönüşür.

Bu nedenle config.timeout, alt indisi "timeout" anahtarıyla çağırır.

@dynamicMemberLookup
struct Config {
    let values: [String: Int]
    subscript(dynamicMember member: String) -> Int {
        values[member] ?? 0
    }
}

let config = Config(values: ["timeout": 30, "retries": 3])
print(config.timeout)
print(config.retries)

Dize Araması Tür Güvenli Değildir

Dize tabanlı dinamik üye araması esnektir; ancak derleme zamanındaki denetimi kaybettirir. Bir üyenin adını yanlış yazarsanız kod yine de derlenir ve eksik anahtar için alt indis ne döndürüyorsa onu alırsınız.

Aşağıda bilinmeyen bir üye, derlemenin başarısız olması yerine sessizce varsayılan değeri döndürür.

@dynamicMemberLookup
struct Config {
    let values: [String: Int]
    subscript(dynamicMember member: String) -> Int {
        values[member] ?? -1
    }
}

let config = Config(values: ["timeout": 30])
print(config.tmout)

Anahtar Yollarıyla Tür Güvenli Arama

Güvenlik için alt indisin bir dize yerine KeyPath almasını sağlayabilirsiniz. Böylece derleyici, üyenin sarmalanan türde var olduğunu doğrular; erişimi yine yönlendirirken tam denetimi yeniden kazanırsınız.

Bu örüntü, güçlü türlendirilmiş bir değer tutan sarmalayıcı türler için idealdir.

struct User { let name: String; let age: Int }

@dynamicMemberLookup
struct Boxed {
    let user: User
    subscript<T>(dynamicMember path: KeyPath<User, T>) -> T {
        user[keyPath: path]
    }
}

let boxed = Boxed(user: User(name: "Ada", age: 36))
print(boxed.name)
print(boxed.age)

Anahtar Yolu Sürümü Neden Daha Güvenli

Alt indis bir KeyPath<User, T> aldığından yalnızca User üzerinde gerçekten var olan üyelere izin verilir. boxed.naem gibi bir yazım hatası, dize sürümünün aksine artık derlenmez.

Nokta sözdiziminin kolaylığını hiçbir risk olmadan elde edersiniz.

struct User { let name: String; let age: Int }

@dynamicMemberLookup
struct ReadOnly {
    let value: User
    subscript<T>(dynamicMember path: KeyPath<User, T>) -> T {
        value[keyPath: path]
    }
}

let r = ReadOnly(value: User(name: "Lin", age: 22))
print(r.name, r.age)

Yazılabilir Dinamik Üyeler

Alt indis bir ayarlayıcı sağlıyor ve WritableKeyPath alıyorsa, yönlendirilen üyelere de atama yapabilirsiniz. Sarmalayıcı, yazma işlemini doğrudan sarmalanan değere iletir.

Bu, saydam ve değiştirilebilir bir sarmalayıcı oluşturur.

struct Profile { var name: String; var score: Int }

@dynamicMemberLookup
struct Wrapper {
    var value: Profile
    subscript<T>(dynamicMember path: WritableKeyPath<Profile, T>) -> T {
        get { value[keyPath: path] }
        set { value[keyPath: path] = newValue }
    }
}

var w = Wrapper(value: Profile(name: "Mo", score: 0))
w.score = 99
print(w.value.score)

Sarmalanan Bir Nesneye Yönlendirme

Dinamik üye araması, çoğunlukla bir iç değere yönlendirme yapan ancak biraz da davranış ekleyen hafif vekiller için oldukça uygundur. Alt indis, yönlendirme mantığını tek bir yerde tutar.

Burada bir günlük kaydı sarmalayıcısı okumaları yönlendirir ve hangi üyeye erişildiğini yazdırır.

struct Account { let id: Int; let balance: Double }

@dynamicMemberLookup
struct Logged {
    let account: Account
    subscript<T>(dynamicMember path: KeyPath<Account, T>) -> T {
        let result = account[keyPath: path]
        print("accessed a member")
        return result
    }
}

let logged = Logged(account: Account(id: 7, balance: 100))
print(logged.balance)

Dinamik Çağrılabilirlik Fikirleriyle Birleştirme

Dinamik üye araması, genel türlerle iyi birleşir. Tek bir genel alt indis, her özellik türünü yönlendirebilir; böylece tek bir sarmalayıcı, farklı biçimlerdeki değerlerle çalışır.

Burada aynı Proxy, üye ister bir dize ister bir tamsayı olsun çalışır.

struct Item { let title: String; let count: Int }

@dynamicMemberLookup
struct Proxy<Wrapped> {
    let wrapped: Wrapped
    subscript<T>(dynamicMember path: KeyPath<Wrapped, T>) -> T {
        wrapped[keyPath: path]
    }
}

let proxy = Proxy(wrapped: Item(title: "Book", count: 4))
print(proxy.title, proxy.count)

JSON Benzeri Veriler için Dize Araması

Dize biçiminin hâlâ bir kullanım alanı vardır: üyelerin derleme zamanında bilinmediği, ayrıştırılmış JSON gibi gevşek yapılı verileri temsil etmek. Her erişim bir sözlük aramasına dönüşür.

Burada küçük bir JSON benzeri değer, alanlarını nokta sözdizimi aracılığıyla sunar.

@dynamicMemberLookup
struct JSON {
    let fields: [String: String]
    subscript(dynamicMember key: String) -> String {
        fields[key] ?? ""
    }
}

let json = JSON(fields: ["city": "Oslo", "country": "Norway"])
print(json.city)
print(json.country)

Akılda Tutulması Gereken Sınırlamalar

Dinamik üye araması yalnızca üye erişimi sözdizimini etkiler; gerçek depolanmış özellikler eklemez. Otomatik tamamlama gibi araçlar anahtar yolu biçimiyle çalışır, ancak rastgele dize anahtarlarıyla çalışmaz.

Temel yapı biliniyorsa anahtar yolu sürümünü tercih edin; dize sürümünü gerçekten dinamik veriler için saklayın.

struct Point { let x: Int; let y: Int }

@dynamicMemberLookup
struct Safe {
    let point: Point
    subscript<T>(dynamicMember path: KeyPath<Point, T>) -> T {
        point[keyPath: path]
    }
}

let safe = Safe(point: Point(x: 3, y: 4))
print(safe.x + safe.y)

Pratik Bir Süsleyici

Hepsini bir araya getirirsek, burada iç değerine yapılan her özellik okumasını yönlendirirken erişimleri sayan ölçümlü bir sarmalayıcı bulunuyor. Gerçek çerçeveler bu fikri gözlemleme ve izleme için kullanır.

Sarmalayıcı üzerindeki nokta sözdizimi, değeri doğrudan kullanmakla tamamen aynı hissettirir.

struct Sensor { let temperature: Double; let humidity: Double }

@dynamicMemberLookup
class Tracked {
    let sensor: Sensor
    var reads = 0
    init(_ s: Sensor) { sensor = s }
    subscript<T>(dynamicMember path: KeyPath<Sensor, T>) -> T {
        reads += 1
        return sensor[keyPath: path]
    }
}

let t = Tracked(Sensor(temperature: 21.5, humidity: 0.4))
print(t.temperature)
print(t.humidity)
print(t.reads)

Hızlı Kontrol: Tür Güvenli Dinamik Arama

Dinamik üye aramasını tür güvenli hâle getiren alt indis parametresini hatırlayınız.

İnteraktif derste cevapla

Özet: Dinamik Üye Araması

@dynamicMemberLookup özniteliğinin nasıl çalıştığını öğrendiniz:

Öznitelik, tanımlanmamış nokta sözdizimi erişimini subscript(dynamicMember:) özelliğine yönlendirir.
Bir String parametresi, JSON benzeri veriler için ideal olan esnek ancak denetlenmeyen erişim sağlar.
Bir KeyPath parametresi tam tür güvenliğini ve otomatik tamamlamayı geri getirir.
Ayarlayıcısı olan bir WritableKeyPath, yazma işlemlerini bir sarmalayıcı üzerinden iletmenizi sağlar.
Bu, vekil ve dekoratör kalıplarıyla doğal biçimde eşleşen bir sözdizimi kolaylığıdır.

Artık okuma, yazma, koleksiyon kullanımı ve dinamik iletme dahil olmak üzere eksiksiz anahtar yolu araç setine sahipsiniz.

struct User { let name: String }

@dynamicMemberLookup
struct Wrap {
    let user: User
    subscript<T>(dynamicMember path: KeyPath<User, T>) -> T {
        user[keyPath: path]
    }
}

print(Wrap(user: User(name: "Final")).name)

Başlamak ücretsiz

Yapay zeka eğitmeniyle Swift öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar: 122
Dersler: 409

Ücretsiz öğrenmeye başla Tüm kursu görüntüle

Sıkça Sorulan Sorular

“@dynamicMemberLookup” dersi ücretsiz mi?

Evet — “@dynamicMemberLookup” 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.

“@dynamicMemberLookup” dersinde ne öğreneceğim?

Dinamik ve tür güvenli üye erişimi oluşturun. 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 4. dersidir.

“@dynamicMemberLookup” 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