如何在 Swift 4 可解码协议中解码具有 JSON 字典类型的属性

How to decode a property with type of JSON dictionary in Swift 4 decodable protocol

提问by Pitiphong Phongpattranont

Let's say I have Customerdata type which contains a metadataproperty that can contains any JSON dictionary in the customer object

假设我有一个Customer数据类型，其中包含一个metadata属性，该属性可以包含客户对象中的任何 JSON 字典

struct Customer {
  let id: String
  let email: String
  let metadata: [String: Any]
}

---

---

{  
  "object": "customer",
  "id": "4yq6txdpfadhbaqnwp3",
  "email": "[email protected]",
  "metadata": {
    "link_id": "linked-id",
    "buy_count": 4
  }
}

The metadataproperty can be any arbitrary JSON map object.

该metadata属性可以是任意的 JSON 映射对象。

Before I can cast the property from a deserialized JSON from NSJSONDeserializationbut with the new Swift 4 Decodableprotocol, I still can't think of a way to do that.

在我可以从反序列化的 JSON 中转换属性之前，NSJSONDeserialization但使用新的 Swift 4Decodable协议，我仍然想不出办法做到这一点。

Do anyone know how to achieve this in Swift 4 with Decodable protocol?

有谁知道如何使用可解码协议在 Swift 4 中实现这一点？

采纳答案by loudmouth

With some inspiration from this gistI found, I wrote some extensions for UnkeyedDecodingContainerand KeyedDecodingContainer. You can find a link to my gist here. By using this code you can now decode any Array<Any>or Dictionary<String, Any>with the familiar syntax:

我从这个要点中找到了一些灵感，我为UnkeyedDecodingContainer和编写了一些扩展KeyedDecodingContainer。你可以在这里找到我的要点的链接。通过使用此代码，您现在可以使用熟悉的语法解码任何Array<Any>或Dictionary<String, Any>：

let dictionary: [String: Any] = try container.decode([String: Any].self, forKey: key)

or

或者

let array: [Any] = try container.decode([Any].self, forKey: key)

Edit:there is one caveat I have found which is decoding an array of dictionaries [[String: Any]]The required syntax is as follows. You'll likely want to throw an error instead of force casting:

编辑：我发现有一个警告是解码字典数组[[String: Any]]所需的语法如下。您可能希望抛出错误而不是强制转换：

let items: [[String: Any]] = try container.decode(Array<Any>.self, forKey: .items) as! [[String: Any]]

EDIT 2:If you simply want to convert an entire file to a dictionary, you are better off sticking with api from JSONSerialization as I have not figured out a way to extend JSONDecoder itself to directly decode a dictionary.

编辑 2：如果您只是想将整个文件转换为字典，最好坚持使用 JSONSerialization 中的 api，因为我还没有想出一种方法来扩展 JSONDecoder 本身以直接解码字典。

guard let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] else {
  // appropriate error handling
  return
}

The extensions

扩展名

// Inspired by https://gist.github.com/mbuchetics/c9bc6c22033014aa0c550d3b4324411a

struct JSONCodingKeys: CodingKey {
    var stringValue: String

    init?(stringValue: String) {
        self.stringValue = stringValue
    }

    var intValue: Int?

    init?(intValue: Int) {
        self.init(stringValue: "\(intValue)")
        self.intValue = intValue
    }
}


extension KeyedDecodingContainer {

    func decode(_ type: Dictionary<String, Any>.Type, forKey key: K) throws -> Dictionary<String, Any> {
        let container = try self.nestedContainer(keyedBy: JSONCodingKeys.self, forKey: key)
        return try container.decode(type)
    }

    func decodeIfPresent(_ type: Dictionary<String, Any>.Type, forKey key: K) throws -> Dictionary<String, Any>? {
        guard contains(key) else { 
            return nil
        }
        guard try decodeNil(forKey: key) == false else { 
            return nil 
        }
        return try decode(type, forKey: key)
    }

    func decode(_ type: Array<Any>.Type, forKey key: K) throws -> Array<Any> {
        var container = try self.nestedUnkeyedContainer(forKey: key)
        return try container.decode(type)
    }

    func decodeIfPresent(_ type: Array<Any>.Type, forKey key: K) throws -> Array<Any>? {
        guard contains(key) else {
            return nil
        }
        guard try decodeNil(forKey: key) == false else { 
            return nil 
        }
        return try decode(type, forKey: key)
    }

