如何通过扩展让Protocol遵循Codable？遇报错求解答

我定义了一个遵循Decodable的协议Foo，并通过扩展提供了解码的默认实现：

protocol Foo: Decodable {
    var prop1: String? { get set }
    var prop2: Bool? { get set }
    var prop3: Int? { get set }

    init()
}

enum FooCodingKeys: CodingKey { case prop1, prop2, prop3 }
extension Foo {
    init(from decoder: Decoder) throws {
        self.init()

        let container = try decoder.container(keyedBy: FooCodingKeys.self)
        self.prop1 = try container.decode(String?, forKey: .prop1)
        self.prop2 = try container.decode(Bool?, forKey: .prop2)
        self.prop3 = try container.decode(Int?, forKey: .prop3)
    }
}

编译器未报错，看起来协议应该完全支持解码，但在结构体Bar中尝试使用[Foo]作为解码类型时：

enum BarCodingKeys: CodingKey { case foos }
struct Bar: Decodable {
    var foos: [Foo]

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: BarCodingKeys.self)
        self.foos = try container.decode([Foo].self, forKey: .foos)
    }
}

出现错误：Protocol 'Foo' as a type cannot conform to 'Decodable'。

错误原因 #

Swift中，协议本身不能作为具体类型遵循协议。虽然你给Foo扩展提供了init(from:)的默认实现，但Foo本质仍是一个协议，而非具体类型。Decodable的解码逻辑需要明确的类型信息来创建实例，而协议没有自身的内存布局，无法直接被解码——编译器无法确定要创建哪个Foo实现类的实例，协议的init()要求只是对实现类型的约束，并非协议本身的构造逻辑。

可行解决办法 #

1. 使用类型擦除包装器 #

创建一个类型擦除的结构体AnyFoo，包装所有Foo的实现：

struct AnyFoo: Foo {
    var prop1: String?
    var prop2: Bool?
    var prop3: Int?

    init() {
        prop1 = nil
        prop2 = nil
        prop3 = nil
    }

    init(_ foo: Foo) {
        self.prop1 = foo.prop1
        self.prop2 = foo.prop2
        self.prop3 = foo.prop3
    }
}

// 修改Bar的foos类型为[AnyFoo]
struct Bar: Decodable {
    var foos: [AnyFoo]

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: BarCodingKeys.self)
        self.foos = try container.decode([AnyFoo].self, forKey: .foos)
    }
}

2. 使用具体实现类型的集合 #

如果Foo有具体的结构体/类实现，比如ConcreteFoo，则直接使用具体类型的数组：

struct ConcreteFoo: Foo {
    var prop1: String?
    var prop2: Bool?
    var prop3: Int?

    init() {}
}

struct Bar: Decodable {
    var foos: [ConcreteFoo]

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: BarCodingKeys.self)
        self.foos = try container.decode([ConcreteFoo].self, forKey: .foos)
    }
}

3. 用枚举承载多种Foo实现 #

如果有多种Foo实现，可通过枚举区分不同类型并遵循Foo协议：

// 先定义具体的Foo实现
struct ConcreteFooA: Foo {
    var prop1: String?
    var prop2: Bool?
    var prop3: Int?
    init() {}
}

struct ConcreteFooB: Foo {
    var prop1: String?
    var prop2: Bool?
    var prop3: Int?
    init() {}
}

// 定义枚举作为容器
enum FooType: Foo, Decodable {
    case typeA(ConcreteFooA)
    case typeB(ConcreteFooB)

    // 实现Foo的属性
    var prop1: String? {
        switch self {
        case .typeA(let foo): return foo.prop1
        case .typeB(let foo): return foo.prop1
        }
    }

    var prop2: Bool? {
        switch self {
        case .typeA(let foo): return foo.prop2
        case .typeB(let foo): return foo.prop2
        }
    }

    var prop3: Int? {
        switch self {
        case .typeA(let foo): return foo.prop3
        case .typeB(let foo): return foo.prop3
        }
    }

    init() {
        self = .typeA(ConcreteFooA())
    }

    // 自定义解码逻辑，通过标识字段区分类型
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: FooCodingKeys.self)
        // 假设JSON中有type字段区分类型
        let type = try container.decode(String.self, forKey: .type)
        switch type {
        case "a":
            self = .typeA(try ConcreteFooA(from: decoder))
        case "b":
            self = .typeB(try ConcreteFooB(from: decoder))
        default:
            throw DecodingError.dataCorruptedError(forKey: .type, in: container, debugDescription: "未知Foo类型")
        }
    }
}

// Bar中使用[FooType]
struct Bar: Decodable {
    var foos: [FooType]

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: BarCodingKeys.self)
        self.foos = try container.decode([FooType].self, forKey: .foos)
    }
}

总结 #

无法直接让协议作为Decodable的具体类型使用，因为协议没有自身的内存布局和实例创建逻辑。必须通过具体类型、类型擦除包装器或枚举容器的方式，提供明确的实例类型供解码逻辑调用。

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