扩展

是什么，为什么存在

Swift 扩展是在类型原始声明之外补充功能的声明。它能扩展类、结构体、枚举和协议，也能扩展标准库或依赖库中的类型。扩展声明的成员在调用点表现为该类型的成员，而不是需要额外包装对象的工具函数。

扩展解决了两个不同问题。对于自己维护的类型，它能按职责拆分实现，例如把协议遵循与核心状态分开。对于不能修改源码的类型，它能添加适合当前模块的便捷操作，或让该类型遵循当前模块定义的协议。

扩展可以添加以下声明：

• 计算实例属性和计算类型属性；
• 实例方法和类型方法，包括值类型的 mutating 方法；
• 构造器、下标与嵌套类型；
• 协议遵循，以及满足协议要求的实现。

扩展不会重新打开类型的存储布局。它不能添加存储属性或属性观察器，也不能添加析构器、覆盖已有实现或为类增加父类。类扩展只能添加便利构造器，不能添加指定构造器。

当一个行为需要新的状态、不变量或独立身份时，包装类型通常比扩展更合适。扩展适合从接收者现有状态计算结果，或把已有能力组织成更清楚的接口；它不是绕过类型设计边界的后门。

工作原理

扩展使用 extension TypeName 声明。编译器在类型检查时把可见的扩展成员纳入成员查找，但原类型声明和扩展仍可能位于不同文件或模块。调用方必须导入声明扩展的模块，扩展才在该源文件中可见。

扩展成员遵循普通的访问控制。与原类型位于同一文件的扩展可以访问该类型的 private 成员；移动到另一文件后，这种访问不再成立。给扩展标记访问级别，会为其中未显式标记的成员提供默认访问级别，但不能突破原声明的可见性。

受约束扩展把成员的可用性与类型条件绑定。extension Array where Element == String 只给字符串数组添加成员；Element: Hashable 则接受任何满足该协议的元素类型。这种 条件遵循（conditional conformance） 或条件成员不会在运行时试探条件，编译器会在调用点证明约束是否满足。

协议扩展有两类成员，分派规则不同。如果成员本来就是协议要求，扩展可以提供默认实现，具体类型自己的实现会作为协议见证（protocol witness）参与调用。如果成员只存在于扩展中，通过协议类型访问时会根据静态类型选择扩展实现；具体类型中的同名方法不是覆盖。

协议遵循是整个进程可见的关系，不是局部别名。当扩展同时为其他模块的类型遵循其他模块的协议时，就形成 追溯遵循（retroactive conformance） 。Swift 6 会对此给出警告，因为任一上游模块以后加入同一遵循，都可能造成冲突；@retroactive 只表示你明确接受风险，不会消除风险。

示例

下面三个独立程序依次展示普通成员、条件能力和协议扩展分派。每段代码都只依赖 Swift 标准库，可以直接保存为文件并运行。

为现有状态添加计算与修改操作

Temperature 保留摄氏温度作为唯一存储。扩展从该状态计算华氏温度，并用 mutating 方法更新值；集合扩展则利用已有的 indices 提供安全下标。

计算属性没有为每个实例增加新字段，fahrenheit 每次都从 celsius 求值。clamp 必须标记为 mutating，因为它修改结构体的 self。通用下标使用集合自己的 Index，所以不仅适用于以 Int 为索引的数组。

安全下标不会替代所有越界错误。有些 API 的索引失效表示调用方破坏了不变量，此时返回 nil 反而会掩盖缺陷。只有“位置可能不存在”本来就是契约的一部分时，才应提供这种可选结果。

用条件扩展表达能力

Batch 对所有元素类型都能报告是否为空。只有元素可比较时，它才提供 contains 并遵循 Equatable，因此调用点不需要运行时转换。

struct Batch<Element> {
    let values: [Element]
}

extension Batch {
    enum State {
        case empty
        case ready
    }

    var state: State {
        values.isEmpty ? .empty : .ready
    }
}

extension Batch where Element: Equatable {
    func contains(_ candidate: Element) -> Bool {
        values.contains(candidate)
    }
}

extension Batch: Equatable where Element: Equatable {}

let first = Batch(values: ["A-1", "B-2"])
let second = Batch(values: ["A-1", "B-2"])
print(first.contains("B-2"))
print(first == second)

switch first.state {
case .empty: print("empty")
case .ready: print("ready")
}

true
true
ready

空状态不依赖 Element 的能力，所以它属于无条件扩展。contains 需要相等比较，约束只放在提供该方法的扩展上。Equatable 遵循也带有相同条件，Batch<NonEquatable> 因而仍可使用，只是不能比较。