    func decode(_ type: Dictionary<String, Any>.Type) throws -> Dictionary<String, Any> {
        var dictionary = Dictionary<String, Any>()

        for key in allKeys {
            if let boolValue = try? decode(Bool.self, forKey: key) {
                dictionary[key.stringValue] = boolValue
            } else if let stringValue = try? decode(String.self, forKey: key) {
                dictionary[key.stringValue] = stringValue
            } else if let intValue = try? decode(Int.self, forKey: key) {
                dictionary[key.stringValue] = intValue
            } else if let doubleValue = try? decode(Double.self, forKey: key) {
                dictionary[key.stringValue] = doubleValue
            } else if let nestedDictionary = try? decode(Dictionary<String, Any>.self, forKey: key) {
                dictionary[key.stringValue] = nestedDictionary
            } else if let nestedArray = try? decode(Array<Any>.self, forKey: key) {
                dictionary[key.stringValue] = nestedArray
            }
        }
        return dictionary
    }
}

extension UnkeyedDecodingContainer {

    mutating func decode(_ type: Array<Any>.Type) throws -> Array<Any> {
        var array: [Any] = []
        while isAtEnd == false {
            // See if the current value in the JSON array is `null` first and prevent infite recursion with nested arrays.
            if try decodeNil() {
                continue
            } else if let value = try? decode(Bool.self) {
                array.append(value)
            } else if let value = try? decode(Double.self) {
                array.append(value)
            } else if let value = try? decode(String.self) {
                array.append(value)
            } else if let nestedDictionary = try? decode(Dictionary<String, Any>.self) {
                array.append(nestedDictionary)
            } else if let nestedArray = try? decode(Array<Any>.self) {
                array.append(nestedArray)
            }
        }
        return array
    }

    mutating func decode(_ type: Dictionary<String, Any>.Type) throws -> Dictionary<String, Any> {

        let nestedContainer = try self.nestedContainer(keyedBy: JSONCodingKeys.self)
        return try nestedContainer.decode(type)
    }
}

回答by zoul

I have played with this problem, too, and finally wrote a simple library for working with “generic JSON” types. (Where “generic” means “with no structure known in advance”.) Main point is representing the generic JSON with a concrete type:

我也玩过这个问题，最后写了一个简单的库来处理“通用 JSON”类型。（其中“通用”的意思是“没有事先知道的结构”。）要点是用具体类型表示通用 JSON：

public enum JSON {
    case string(String)
    case number(Float)
    case object([String:JSON])
    case array([JSON])
    case bool(Bool)
    case null
}

This type can then implement Codableand Equatable.

这种类型然后可以实现Codable和Equatable。

回答by Suhit Patil

You can create metadata struct which confirms to Decodableprotocol and use JSONDecoderclass to create object from data by using decode method like below

您可以创建元数据结构，该结构确认Decodable协议并使用JSONDecoder类通过使用如下解码方法从数据创建对象

let json: [String: Any] = [
    "object": "customer",
    "id": "4yq6txdpfadhbaqnwp3",
    "email": "[email protected]",
    "metadata": [
        "link_id": "linked-id",
        "buy_count": 4
    ]
]

struct Customer: Decodable {
    let object: String
    let id: String
    let email: String
    let metadata: Metadata
}

struct Metadata: Decodable {
    let link_id: String
    let buy_count: Int
}

let data = try JSONSerialization.data(withJSONObject: json, options: .prettyPrinted)

let decoder = JSONDecoder()
do {
    let customer = try decoder.decode(Customer.self, from: data)
    print(customer)
} catch {
    print(error.localizedDescription)
}

回答by Giuseppe Lanza

I came with a slightly different solution.

我带来了一个稍微不同的解决方案。

Let's suppose we have something more than a simple [String: Any]to parse were Any might be an array or a nested dictionary or a dictionary of arrays.

让我们假设我们有一些比[String: Any]解析更简单的东西Any 可能是一个数组、一个嵌套字典或一个数组字典。

Something like this:

像这样的东西：

var json = """
{
  "id": 12345,
  "name": "Giuseppe",
  "last_name": "Lanza",
  "age": 31,
  "happy": true,
  "rate": 1.5,
  "classes": ["maths", "phisics"],
  "dogs": [
    {
      "name": "Gala",
      "age": 1
    }, {
      "name": "Aria",
      "age": 3
    }
  ]
}
"""

