Swift 4中如何创建可存储任意Codable对象的Codable容器类？

嘿，这个问题我之前也踩过坑，Swift的Codable在做通用容器的时候确实容易遇到这种“不想重复造轮子”的困扰，不过用泛型或者带类型标识的方案就能完美解决你的需求，不用再写一堆重复的容器类或者强制所有类型继承基类！

方案一：泛型容器（最简洁，适合不需要混合类型的场景） #

这是最直接的解决方式，利用Swift的泛型特性，让容器类适配任意遵循Codable协议的类型，自动满足Codable要求：

class CodableContainer<T: Codable>: NSObject, Codable {
    var date: Date?
    var item: T?
    
    // 可选：显式定义CodingKeys，属性名和JSON字段一致时可省略，显式声明更清晰
    enum CodingKeys: String, CodingKey {
        case date, item
    }
    
    // 可选：自定义编码逻辑，比如统一处理Date格式
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(date, forKey: .date)
        try container.encode(item, forKey: .item)
    }
    
    // 解码初始化方法，因继承NSObject需调用super.init()
    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        date = try container.decodeIfPresent(Date.self, forKey: .date)
        item = try container.decodeIfPresent(T.self, forKey: .item)
        super.init()
    }
}

使用示例
比如你有CodableTypeA和CodableTypeB两个遵循Codable的类型，直接这样创建容器：

// 存储CodableTypeA
let containerA = CodableContainer<CodableTypeA>()
containerA.date = Date()
containerA.item = CodableTypeA()

// 存储CodableTypeB
let containerB = CodableContainer<CodableTypeB>()
containerB.date = Date()
containerB.item = CodableTypeB()

这个方案完全不需要修改现有类型，只要它们遵循Codable就行，代码简洁且类型安全，Swift 4完全支持。

方案二：带类型标识的通用容器（适合需要混合不同类型容器的场景） #

如果你的需求是把不同类型的容器放在同一个数组里（比如[CodableContainer]），泛型方案就无法满足了（因为泛型是具体类型），这时候可以给容器加上类型标识，编码时存下类型信息，解码时根据标识还原具体类型：

首先，实现一个轻量版的AnyCodable来擦除具体类型（Swift 4没有官方的AnyCodable）：

struct AnyCodable: Codable {
    let value: Codable
    
    init(_ value: Codable) {
        self.value = value
    }
    
    func encode(to encoder: Encoder) throws {
        try value.encode(to: encoder)
    }
}

然后实现带类型标识的容器：

class CodableContainer: NSObject, Codable {
    var date: Date?
    var item: AnyCodable?
    private var itemType: String // 存储类型的字符串标识
    
    enum CodingKeys: String, CodingKey {
        case date, item, itemType
    }
    
    // 初始化方法，自动捕获传入类型的标识
    init<T: Codable>(date: Date?, item: T?) {
        self.date = date
        self.item = item.map(AnyCodable.init)
        self.itemType = String(describing: T.self)
        super.init()
    }
    
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(date, forKey: .date)
        try container.encode(item, forKey: .item)
        try container.encode(itemType, forKey: .itemType)
    }
    
    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        date = try container.decodeIfPresent(Date.self, forKey: .date)
        itemType = try container.decode(String.self, forKey: .itemType)
        
        // 维护类型映射表，注册所有用到的Codable类型
        guard let codableType = typeMapping[itemType] as? Codable.Type else {
            throw DecodingError.dataCorruptedError(
                forKey: .itemType,
                in: container,
                debugDescription: "未知类型：\(itemType)"
            )
        }
        
        // 根据类型解码item
        let decodedItem = try container.decodeIfPresent(codableType, forKey: .item)
        item = decodedItem.map { AnyCodable($0 as! Codable) }
        super.init()
    }
    
    // 类型映射表，新增类型时在这里添加即可
    private let typeMapping: [String: Any.Type] = [
        "CodableTypeA": CodableTypeA.self,
        "CodableTypeB": CodableTypeB.self
    ]
}

使用示例
这个容器可以统一存储任意Codable类型，还能放在同一个数组里：

let containerA = CodableContainer(date: Date(), item: CodableTypeA())
let containerB = CodableContainer(date: Date(), item: CodableTypeB())

// 可以放在同一个数组中
let containers: [CodableContainer] = [containerA, containerB]

// 编码解码正常工作
let encoder = JSONEncoder()
encoder.dateEncodingStrategy = .iso8601
let data = try encoder.encode(containers)

let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601
let decodedContainers = try decoder.decode([CodableContainer].self, from: data)

补充小提示 #

• 处理Date时，记得给编码器和解码器设置统一的日期策略（比如.iso8601），避免默认时间戳格式带来的兼容性问题。
• 若不需要混合不同类型的容器，优先选择方案一，类型更安全，代码也更简洁。
• 方案二的类型映射表可以做成全局单例，方便后续新增类型时统一管理。

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