PricingLoginStart free
Swift Academy · 课时

@dynamicMemberLookup

构建动态且类型安全的成员访问。

第 4 / 4 课13 个步骤

@dynamicMemberLookup 是 CoddyKit 上的免费 Swift Academy 课时。 这是第 4 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Swift Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Swift Academy 课程共包含 4 节课。

什么是动态成员查找

@dynamicMemberLookup 特性允许类型响应点语法成员访问，即使该成员并未声明为真正的属性。当您编写 value.something 时，Swift 会将其转发到您定义的特殊下标。

这样，包装器类型可以拥有自然的使用体验，同时将访问逻辑集中在一个地方。

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

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

必需的下标

标记为 @dynamicMemberLookup 的类型必须实现 subscript(dynamicMember:)。当参数类型为 String 时，您输入的成员名称会在运行时变成该字符串。

因此，config.timeout 会使用键 "timeout" 调用这个下标。

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

基于字符串的查找不具备类型安全性

基于字符串的动态成员查找很灵活，但会失去编译时检查。如果成员名称拼写错误，代码仍然可以编译，而您会得到下标针对缺失键返回的任何结果。

在下面的示例中，未知成员会静默返回默认值，而不是导致构建失败。

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

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

使用键路径实现类型安全的查找

为了提高安全性，您可以让下标接收 KeyPath 而不是字符串。这样，编译器就会验证被包装类型上是否存在该成员，同时仍然转发访问，从而恢复完整的类型检查。

对于保存强类型值的包装器类型来说，这种模式非常理想。

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)

为什么键路径版本更安全

由于下标接收 KeyPath<User, T>，因此只允许使用 User 中实际存在的成员。像 boxed.naem 这样的拼写错误现在会导致编译失败，而字符串版本不会。

您可以享受点语法的便利，同时完全避免这种风险。

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)

可写的动态成员

如果下标提供设置器并接收 WritableKeyPath，您还可以为转发的成员赋值。包装器会将写入操作直接传递给被包装的值。

这样就能构建一个透明的可变包装器。

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)

转发到被包装的对象

动态成员查找非常适合轻量级代理：它们主要将访问转发给内部值，同时添加少量行为。下标会将转发逻辑集中在一个地方。

这里的日志包装器会转发读取操作，并输出被访问的成员。

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)

与动态可调用思想结合

动态成员查找与泛型结合得很好。一个通用下标就可以转发任意属性类型，因此同一个 Proxy 可以服务于形态各异的 values。

这里无论成员是 String 还是 Int，同一个 Proxy 都可以正常工作。

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 数据的字符串查找

字符串形式仍有其适用场景：表示解析后的 JSON 等结构不固定的数据，因为成员在编译时是未知的。每次访问都会变成一次字典查找。

这里，一个小型的类 JSON 值通过点语法公开其 fields。

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

需要注意的限制

动态成员查找只会影响成员访问语法；它不会添加真正的存储属性。自动补全等工具支持键路径形式，但不支持任意字符串键。

只要底层结构已知，就应优先使用键路径版本；字符串版本则应保留给真正动态的数据。

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)

实用装饰器

综合起来，下面是一个经过实际考量的包装器：它会将每次属性读取转发给内部值，同时统计访问次数。实际框架会将这一思想用于观测和跟踪。

包装器上的点语法与直接使用该值时的体验完全相同。

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)

快速检查：类型安全的动态查找

回想一下：哪个下标参数可以让动态成员查找具备类型安全性？

在交互式课程中回答

回顾：动态成员查找

您已经学习了 @dynamicMemberLookup 的工作方式：

  • 该特性会将未声明的点语法访问转发到 subscript(dynamicMember:)。
  • 使用 String 参数可以实现灵活但不受检查的访问，非常适合类似 JSON 的数据。
  • 使用 KeyPath 参数可以恢复完整的类型安全和代码自动补全。
  • 带有设置器的 WritableKeyPath 可以让您通过包装器转发写入操作。
  • 这是一种语法便利功能，与代理和装饰器模式天然搭配。

现在，您已经掌握了完整的键路径工具集：读取、写入、集合使用和动态转发。

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)
免费开始

用 AI 导师学习 Swift — 免费

在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。

课程
122
课程
409
免费开始学习查看完整课程

常见问题解答

「@dynamicMemberLookup」课时是免费的吗？

是的 — 「@dynamicMemberLookup」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Swift Academy 课程的其余内容，请升级到 CoddyKit PRO。 Swift Academy 课程共包含 4 节课。

「@dynamicMemberLookup」这节课中我会学到什么？

构建动态且类型安全的成员访问。 你通过在浏览器中直接运行的动手代码来练习 Swift Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Swift Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Swift Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 4 节课，共 4 节。

「@dynamicMemberLookup」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Swift Academy 课中编写并运行代码吗？

能。每节 Swift Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. KeyPath 基础
  2. 在集合中使用 KeyPaths
  3. 可写键路径与引用键路径
  4. @dynamicMemberLookup
← 返回 Swift Academy