如何从复杂的 json 创建简单的可编码结构

Question

I receive a complex json response from the API something similar to this.

{
    "result": "success",
    "count": 100,
    "details": [{
            "unnecessaryDetails": "something",
            "area": {
                "name": "Test1"
            }
        },
        {
            "unnecessaryDetails": "something",
            "area": {
                "name": "Test2"
            }
        },
        {
            "unnecessaryDetails": "something",
            "area": {
                "name": "Test3"
            }
        }
    ]
}

My struct is

struct Person {
    var name: String
}

struct Response {
    var result: String
    var count: Int
    var details: [Person]
}

I don't want to create properties for everything I receive from the response. I can't ask the backend developer to give the necessary details only. How to avoid unnecessary details and create struct with require details only?

Answer 1

You can skip intermediate arrays and dictionaries with nested containers.

struct Person : Decodable {
    let name: String
}

struct Response : Decodable {
    let result: String
    let count: Int
    let details: [Person]

    enum CodingKeys: String, CodingKey { case result, count, details }
    enum DetailCodingKeys: String, CodingKey { case area }

    init(from decoder : Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        result = try container.decode(String.self, forKey: .result)
        count = try container.decode(Int.self, forKey: .count)
        var detailContainer = try container.nestedUnkeyedContainer(forKey: .details)
        var people = [Person]()
        while !detailContainer.isAtEnd {
            let areaContainer = try detailContainer.nestedContainer(keyedBy: DetailCodingKeys.self)
            let person = try areaContainer.decode(Person.self, forKey: .area)
            people.append(person)
        }
        details = people
    }
}

However the effort is much bigger than adding the extra struct

struct Response : Decodable {
    let result: String
    let count: Int
    let details: [Detail]
}

struct Detail : Decodable {
    let area : Person
}

struct Person : Decodable {
    let name: String
}

Answer 2

You can use Codable to parse only property you want to parse and rest of all will be ignored, If you want to parse json in 2 separate models, you can follow this question's answer.

Is it possible to decode single level JSON into 2 separate models?

Answer 3

Use Codable (remove the fields however you want):

import Foundation

struct Response : Codable {
    let result : String?
    let count : Int?
    let details : [Details]?

    enum CodingKeys: String, CodingKey {

        case result = "result"
        case count = "count"
        case details = "details"
    }

    init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        result = try values.decodeIfPresent(String.self, forKey: .result)
        count = try values.decodeIfPresent(Int.self, forKey: .count)
        details = try values.decodeIfPresent([Details].self, forKey: .details)
    }

}

Details struct :

struct Details : Codable {
    let unnecessaryDetails : String?
    let area : Area?

    enum CodingKeys: String, CodingKey {

        case unnecessaryDetails = "unnecessaryDetails"
        case area = "area"
    }

    init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        unnecessaryDetails = try values.decodeIfPresent(String.self, forKey: .unnecessaryDetails)
        area = try values.decodeIfPresent(Area.self, forKey: .area)
    }

}

Area struct :

struct Area : Codable {
    let name : String?

    enum CodingKeys: String, CodingKey {

        case name = "name"
    }

    init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        name = try values.decodeIfPresent(String.self, forKey: .name)
    }

}

You can even use SwiftyJSON to parse only the fields you want.

Answer 4

You can use Codable for this situation. It will automatically ignore the properties you did not define in your struct. Your structs can be like this:

struct Response: Codable {
    let result: String
    let count: Int
    let details: [Detail]
}

struct Detail: Codable {
    let area: Area
}

struct Area: Codable {
    let name: String
}

And to parse:

let response = try? JSONDecoder().decode(Response.self, from: jsonData)

After that you can reach out to any properties you defined in your struct.