单个JSON返回值中有多种可编码对象类型

Question

My dilemma is I'm receiving two different object types from one table in a JSON response. Here is an example of the response of both types in a return.

"supplementaryItems": [
    {
        "header": "Doodle",
        "subHeader": "It's a drawing.",
        "slideID": 4,
        "imageName": null,
        "textItems": null,
        "sortOrder": 0
    },
    {
        "header": "Cell Phones",
        "subHeader": "No phones please",
        "slideID": 8,
        "imageName": "welcome_icon_cellphones",
        "textItems": ["first","second","third"],
        "sortOrder": 1
    }
]

What we're hoping to do is create two different types of objects here. A textOnlyItem , and a imageWithTextItem .

Is there a way to create one as a subclass or extension that can be keyed off of a Bool defined by whether imageName is null or not?

Thanks for any help all.

Answer 1

You don't need two different objects. Just declare imageName and textItems as optional, this handles the null case.

You can simply check whether imageName is nil

let jsonString = """
{"supplementaryItems": [
{
"header": "Doodle",
"subHeader": "It's a drawing.",
"slideID": 4,
"imageName": null,
"textItems": null,
"sortOrder": 0
},
{
"header": "Cell Phones",
"subHeader": "No phones please",
"slideID": 8,
"imageName": "welcome_icon_cellphones",
"textItems": ["first","second","third"],
"sortOrder": 1
}
]
}
"""

---

struct Root : Decodable {
    let supplementaryItems : [SupplementaryItem]
}

struct SupplementaryItem : Decodable {
    let header : String
    let subHeader : String
    let slideID : Int
    let imageName : String?
    let textItems : [String]?
    let sortOrder : Int
}

do {
    let data = Data(jsonString.utf8)
    let result = try JSONDecoder().decode(Root.self, from: data)
    for item in result.supplementaryItems {
       if let imageName = item.imageName {
           print(imageName + " has text items")
       } else {
           print(item.header + " has no text items")
       }
    }
} catch { print(error) }

Answer 2

I actually like vadian's approach, of one type. But I gather that would require significant refactoring in your situation.

The other approach is to just use JSONSerialization and build your heterogeneous array manually. JSONSerialization isn't deprecated, it just doesn't do it automatically like JSONDecoder .

Another approach is to use JSONDecoder , writing custom initializer that tries to decode it as ImageItem , and if that fails, try decoding it as TextItem :

protocol SupplementaryItem {
    var header:    String    { get }
    var subHeader: String    { get }
    var slideID:   Int       { get }
    var sortOrder: Int       { get }
    var textItems: [String]? { get }
}

struct TextItem: SupplementaryItem, Codable {
    let header:    String
    let subHeader: String
    let slideID:   Int
    let sortOrder: Int
    let textItems: [String]?
}

struct ImageItem: SupplementaryItem, Codable {
    let header:    String
    let subHeader: String
    let slideID:   Int
    let sortOrder: Int
    let textItems: [String]?
    let imageName: String
}

struct ResponseObject: Decodable {
    let supplementaryItems: [SupplementaryItem]

    enum CodingKeys: String, CodingKey {
        case supplementaryItems
    }

    init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        var container = try values.nestedUnkeyedContainer(forKey: .supplementaryItems)
        if container.count == nil {
            throw DecodingError.dataCorruptedError(in: container, debugDescription: "Expected array for supplementaryItems")
        }
        var items = [SupplementaryItem]()
        while !container.isAtEnd {
            if let item = try? container.decodeIfPresent(ImageItem.self), let imageItem = item {
                items.append(imageItem)
            } else {
                let textItem = try container.decode(TextItem.self)
                items.append(textItem)
            }
        }
        supplementaryItems = items
    }
}

Then:

let string = """
    {
        "supplementaryItems": [
            {
                "header": "Doodle",
                "subHeader": "It's a drawing.",
                "slideID": 4,
                "imageName": "foo",
                "textItems": null,
                "sortOrder": 0
            },
            {
                "header": "Cell Phones",
                "subHeader": "No phones please",
                "slideID": 8,
                "imageName": "welcome_icon_cellphones",
                "textItems": ["first","second","third"],
                "sortOrder": 1
            }
        ]
    }
    """

let data = string.data(using: .utf8)!

let json = try! JSONDecoder().decode(ResponseObject.self, from: data)
print(json)

I'm not convinced this is any better or worse than just using JSONSerialization , but it's another approach.