嵌套的 State 名称属于 Batch 的命名空间，但它不捕获外层泛型实参。若嵌套类型本身需要保存 Element，应在自己的存储或泛型声明中明确表达，而不是假定外层实例存在。

区分协议要求与扩展成员

render() 是协议要求，debugLabel() 只由扩展添加。Audit 为两者都声明同名实现后，协议类型上的两个调用表现不同。

protocol Reportable {
    var title: String { get }
    func render() -> String
}

extension Reportable {
    func render() -> String {
        "Default: \(title)"
    }

    func debugLabel() -> String {
        "[report] \(title)"
    }
}

struct Audit: Reportable {
    let title: String

    func render() -> String {
        "Audit: \(title)"
    }

    func debugLabel() -> String {
        "[audit] \(title)"
    }
}

let concrete = Audit(title: "Access")
let erased: any Reportable = concrete
print(erased.render())
print(concrete.debugLabel())
print(erased.debugLabel())

Audit: Access
[audit] Access
[report] Access

erased.render() 使用 Audit 的实现，因为 render 是协议要求，遵循记录保存了对应见证。concrete.debugLabel() 根据具体静态类型找到 Audit 的成员。erased.debugLabel() 的静态类型只有 any Reportable，因此选择协议扩展成员。

如果调用方需要每个遵循类型自定义 debugLabel()，就应把它加入协议声明，并在扩展中保留默认实现。仅仅给具体类型写一个同名方法，不会把扩展成员变成协议要求。

添加构造器与嵌套类型

扩展构造器仍必须完成原类型的全部初始化规则。下面的扩展调用结构体已有的成员构造器，而嵌套枚举只负责描述从现有存储计算出的形状。

struct Rectangle {
    let width: Int
    let height: Int
}

extension Rectangle {
    enum Shape {
        case square
        case oblong
    }

    init(square side: Int) {
        self.init(width: side, height: side)
    }

    var shape: Shape {
        width == height ? .square : .oblong
    }
}

extension Rectangle: CustomStringConvertible {
    var description: String {
        "\(width)x\(height)"
    }
}

let tile = Rectangle(square: 4)
let banner = Rectangle(width: 8, height: 3)
print(tile)
print(banner)

switch tile.shape {
case .square: print("square")
case .oblong: print("oblong")
}

4x4
8x3
square

把自定义构造器放进扩展后，结构体原有的成员构造器仍可在这里使用，调用方也能继续调用它。若把自定义构造器写进原始结构体声明，编译器是否合成成员构造器的规则会不同，因此移动代码不只是排版变化。

把 CustomStringConvertible 遵循放在单独扩展中，可以让类型的核心存储与格式化契约保持清楚。协议遵循仍然是类型身份的一部分，不会因为声明被放在另一段源码中就变成可选功能。

陷阱

用计算属性伪装存储

修复方法： 状态属于类型不变量时，把它放回原类型；无法修改原类型时，创建拥有该状态的包装类型。只有平台互操作已有明确所有权和清理契约时，才考虑专用的关联存储机制。

把同名方法当作覆盖

修复方法： 类层次需要覆盖时，在原类声明中提供可覆盖成员。协议需要多态选择时，把成员声明为协议要求，再用扩展提供默认实现；同时测试具体值和 any Protocol 值两条调用路径。

让约束覆盖面过大

修复方法： 把约束放在最窄的扩展或成员上。无条件能力留在基础声明中，依赖哈希、排序或并发安全的能力分别放进自己的受约束扩展。

污染公共命名空间

修复方法： 公共库应优先扩展自己拥有的类型或协议。确需扩展外部类型时，使用能表达领域含义的名称，并把扩展的访问级别控制在最小范围；命名空间包装器适合成组的应用专用操作。

随意声明追溯遵循

修复方法： 优先定义包装类型，或定义当前模块拥有的窄协议。确实必须声明追溯遵循时，用 @retroactive 明确接受责任，记录语义与迁移计划，并在依赖升级时检查重复遵循。

移动扩展后假定语义不变

修复方法： 移动前先检查私有访问与合成遵循。优先把需要实现细节的扩展留在同一文件；确需跨文件时，显式提供实现，或只在确有模块级调用方时谨慎放宽访问级别。

延伸阅读

• Swift 编程语言：扩展
• Swift 编程语言：协议
• Swift 编程语言：泛型
• Swift Evolution SE-0143：条件遵循
• Swift Evolution SE-0364：追溯遵循警告
• Swift 6.3 发布说明