Well, this is my solution:

嗯，这是我的解决方案：

public struct AnyDecodable: Decodable {
  public var value: Any

  private struct CodingKeys: CodingKey {
    var stringValue: String
    var intValue: Int?
    init?(intValue: Int) {
      self.stringValue = "\(intValue)"
      self.intValue = intValue
    }
    init?(stringValue: String) { self.stringValue = stringValue }
  }

  public init(from decoder: Decoder) throws {
    if let container = try? decoder.container(keyedBy: CodingKeys.self) {
      var result = [String: Any]()
      try container.allKeys.forEach { (key) throws in
        result[key.stringValue] = try container.decode(AnyDecodable.self, forKey: key).value
      }
      value = result
    } else if var container = try? decoder.unkeyedContainer() {
      var result = [Any]()
      while !container.isAtEnd {
        result.append(try container.decode(AnyDecodable.self).value)
      }
      value = result
    } else if let container = try? decoder.singleValueContainer() {
      if let intVal = try? container.decode(Int.self) {
        value = intVal
      } else if let doubleVal = try? container.decode(Double.self) {
        value = doubleVal
      } else if let boolVal = try? container.decode(Bool.self) {
        value = boolVal
      } else if let stringVal = try? container.decode(String.self) {
        value = stringVal
      } else {
        throw DecodingError.dataCorruptedError(in: container, debugDescription: "the container contains nothing serialisable")
      }
    } else {
      throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not serialise"))
    }
  }
}

Try it using

尝试使用

let stud = try! JSONDecoder().decode(AnyDecodable.self, from: jsonData).value as! [String: Any]
print(stud)

回答by Pitiphong Phongpattranont

When I found the old answer, I only tested a simple JSON object case but not an empty one which will cause a runtime exception like @slurmomatic and @zoul found. Sorry for this issue.

当我找到旧答案时，我只测试了一个简单的 JSON 对象案例，而不是一个空的案例，它会导致像 @slurmomatic 和 @zoul found 这样的运行时异常。抱歉这个问题。

So I try another way by having a simple JSONValue protocol, implement the AnyJSONValuetype erasure struct and use that type instead of Any. Here's an implementation.

所以我尝试了另一种方法，通过一个简单的 JSONValue 协议，实现AnyJSONValue类型擦除结构并使用该类型而不是Any. 这是一个实现。

public protocol JSONType: Decodable {
    var jsonValue: Any { get }
}

extension Int: JSONType {
    public var jsonValue: Any { return self }
}
extension String: JSONType {
    public var jsonValue: Any { return self }
}
extension Double: JSONType {
    public var jsonValue: Any { return self }
}
extension Bool: JSONType {
    public var jsonValue: Any { return self }
}

public struct AnyJSONType: JSONType {
    public let jsonValue: Any

    public init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()

        if let intValue = try? container.decode(Int.self) {
            jsonValue = intValue
        } else if let stringValue = try? container.decode(String.self) {
            jsonValue = stringValue
        } else if let boolValue = try? container.decode(Bool.self) {
            jsonValue = boolValue
        } else if let doubleValue = try? container.decode(Double.self) {
            jsonValue = doubleValue
        } else if let doubleValue = try? container.decode(Array<AnyJSONType>.self) {
            jsonValue = doubleValue
        } else if let doubleValue = try? container.decode(Dictionary<String, AnyJSONType>.self) {
            jsonValue = doubleValue
        } else {
            throw DecodingError.typeMismatch(JSONType.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Unsupported JSON tyep"))
        }
    }
}

And here is how to use it when decoding

这是解码时如何使用它

metadata = try container.decode ([String: AnyJSONValue].self, forKey: .metadata)

The problem with this issue is that we must call value.jsonValue as? Int. We need to wait until Conditional Conformanceland in Swift, that would solve this problem or at least help it to be better.

这个问题的问题是我们必须调用value.jsonValue as? Int. 我们需要等到Conditional ConformanceSwift 落地，这将解决这个问题，或者至少帮助它变得更好。

---

---

[Old Answer]

[旧答案]

I post this question on the Apple Developer forum and it turns out it is very easy.

我在 Apple Developer 论坛上发布了这个问题，结果证明这很容易。

I can do

我可以

metadata = try container.decode ([String: Any].self, forKey: .metadata)

in the initializer.

