स्विफ्ट डिकोडेबल प्रोटोकॉल के साथ नेस्टेड JSON स्ट्रक्चर को डीकोड कैसे करें?

Question 1

यहाँ मेरा JSON है

{
    "id": 1,
    "user": {
        "user_name": "Tester",
        "real_info": {
            "full_name":"Jon Doe"
        }
    },
    "reviews_count": [
        {
            "count": 4
        }
    ]
}

यहां वह संरचना है जो मैं चाहता हूं कि इसे (अपूर्ण) बचाया जाए

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

    enum CodingKeys: String, CodingKey {
       case id, 
       // How do i get nested values?
    }
}

मैंने नेस्टेड स्ट्रक्चर्स को डिकोड करने पर Apple के डॉक्यूमेंटेशन को देखा है , लेकिन मुझे अभी तक समझ नहीं आया है कि JSON के विभिन्न स्तरों को ठीक से कैसे किया जाए। किसी भी प्रकार के मदद की बहुत सराहना की जाएगी।

Question 2

एक अन्य दृष्टिकोण एक मध्यवर्ती मॉडल बनाना है जो JSON ( क्विकटाइप.आईओ जैसे उपकरण की सहायता से ) के साथ निकटता से मेल खाता है , स्विफ्ट को इसे डिकोड करने के लिए तरीके उत्पन्न करते हैं, और फिर उन टुकड़ों को उठाते हैं जिन्हें आप अपने अंतिम डेटा मॉडल में चाहते हैं:

// 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
    }
}

यह आपको आसानी से reviews_countइसके माध्यम से पुनरावृत्त करने की अनुमति देता है , क्या इसमें भविष्य में 1 से अधिक मूल्य होना चाहिए।

Question 3

अपनी समस्या को हल करने के लिए, आप अपने RawServerResponseकार्यान्वयन को कई तर्क भागों (स्विफ्ट 5 का उपयोग करके) में विभाजित कर सकते हैं ।

# 1। गुणों को लागू करें और कोडिंग कुंजी की आवश्यकता है

import Foundation

struct RawServerResponse {

    enum RootKeys: String, CodingKey {
        case id, user, reviewCount = "reviews_count"
    }

    enum UserKeys: String, CodingKey {
        case userName = "user_name", realInfo = "real_info"
    }

    enum RealInfoKeys: String, CodingKey {
        case fullName = "full_name"
    }

    enum ReviewCountKeys: String, CodingKey {
        case count
    }

    let id: Int
    let userName: String
    let fullName: String
    let reviewCount: Int

}

# 2। `id`संपत्ति के लिए डिकोडिंग रणनीति निर्धारित करें

extension RawServerResponse: Decodable {

    init(from decoder: Decoder) throws {
        // id
        let container = try decoder.container(keyedBy: RootKeys.self)
        id = try container.decode(Int.self, forKey: .id)

        /* ... */                 
    }

}

# 3। `userName`संपत्ति के लिए डिकोडिंग रणनीति निर्धारित करें

extension RawServerResponse: Decodable {

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

        // userName
        let userContainer = try container.nestedContainer(keyedBy: UserKeys.self, forKey: .user)
        userName = try userContainer.decode(String.self, forKey: .userName)

        /* ... */
    }

}

# 4। `fullName`संपत्ति के लिए डिकोडिंग रणनीति निर्धारित करें

extension RawServerResponse: Decodable {

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

        // fullName
        let realInfoKeysContainer = try userContainer.nestedContainer(keyedBy: RealInfoKeys.self, forKey: .realInfo)
        fullName = try realInfoKeysContainer.decode(String.self, forKey: .fullName)

        /* ... */
    }

}

# 5। `reviewCount`संपत्ति के लिए डिकोडिंग रणनीति निर्धारित करें

extension RawServerResponse: Decodable {

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

        // reviewCount
        var reviewUnkeyedContainer = try container.nestedUnkeyedContainer(forKey: .reviewCount)
        var reviewCountArray = [Int]()
        while !reviewUnkeyedContainer.isAtEnd {
            let reviewCountContainer = try reviewUnkeyedContainer.nestedContainer(keyedBy: ReviewCountKeys.self)
            reviewCountArray.append(try reviewCountContainer.decode(Int.self, forKey: .count))
        }
        guard let reviewCount = reviewCountArray.first else {
            throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: container.codingPath + [RootKeys.reviewCount], debugDescription: "reviews_count cannot be empty"))
        }
        self.reviewCount = reviewCount
    }

}

