How Can One Use Swift's Decodable to Parse an Arbitrary JSON String Where You Only Know or Care About a Few Fields

How can one use Swift's Decodable to parse an arbitrary JSON string where you only know or care about a few fields?

The question seems to be based on a misapprehension about how Decodable works. As a convenience, Decodable is willing to do some automatic code generation behind the scenes so that you can define a struct or nest of structs and just decode the entirety of the JSON. But you are not required to take advantage of that in order to decode JSON.

• There is no need to define struct properties for "fields" you don't care about. If a JSON dictionary contains 100 keys and your corresponding struct contains just one property, no problem; that key will be fetched, and no others.

• With regard to the "deeply nested" part, it should not take you much time to write simple nested structs that perform the dive to reach the dictionary you really care about. But if you don't want to do even that, you could write an implementation of init(from:) that dives down and fetches out the desired values.

In other words, if you think of Decodable as consisting primarily of your implementation of init(from:), and learn to write the code that it needs, you will see that this JSON can be parsed in a few quick simple lines of code.

As an example, here's a JSON sketch of a deeply nested piece of information with a bunch of extra information at every level that we want to ignore:

{
  "ignore": true,
  "outer1": {
    "ignore": true,
    "outer2": {
      "ignore": true,
      "outer3": {
        "name": "matt",
        "ignore": true
      }
    }
  }
}

What I'd like to do is define a very simple struct Person that consists solely of the deeply nested name:

struct Person : Decodable {
    let name : String
}

I can do that! To do so, I implement Decodable myself, supplying a "hoover" CodingKey adopter struct and an implementation of init(from:), like this (this may look like a lot of work, but it isn't, because the AnyCodingKey implementation is boilerplate, copied and pasted from here, and the init(coder:) implementation is just a few lines of code that were easy to write):

    struct Person : Decodable {
        let name : String
        struct AnyCodingKey : CodingKey {
            var stringValue: String
            var intValue: Int?
            init(_ codingKey: CodingKey) {
                self.stringValue = codingKey.stringValue
                self.intValue = codingKey.intValue
            }
            init(stringValue: String) {
                self.stringValue = stringValue
                self.intValue = nil
            }
            init(intValue: Int) {
                self.stringValue = String(intValue)
                self.intValue = intValue
            }
        }
        init(from decoder: Decoder) throws {
            var con = try! decoder.container(keyedBy: AnyCodingKey.self)
            con = try! con.nestedContainer(keyedBy: AnyCodingKey.self, forKey: AnyCodingKey(stringValue:"outer1"))
            con = try! con.nestedContainer(keyedBy: AnyCodingKey.self, forKey: AnyCodingKey(stringValue:"outer2"))
            con = try! con.nestedContainer(keyedBy: AnyCodingKey.self, forKey: AnyCodingKey(stringValue:"outer3"))
            let name = try! con.decode(String.self, forKey: AnyCodingKey(stringValue:"name"))
            self.name = name
        }
    }

When I want to dive into the JSON and grab the name information, it's trivial:

let person = try! JSONDecoder().decode(Person.self, from: json)

The result is a Person object with name value "matt". Note that I didn't have to add any of the ignore keys and I didn't need to make a nest of structs.

How can I decode a generic JSON response in Swift 4?

You could make two structs:

struct generalStruct:Codable {
    let jsonrpc:String
    let id:Int
    let result:[resultsStruct]
}

struct resultsStruct{
     //assuming that you have strings in here, cause you didn't specify that. And it's considered as a Dictionary like: "data_tupe":"string_value" or if you have an array also here than just make another struct or just make data_type:[String]
    let data_type:String
}

With that structs you can decode now. Example:

 let json = try decoder.decode(generalStruct.self, from: response.data!)
 //here you can get access to each element of your 'data_type'
 for obj in json.result{
  for data in obj.data_type {
      //you have every element from dict access here if its more objects inside every 'data_type'
   }
 }

Related Topics