在初始化程序中。

It was my bad to miss that in the first place.

一开始就错过它是我的坏事。

回答by allen huang

If you use SwiftyJSONto parse JSON, you can update to 4.1.0which has Codableprotocol support. Just declare metadata: JSONand you're all set.

如果您使用SwiftyJSON来解析 JSON，则可以更新到具有协议支持的4.1.0Codable。只需声明即可metadata: JSON。

import SwiftyJSON

struct Customer {
  let id: String
  let email: String
  let metadata: JSON
}

回答by Tai Le

I have made a pod to facilitate the way the decoding + encoding [String: Any], [Any]. And this provides encode or decode the optional properties, here https://github.com/levantAJ/AnyCodable

我做了一个pod来方便解码+编码的方式[String: Any]，[Any]. 这提供了编码或解码的可选属性，这里是https://github.com/levantAJ/AnyCodable

pod 'DynamicCodable', '1.0'

How to use it:

如何使用它：

import DynamicCodable

struct YourObject: Codable {
    var dict: [String: Any]
    var array: [Any]
    var optionalDict: [String: Any]?
    var optionalArray: [Any]?

    enum CodingKeys: String, CodingKey {
        case dict
        case array
        case optionalDict
        case optionalArray
    }

    init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: CodingKeys.self)
        dict = try values.decode([String: Any].self, forKey: .dict)
        array = try values.decode([Any].self, forKey: .array)
        optionalDict = try values.decodeIfPresent([String: Any].self, forKey: .optionalDict)
        optionalArray = try values.decodeIfPresent([Any].self, forKey: .optionalArray)
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(dict, forKey: .dict)
        try container.encode(array, forKey: .array)
        try container.encodeIfPresent(optionalDict, forKey: .optionalDict)
        try container.encodeIfPresent(optionalArray, forKey: .optionalArray)
    }
}

回答by canius

You might have a look at BeyovaJSON

你可能看看BeyovaJSON

import BeyovaJSON

struct Customer: Codable {
  let id: String
  let email: String
  let metadata: JToken
}

//create a customer instance

customer.metadata = ["link_id": "linked-id","buy_count": 4]

let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted 
print(String(bytes: try! encoder.encode(customer), encoding: .utf8)!)

回答by minhazur

The easiest and suggested way is to create separate model for each dictionary or model that is in JSON.

最简单和建议的方法是为JSON 中的每个字典或模型创建单独的模型。

Here is what I do

这是我所做的

//Model for dictionary **Metadata**

struct Metadata: Codable {
    var link_id: String?
    var buy_count: Int?
}  

//Model for dictionary **Customer**

struct Customer: Codable {
   var object: String?
   var id: String?
   var email: String?
   var metadata: Metadata?
}

//Here is our decodable parser that decodes JSON into expected model

struct CustomerParser {
    var customer: Customer?
}

extension CustomerParser: Decodable {

//keys that matches exactly with JSON
enum CustomerKeys: String, CodingKey {
    case object = "object"
    case id = "id"
    case email = "email"
    case metadata = "metadata"
}

init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CustomerKeys.self) // defining our (keyed) container

    let object: String = try container.decode(String.self, forKey: .object) // extracting the data
    let id: String = try container.decode(String.self, forKey: .id) // extracting the data
    let email: String = try container.decode(String.self, forKey: .email) // extracting the data

   //Here I have used metadata model instead of dictionary [String: Any]
    let metadata: Metadata = try container.decode(Metadata.self, forKey: .metadata) // extracting the data

    self.init(customer: Customer(object: object, id: id, email: email, metadata: metadata))

    }
}

Usage:

用法：

  if let url = Bundle.main.url(forResource: "customer-json-file", withExtension: "json") {
        do {
            let jsonData: Data =  try Data(contentsOf: url)
            let parser: CustomerParser = try JSONDecoder().decode(CustomerParser.self, from: jsonData)
            print(parser.customer ?? "null")

        } catch {

        }
    }

**I have used optional to be in safe side while parsing, can be changed as needed.

**我在解析时使用了 optional 来保证安全，可以根据需要进行更改。

Read more on this topic

阅读有关此主题的更多信息

回答by Alexey Kozhevnikov

Here is more generic (not only [String: Any], but [Any]can decoded) and encapsulated approach (separate entity is used for that) inspired by @loudmouth answer.

