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


मेरा 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?
    }
}

मैंने देखा है ऐप्पल का दस्तावेज़ीकरण नेस्टेड structs डीकोडिंग पर, लेकिन मैं अभी भी समझ में नहीं आता कि JSON के विभिन्न स्तरों को ठीक से कैसे करें। किसी भी प्रकार के मदद की बहुत सराहना की जाएगी।


44
2018-06-14 15:47


मूल




जवाब:


एक और तरीका एक इंटरमीडिएट मॉडल बनाना है जो जेएसओएन से बारीकी से मेल खाता है, स्विफ्ट को इसे डीकोड करने के तरीकों को उत्पन्न करने दें, और उसके बाद अपने अंतिम डेटा मॉडल में इच्छित टुकड़े चुनें:

// snake_case to match the JSON
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 से अधिक मूल्य होना चाहिए।


46
2018-06-14 23:23



ठीक। यह दृष्टिकोण बहुत साफ दिखता है। मेरे मामले में, मुझे लगता है कि मैं इसका इस्तेमाल करूंगा - iOS Calendar View OnMyProfile
हाँ, मैंने निश्चित रूप से इस पर विचार किया - @JTAppleCalendarforiOSSwift आपको इसे स्वीकार करना चाहिए, क्योंकि यह एक बेहतर समाधान है। - Hamish
@ हैमिश ठीक है। मैंने इसे स्विच किया, लेकिन आपका जवाब बेहद विस्तृत था। मैंने इससे बहुत कुछ सीखा। - iOS Calendar View OnMyProfile
बहुत साफ समाधान, धन्यवाद! - appsunited
मैं जानना चाहता हूं कि कोई कैसे कार्यान्वित कर सकता है Encodable के लिए ServerResponse एक ही दृष्टिकोण के बाद संरचना। क्या यह भी संभव है? - nayem


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


# 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
*/

42
2017-07-11 20:52



बहुत समर्पित उत्तर। - Hexfire
के बजाय struct आपने इस्तेमाल किया enum चाबियाँ के साथ जो बहुत अधिक सुरुचिपूर्ण है - Jack
इस दस्तावेज को दस्तावेज करने के लिए समय देने के लिए बहुत बड़ा धन्यवाद। डीकोडेबल और पार्सिंग जेएसओएन पर इतने सारे दस्तावेज खोने के बाद, आपके जवाब ने वास्तव में मेरे कई प्रश्नों को मंजूरी दे दी। - Marcy
यह मेरे लिए स्वीकार्य उत्तर होना चाहिए। - A_C


एक बड़ा होने की बजाय CodingKeys के साथ गणना सब JSON को डीकोड करने के लिए आपको जिस कुंजी की आवश्यकता होगी, मैं चाबियों को विभाजित करने की सलाह दूंगा से प्रत्येक पदानुक्रम को संरक्षित रखने के लिए नेस्टेड गणनाओं का उपयोग करके, अपने नेस्टेड 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 में प्रत्येक स्तर पर चाबियों का ट्रैक रखना आसान हो जाएगा।

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

  • कुंजी कंटेनर JSON ऑब्जेक्ट को डीकोड करने के लिए प्रयोग किया जाता है, और इसे डीकोड किया जाता है CodingKey अनुरूप प्रकार (जैसे कि हमने ऊपर परिभाषित किया है)।

  • एक बेकार कंटेनर 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)

एक बेकार कंटेनर के माध्यम से 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)
            )
        }
    }
}

17
2018-06-14 16:12



स्पष्टीकरण देने के लिए एक बात: आपका क्या मतलब था I would advise splitting the keys for each of your nested JSON objects up into multiple nested enumerations, thereby making it easier to keep track of the keys at each level in your JSON ? - iOS Calendar View OnMyProfile
@JTAppleCalendarforiOSSwift मेरा मतलब है कि एक बड़ा होने के बजाय CodingKeys साथ enum सब कुंजी जो आपको अपने JSON ऑब्जेक्ट को डीकोड करने की आवश्यकता होगी, आपको प्रत्येक JSON ऑब्जेक्ट के लिए उन्हें कई enums में विभाजित करना चाहिए - उदाहरण के लिए, हमारे ऊपर दिए गए कोड में CodingKeys.User उपयोगकर्ता JSON ऑब्जेक्ट को डीकोड करने के लिए कुंजी के साथ ({ "user_name": "Tester", "real_info": { "full_name": "Jon Doe" } }), तो बस के लिए चाबियाँ "user_name" और "real_info"। - Hamish
धन्यवाद। बहुत स्पष्ट प्रतिक्रिया। मैं अभी भी इसे पूरी तरह से समझने के लिए देख रहा हूँ। लेकिन यह काम करता है। - iOS Calendar View OnMyProfile
मेरे बारे में एक सवाल था reviews_count जो शब्दकोश की एक सरणी है। वर्तमान में, कोड अपेक्षित के रूप में काम करता है। मेरी समीक्षा गणना केवल सरणी में एक मान है। लेकिन अगर मैं वास्तव में review_count की एक सरणी चाहता था, तो मुझे बस घोषणा करने की आवश्यकता होगी var reviewCount: Int एक सरणी के रूप में सही है? -> var reviewCount: [Int]। और फिर मुझे भी संपादित करने की आवश्यकता होगी ReviewsCount enum सही है? - iOS Calendar View OnMyProfile
@JTAppleCalendarforiOSSwift यह वास्तव में थोड़ा अधिक जटिल होगा, जैसा कि आप वर्णन कर रहे हैं केवल एक सरणी नहीं है Int, लेकिन JSON ऑब्जेक्ट्स की एक सरणी जिसमें प्रत्येक के पास है Int किसी दिए गए कुंजी के लिए मूल्य - तो आपको जो करना होगा उसे बेकार कंटेनर के माध्यम से फिर से चालू करना होगा और सभी नेस्टेड कीड कंटेनर प्राप्त करना होगा, एक डीकोड करना होगा Int प्रत्येक के लिए (और फिर उनको अपनी सरणी में जोड़ना), उदाहरण के लिए gist.github.com/hamishknight/9b5c202fe6d8289ee2cb9403876a1b41 - Hamish


इन लोगों ने पहले ही मेरे प्रश्न का उत्तर दिया है, लेकिन मैंने सोचा कि मैं इस लिंक को यहां पोस्ट करूंगा जो इसे बहुत आसान बनाता है -> https://app.quicktype.io/#l=swift

बस बाएं हाथ फलक पर अपनी JSON प्रतिक्रिया पोस्ट करें, और अपने मॉडल को दाईं ओर जेनरेट करें देखें। जब आप अभी शुरू कर रहे हैं तो इससे मदद मिल सकती है।


9
2018-03-01 01:07



महान संसाधन - मैं बस इसे सीखना शुरू कर रहा हूं। - Chris


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

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

0
2018-05-27 20:13