पूर्ण कार्यान्वयन

import Foundation

struct RawServerResponse {

    enum RootKeys: String, CodingKey {
        case id, user, reviewCount = "reviews_count"
    }

    enum UserKeys: String, CodingKey {
        case userName = "user_name", realInfo = "real_info"
    }

    enum RealInfoKeys: String, CodingKey {
        case fullName = "full_name"
    }

    enum ReviewCountKeys: String, CodingKey {
        case count
    }

    let id: Int
    let userName: String
    let fullName: String
    let reviewCount: Int

}

extension RawServerResponse: Decodable {

    init(from decoder: Decoder) throws {
        // id
        let container = try decoder.container(keyedBy: RootKeys.self)
        id = try container.decode(Int.self, forKey: .id)

        // userName
        let userContainer = try container.nestedContainer(keyedBy: UserKeys.self, forKey: .user)
        userName = try userContainer.decode(String.self, forKey: .userName)

        // fullName
        let realInfoKeysContainer = try userContainer.nestedContainer(keyedBy: RealInfoKeys.self, forKey: .realInfo)
        fullName = try realInfoKeysContainer.decode(String.self, forKey: .fullName)

        // reviewCount
        var reviewUnkeyedContainer = try container.nestedUnkeyedContainer(forKey: .reviewCount)
        var reviewCountArray = [Int]()
        while !reviewUnkeyedContainer.isAtEnd {
            let reviewCountContainer = try reviewUnkeyedContainer.nestedContainer(keyedBy: ReviewCountKeys.self)
            reviewCountArray.append(try reviewCountContainer.decode(Int.self, forKey: .count))
        }
        guard let reviewCount = reviewCountArray.first else {
            throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: container.codingPath + [RootKeys.reviewCount], debugDescription: "reviews_count cannot be empty"))
        }
        self.reviewCount = reviewCount
    }

}

प्रयोग

let jsonString = """
{
    "id": 1,
    "user": {
        "user_name": "Tester",
        "real_info": {
            "full_name":"Jon Doe"
        }
    },
    "reviews_count": [
    {
    "count": 4
    }
    ]
}
"""

let jsonData = jsonString.data(using: .utf8)!
let decoder = JSONDecoder()
let serverResponse = try! decoder.decode(RawServerResponse.self, from: jsonData)
dump(serverResponse)

/*
prints:
▿ RawServerResponse #1 in __lldb_expr_389
  - id: 1
  - user: "Tester"
  - fullName: "Jon Doe"
  - reviewCount: 4
*/

Question 4

JSON को डिकोड करने के लिए आपको जिन सभी कुंजियों की आवश्यकता होगी, उनके CodingKeysसाथ एक बड़ी गणना करने के बजाय , मैं आपके प्रत्येक नेस्टेड JSON ऑब्जेक्ट्स के लिए कुंजियों को विभाजित करने की सलाह दूंगा , पदानुक्रम को संरक्षित करने के लिए नेस्टेड एन्यूमरेशन्स का उपयोग करते हुए:

// 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
    }
}

इससे आपके JSON में प्रत्येक स्तर पर कुंजियों का ट्रैक रखना आसान हो जाएगा।

अब, यह ध्यान में रखते हुए कि:

जेन्स ऑब्जेक्ट को डीकोड करने के लिए एक कुंजी वाले कंटेनर का उपयोग किया जाता है, और एक CodingKeyअनुरूप प्रकार के साथ डिकोड किया जाता है (जैसे कि हमने जो ऊपर परिभाषित किया है)।
एक unkeyed कंटेनर का उपयोग JSON सरणी को डीकोड करने के लिए किया जाता है, और क्रमिक रूप से डिकोड किया जाता है (यानी हर बार जब आप उस पर डिकोड या नेस्टेड कंटेनर विधि कहते हैं, तो यह सरणी में अगले तत्व को आगे बढ़ाता है)। आप एक के माध्यम से कैसे पुनरावृत्ति कर सकते हैं, इसके उत्तर के दूसरे भाग को देखें।