这是比较通用的（不仅[String: Any]，而且[Any]可以解码）和封装方法（独立的实体，用于那些）由@loudmouth答案启发。

Using it will look like:

使用它看起来像：

extension Customer: Decodable {
  public init(from decoder: Decoder) throws {
    let selfContainer = try decoder.container(keyedBy: CodingKeys.self)
    id = try selfContainer.decode(.id)
    email = try selfContainer.decode(.email)
    let metadataContainer: JsonContainer = try selfContainer.decode(.metadata)
    guard let metadata = metadataContainer.value as? [String: Any] else {
      let context = DecodingError.Context(codingPath: [CodingKeys.metadata], debugDescription: "Expected '[String: Any]' for 'metadata' key")
      throw DecodingError.typeMismatch([String: Any].self, context)
    }
    self.metadata = metadata
  }

  private enum CodingKeys: String, CodingKey {
    case id, email, metadata
  }
}

JsonContaineris a helper entity we use to wrap decoding JSON data to JSON object (either array or dictionary) without extending *DecodingContainer(so it won't interfere with rare cases when a JSON object is not meant by [String: Any]).

JsonContainer是一个辅助实体，我们用来将解码 JSON 数据包装到 JSON 对象（数组或字典）而不进行扩展*DecodingContainer（因此它不会干扰 JSON 对象不是由 表示的罕见情况[String: Any]）。

struct JsonContainer {

  let value: Any
}

extension JsonContainer: Decodable {

  public init(from decoder: Decoder) throws {
    if let keyedContainer = try? decoder.container(keyedBy: Key.self) {
      var dictionary = [String: Any]()
      for key in keyedContainer.allKeys {
        if let value = try? keyedContainer.decode(Bool.self, forKey: key) {
          // Wrapping numeric and boolean types in `NSNumber` is important, so `as? Int64` or `as? Float` casts will work
          dictionary[key.stringValue] = NSNumber(value: value)
        } else if let value = try? keyedContainer.decode(Int64.self, forKey: key) {
          dictionary[key.stringValue] = NSNumber(value: value)
        } else if let value = try? keyedContainer.decode(Double.self, forKey: key) {
          dictionary[key.stringValue] = NSNumber(value: value)
        } else if let value = try? keyedContainer.decode(String.self, forKey: key) {
          dictionary[key.stringValue] = value
        } else if (try? keyedContainer.decodeNil(forKey: key)) ?? false {
          // NOP
        } else if let value = try? keyedContainer.decode(JsonContainer.self, forKey: key) {
          dictionary[key.stringValue] = value.value
        } else {
          throw DecodingError.dataCorruptedError(forKey: key, in: keyedContainer, debugDescription: "Unexpected value for \(key.stringValue) key")
        }
      }
      value = dictionary
    } else if var unkeyedContainer = try? decoder.unkeyedContainer() {
      var array = [Any]()
      while !unkeyedContainer.isAtEnd {
        let container = try unkeyedContainer.decode(JsonContainer.self)
        array.append(container.value)
      }
      value = array
    } else if let singleValueContainer = try? decoder.singleValueContainer() {
      if let value = try? singleValueContainer.decode(Bool.self) {
        self.value = NSNumber(value: value)
      } else if let value = try? singleValueContainer.decode(Int64.self) {
        self.value = NSNumber(value: value)
      } else if let value = try? singleValueContainer.decode(Double.self) {
        self.value = NSNumber(value: value)
      } else if let value = try? singleValueContainer.decode(String.self) {
        self.value = value
      } else if singleValueContainer.decodeNil() {
        value = NSNull()
      } else {
        throw DecodingError.dataCorruptedError(in: singleValueContainer, debugDescription: "Unexpected value")
      }
    } else {
      let context = DecodingError.Context(codingPath: [], debugDescription: "Invalid data format for JSON")
      throw DecodingError.dataCorrupted(context)
    }
  }

  private struct Key: CodingKey {
    var stringValue: String

    init?(stringValue: String) {
      self.stringValue = stringValue
    }

    var intValue: Int?

    init?(intValue: Int) {
      self.init(stringValue: "\(intValue)")
      self.intValue = intValue
    }
  }
}

Note that numberic and boolean types are backed by NSNumber, else something like this won't work:

请注意，数字和布尔类型由 支持NSNumber，否则这样的事情将不起作用：

if customer.metadata["keyForInt"] as? Int64 { // as it always will be nil