Comment décoder un imbriquée struct JSON avec Swift Décodable protocole?

Une autre approche consiste à créer un modèle intermédiaire qui correspond au format JSON (avec l'aide d'un outil comme quicktype.io), laissez Swift générer les méthodes pour le décoder, puis de ramasser les morceaux que vous voulez dans la version finale du modèle de données:

//snake_case to match the JSON and hence no need to write CodingKey enums /struct
fileprivate struct RawServerResponse: Decodable {
    struct User: Decodable {
        var user_name: String
        var real_info: UserRealInfo
    }

    struct UserRealInfo: Decodable {
        var full_name: String
    }

    struct Review: Decodable {
        var count: Int
    }

    var id: Int
    var user: User
    var reviews_count: [Review]
}

struct ServerResponse: Decodable {
    var id: String
    var username: String
    var fullName: String
    var reviewCount: Int

    init(from decoder: Decoder) throws {
        let rawResponse = try RawServerResponse(from: decoder)

        //Now you can pick items that are important to your data model,
        //conveniently decoded into a Swift structure
        id = String(rawResponse.id)
        username = rawResponse.user.user_name
        fullName = rawResponse.user.real_info.full_name
        reviewCount = rawResponse.reviews_count.first!.count
    }
}

Cela vous permet également de facilement parcourir reviews_count, devrait-il contenir plus de 1 la valeur à l'avenir.

Plutôt que d'avoir un gros CodingKeys énumération avec tous les touches que vous aurez besoin pour le décodage JSON, je vous conseille de fractionnement les clés pour chaque de votre imbriquée objets JSON, utilisant des énumérations pour préserver la hiérarchie:

//top-level JSON object keys
private enum CodingKeys : String, CodingKey {

    //using camelCase case names, with snake_case raw values where necessary.
    //the raw values are what's used as the actual keys for the JSON object,
    //and default to the case name unless otherwise specified.
    case id, user, reviewsCount = "reviews_count"

    //"user" JSON object keys
    enum User : String, CodingKey {
        case username = "user_name", realInfo = "real_info"

        //"real_info" JSON object keys
        enum RealInfo : String, CodingKey {
            case fullName = "full_name"
        }
    }

    //nested JSON objects in "reviews" keys
    enum ReviewsCount : String, CodingKey {
        case count
    }
}

Ce sera plus facile de garder une trace des clés à chaque niveau dans votre JSON.

Maintenant, en gardant à l'esprit que:

• Un incrustée conteneur est utilisée pour décoder un objet JSON, et est décodé avec un CodingKey conformes type (tels que ceux que nous avons définis ci-dessus).