डिकोडर से अपने शीर्ष-स्तर वाले कुंजीयुक्त कंटेनर को प्राप्त करने के बाद container(keyedBy:)(जैसा कि आपके पास शीर्ष-स्तर पर JSON ऑब्जेक्ट है), आप बार-बार विधियों का उपयोग कर सकते हैं:

nestedContainer(keyedBy:forKey:) किसी दी गई कुंजी के लिए किसी ऑब्जेक्ट से नेस्टेड ऑब्जेक्ट प्राप्त करना
nestedUnkeyedContainer(forKey:) किसी दिए गए कुंजी के लिए किसी ऑब्जेक्ट से नेस्टेड सरणी प्राप्त करना
nestedContainer(keyedBy:) किसी सरणी से अगली नेस्टेड ऑब्जेक्ट प्राप्त करने के लिए
nestedUnkeyedContainer() एक सरणी से अगले नेस्टेड सरणी प्राप्त करने के लिए

उदाहरण के लिए:

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)
    }
}

उदाहरण डिकोडिंग:

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)

एक unkeyed कंटेनर के माध्यम से Iterating

उस मामले को ध्यान में रखते हुए जहां आप reviewCountएक होना चाहते हैं [Int], जहां प्रत्येक तत्व "count"नेस्टेड JSON में कुंजी के लिए मूल्य का प्रतिनिधित्व करता है :

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

आपको नेस्टेड अनकेड कंटेनर के माध्यम से पुनरावृत्त करने की आवश्यकता होगी, प्रत्येक पुनरावृत्ति में नेस्टेड कीड कंटेनर प्राप्त करना, और "count"कुंजी के लिए मूल्य को डिकोड करना । countपरिणामी सरणी को पूर्व-आबंटित करने के लिए, और फिर isAtEndइसके माध्यम से पुनरावृति करने के लिए आप अनकैप्ड कंटेनर की संपत्ति का उपयोग कर सकते हैं ।

उदाहरण के लिए:

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)
            )
        }
    }
}

Question 5

कई अच्छे उत्तर पहले ही पोस्ट किए जा चुके हैं, लेकिन एक सरल विधि है जिसका वर्णन अभी तक नहीं किया गया है।

जब JSON फ़ील्ड नाम लिखे जाते snake_case_notationहैं, तब भी आप camelCaseNotationअपनी स्विफ्ट फ़ाइल में उपयोग कर सकते हैं ।

आपको बस सेट करने की जरूरत है

decoder.keyDecodingStrategy = .convertFromSnakeCase

इसके बाद snake_casefrom लाइन स्विफ्ट स्वचालित रूप से JSON से camelCaseफ़ील्ड्स के स्विफ्ट मॉडल के सभी फ़ील्ड से मेल खाएगी ।

उदाहरण के लिए

user_name` -> userName
reviews_count -> `reviewsCount
...

यहाँ पूर्ण कोड है

1. मॉडल लेखन

struct Response: Codable {

    let id: Int
    let user: User
    let reviewsCount: [ReviewCount]

    struct User: Codable {
        let userName: String

        struct RealInfo: Codable {
            let fullName: String
        }
    }

    struct ReviewCount: Codable {
        let count: Int
    }
}

2. डिकोडर सेट करना

let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase

3. डिकोडिंग

do {
    let response = try? decoder.decode(Response.self, from: data)
    print(response)
} catch {
    debugPrint(error)
}

Question 6

जसन फाइल को https://app.quicktype.io पर कॉपी करें
स्विफ्ट का चयन करें (यदि आप स्विफ्ट 5 का उपयोग करते हैं, तो स्विफ्ट 5 के लिए संगतता स्विच की जांच करें)
फ़ाइल को डीकोड करने के लिए निम्न कोड का उपयोग करें
देखा!

let file = "data.json"

guard let url = Bundle.main.url(forResource: "data", withExtension: "json") else{
    fatalError("Failed to locate \(file) in bundle.")
}

guard let data = try? Data(contentsOf: url) else{
    fatalError("Failed to locate \(file) in bundle.")
}

let yourObject = try? JSONDecoder().decode(YourModel.self, from: data)

Question 7

इसके अलावा, आप लाइब्रेरी KeyedCodable I का उपयोग कर सकते हैं । इसके लिए कम कोड की आवश्यकता होगी। मुझे बताओ आप इसके बारे में क्या सोचते हैं।

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)
  }
}