json – 如何解码类型依赖于标记的值数组？

[
    { "tag": "Foo",… },{ "tag": "Bar",{ "tag": "Baz",]

protocol someCommonType {}

struct Foo: Decodable,someCommonType { … }
struct Bar: Decodable,someCommonType { … }
struct Baz: Decodable,someCommonType { … }

let values = try JSONDecoder().decode([someCommonType].self,from: …)

struct DecodingWrapper: Decodable {

    let value: someCommonType

    public init(from decoder: Decoder) throws {
        let c = try decoder.singleValueContainer()
        if let decoded = try? c.decode(Foo.self) {
            value = decoded
        } else if let decoded = try? c.decode(Bar.self) {
            value = decoded
        } else if let decoded = try? c.decode(Baz.self) {
            value = decoded
        } else {
            throw …
        }
    }
}

let wrapped = try JSONDecoder().decode([DecodingWrapper].self,from: …)
let values = wrapped.map { $0.value }

你的数组包含有限,可枚举变种的异构对象;听起来像Swift枚举的完美用例.它不适用于多态性,因为从概念上讲,这些“事物”不一定是同一种.他们恰好被标记了.

以这种方式看待它：你有一系列都有标签的东西,有些属于这种类型,有些属于完全不同的类型,还有其他……有时你甚至都不认识标签. Swift enum是捕捉这一想法的完美载体.

所以你有一堆结构共享一个标签属性,但彼此完全不同：

struct Foo: Decodable {
    let tag: String
    let fooValue: Int
}

struct Bar: Decodable {
    let tag: String
    let barValue: Int
}

struct Baz: Decodable {
    let tag: String
    let bazValue: Int
}

并且您的数组可以包含上述类型的任何实例,或者包含未知类型的实例.所以你有enum TagggedThing(或更好的名字).

enum TagggedThing {
    case foo(Foo)
    case bar(Bar)
    case baz(Baz)
    case unknown
}

你的数组,用Swift术语,是[TagggedThing]类型.所以你将TagggedThing类型与Decodable一致,如下所示：

extension TagggedThing: Decodable {
    private enum CodingKeys: String,CodingKey {
        case tag
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        let tag = try container.decode(String.self,forKey: .tag)

        let singleValueContainer = try decoder.singleValueContainer()
        switch tag {
        case "foo":
            // if it's not a Foo,throw and blame the server guy
            self = .foo(try singleValueContainer.decode(Foo.self))
        case "bar":
            self = .bar(try singleValueContainer.decode(Bar.self))
        case "baz":
            self = .baz(try singleValueContainer.decode(Baz.self))
        default:
            // this tag is unknown,or known but we don't care
            self = .unknown
        }
    }
}

现在您可以解码以下JSON：

let json: Data! = """
[
    {"tag": "foo","fooValue": 1},{"tag": "bar","barValue": 2},{"tag": "baz","bazValue": 3}
]
""".data(using: .utf8)

像这样：

let taggedThings = try? JSONDecoder().decode([TagggedThing].self,from: json)