Swift泛型类数组创建难题：除any外的替代方案？

针对你遇到的泛型类数组存储问题，除了Swift 5.7的any关键字，还有以下几种实用方案，既能存储所有Base<T>类型实例，又能保证类型安全：

方案1：用非泛型协议抽象公共接口 #

创建一个非泛型协议，定义你需要在数组中访问的公共属性/方法，让Base<T>遵守该协议，以此作为数组的元素类型：

import Foundation

protocol Value {
    var humanized: String? { get }
}

class AValue: Value {
    var humanized: String? { nil }
}

class AbstractType<T: CustomStringConvertible>: AValue {
    let value: T
    init(_ v: T) {
        self.value = v
    }
    override var humanized: String {
        value.description
    }
}

class Bol: AbstractType<Bool> { }
class Doub: AbstractType<Double> { }

// 定义非泛型协议，暴露需要的公共能力
protocol BaseProtocol {
    var firstHumanizedValue: String? { get }
}

class Base<T: AValue>: BaseProtocol {
    var values: [T]?
    
    // 实现协议方法，封装泛型属性的访问逻辑
    var firstHumanizedValue: String? {
        values?.first?.humanized
    }
}

// 数组类型改为协议类型
var a = [BaseProtocol]()

class Lab: Base<Doub> { }
class Condition: Base<Bol> { }

let b = Bol(true)
let d = Doub(1.1)
let bb = Condition()
bb.values = [b]
let dd = Lab()
dd.values = [d]

// 现在可以正常添加实例了
a.append(bb)
a.append(dd)

for item in a {
    print(item.firstHumanizedValue) // 输出 Optional("true")、Optional("1.1")
}

这种方式通过协议统一了不同Base<T>实例的公共行为，同时保证只有符合要求的类型才能加入数组，完全满足你"仅允许精确类型"的需求。

方案2：使用类型擦除包装器 #

创建一个类型擦除的包装类，把任意Base<T>实例包裹起来，对外暴露统一的接口，不需要修改原有的Base类结构：

// 沿用你原有的Value、AValue、AbstractType、Bol、Doub、Base等定义，此处省略重复代码

class AnyBase {
    private let _getFirstHumanized: () -> String?
    
    // 接收任意Base<T>实例，捕获其属性访问逻辑
    init<T: AValue>(_ base: Base<T>) {
        _getFirstHumanized = { base.values?.first?.humanized }
    }
    
    // 对外暴露统一的访问入口
    var firstHumanizedValue: String? {
        _getFirstHumanized()
    }
}

// 数组类型改为包装类类型
var a = [AnyBase]()

// 添加实例时用包装器包裹
a.append(AnyBase(bb))
a.append(AnyBase(dd))

for item in a {
    print(item.firstHumanizedValue)
}

这种方案适合无法修改原Base类的场景，通过包装器实现类型统一，同时保留对泛型实例属性的访问能力。

关键原理说明 #

Swift的泛型类是不变类型——哪怕Bol是AValue的子类，Base<Bol>也不是Base<AValue>的子类。这是Swift的类型安全设计：如果允许Base<Bol>赋值给Base<AValue>，就可能出现往values里添加Doub实例的情况，导致运行时崩溃。

所以所有方案的核心都是抽象公共行为，而非直接依赖泛型类型本身，以此绕开泛型不变性带来的限制。

内容的提问来源于stack exchange，提问作者jasonIM