• Un unkeyed conteneur est utilisée pour décoder un tableau JSON, et est décodé séquentiellement (j'.e chaque fois que vous appelez une décoder ou conteneur imbriqué méthode, il avance vers le prochain élément dans le tableau). Voir la deuxième partie de la réponse pour savoir comment vous pouvez parcourir une.

Après l'obtention de votre haut niveau incrustée conteneur à partir du décodeur avec conteneur(keyedBy:) (que vous avez un objet JSON dans le haut-niveau), vous pouvez utiliser plusieurs fois les méthodes:

• nestedContainer(keyedBy:forKey:) pour obtenir un objet imbriqué à partir d'un objet pour une clé donnée
• nestedUnkeyedContainer(forKey:) pour obtenir un tableau imbriqué à partir d'un objet pour une clé donnée
• nestedContainer(keyedBy:) pour obtenir le prochain objet imbriqué à partir d'un tableau
• nestedUnkeyedContainer() pour obtenir le prochain tableau imbriqué à partir d'un tableau

Par exemple:

struct ServerResponse : Decodable {
var id: Int, username: String, fullName: String, reviewCount: Int
private enum CodingKeys : String, CodingKey { /* see above definition in answer */ }
init(from decoder: Decoder) throws {
//top-level container
        let container = try decoder.container(keyedBy: CodingKeys.self)
self.id = try container.decode(Int.self, forKey: .id)
//container for { "user_name": "Tester", "real_info": { "full_name": "Jon Doe" } }
        let userContainer =
try container.nestedContainer(keyedBy: CodingKeys.User.self, forKey: .user)
self.username = try userContainer.decode(String.self, forKey: .username)
//container for { "full_name": "Jon Doe" }
        let realInfoContainer =
try userContainer.nestedContainer(keyedBy: CodingKeys.User.RealInfo.self,
forKey: .realInfo)
self.fullName = try realInfoContainer.decode(String.self, forKey: .fullName)
//container for [{ "count": 4 }] – must be a var, as calling a nested container
        //method on it advances it to the next element.
        var reviewCountContainer =
try container.nestedUnkeyedContainer(forKey: .reviewsCount)
//container for { "count" : 4 }
        //(note that we're only considering the first element of the array)
        let firstReviewCountContainer =
try reviewCountContainer.nestedContainer(keyedBy: CodingKeys.ReviewsCount.self)
self.reviewCount = try firstReviewCountContainer.decode(Int.self, forKey: .count)
}
}

Exemple de décodage:

let jsonData = """
{
"id": 1,
"user": {
"user_name": "Tester",
"real_info": {
"full_name":"Jon Doe"
}
},
"reviews_count": [
{
"count": 4
}
]
}
""".data(using: .utf8)!
do {
let response = try JSONDecoder().decode(ServerResponse.self, from: jsonData)
print(response)
} catch {
print(error)
}
// ServerResponse(id: 1, username: "Tester", fullName: "Jon Doe", reviewCount: 4)

Une itération à travers un unkeyed conteneur

Considérant le cas où vous souhaitez reviewCount être un [Int], où chaque élément représente la valeur de l' "count" clé dans le imbriqués JSON:

  "reviews_count": [
{
"count": 4
},
{
"count": 5
}
]

Vous aurez besoin pour itérer sur les imbriquée unkeyed conteneur, l'obtention de la imbriquée à clé contenant à chaque itération, et le décodage de la valeur pour l' "count" clé. Vous pouvez utiliser le count propriété de la unkeyed conteneur afin de pré-allouer la résultante de tableau, puis la isAtEnd propriété d'itérer à travers elle.

Par exemple:

struct ServerResponse : Decodable {
var id: Int
var username: String
var fullName: String
var reviewCounts = [Int]()
//...

init(from decoder: Decoder) throws {
//...

//container for [{ "count": 4 }, { "count": 5 }]
        var reviewCountContainer =
try container.nestedUnkeyedContainer(forKey: .reviewsCount)
//pre-allocate the reviewCounts array if we can
        if let count = reviewCountContainer.count {
self.reviewCounts.reserveCapacity(count)
}
//iterate through each of the nested keyed containers, getting the
        //value for the "count" key, and appending to the array.
        while !reviewCountContainer.isAtEnd {
//container for a single nested object in the array, e.g { "count": 4 }
            let nestedReviewCountContainer = try reviewCountContainer.nestedContainer(
keyedBy: CodingKeys.ReviewsCount.self)
self.reviewCounts.append(
try nestedReviewCountContainer.decode(Int.self, forKey: .count)
)
}
}
}

Vous pouvez également utiliser la bibliothèque KeyedCodable j'ai préparé. Il aura besoin de moins de code. Laissez-moi savoir ce que vous en pensez.

struct ServerResponse: Decodable, Keyedable {
var id: String!
var username: String!
var fullName: String!
var reviewCount: Int!
private struct ReviewsCount: Codable {
var count: Int
}
mutating func map(map: KeyMap) throws {
var id: Int!
try id <<- map["id"]
self.id = String(id)
try username <<- map["user.user_name"]
try fullName <<- map["user.real_info.full_name"]
var reviewCount: [ReviewsCount]!
try reviewCount <<- map["reviews_count"]
self.reviewCount = reviewCount[0].count
}
init(from decoder: Decoder) throws {
try KeyedDecoder(with: decoder).decode(to: &self)
}
}