快速解码单个对象与对象数组的 JSON

Question

我对 swift 编程语言相当陌生，并且在过去一周左右的时间里一直在努力让它工作。我正在使用一个现有的 API，它返回 JSON 数据，其结构会根据返回的场地数量而略有变化。

实际结构稍微复杂一些，但这个例子说明了问题。在一种结果中，我得到一个返回的场地，例如：

{
  "totalItems": 21,
  "pageSize": 2,
  "venues": {
    "venue":
    {
       "name": "Venue Name 1"
       "location": "Location A",
       "showCount": "4"
    }
  }
}

在另一种结果中，我返回了一系列场地：

{
  "totalItems": 21,
  "pageSize": 2,
  "venues": {
    "venue":
    [{
       "name": "Venue Name 1"
       "location": "Location A",
       "showCount": "4"
    },
    {
       "name": "Venue Name 2"
       "location": "Location B",
       "showCount": "2"
    }]
  }
}

是的 - 此 API 的所有者无论如何都应该返回一个数组，但他们没有，而且无法更改。

我能够为一系列场地正确解码（或者即使没有通过场地），但是当通过单个场地时它会中止（当然是由于结构变化）。当我将代码更改为容纳单个场地时，我的代码也可以正常工作，但随后多个场地的返回中止。

我想做的是将任一变体解码为包含数组的内部结构，而不管我收到哪种变体，从而使我以后以编程方式处理事情变得更加简单。像这样的：

struct Response: Decodable {
    let totalItems: Int
    let pageSize: Int
    let venues: VenueWrapper

    struct VenueWrapper: Decodable {
        let venue: [Venue]     // This might contain 0, 1, or more than one venues
    }

    struct Venue: Decodable {
        let name: String
        let location: String
        let showCount: Int
    }
}

注意：在实际的 JSON 响应中，响应中实际上有几个这样的子结构（例如，单个结构与结构数组），这就是为什么我觉得简单地创建一个替代结构不是一个好的解决方案。

我希望以前有人遇到过这种情况。提前致谢！

Answer 1

不需要VenueWrapper。 ??

struct Response {
  let totalItems: Int
  let pageSize: Int
  let venues: [Venue]

  struct Venue {
    let name: String
    let location: String
    let showCount: Int
  }
}

您需要编写自己的初始化程序。不幸的是，我认为没有办法消除非愚蠢编码属性的样板。

即使您永远不需要对其进行编码，制作 Response Codable，而不仅仅是 Decodable，也会让您访问自动生成的 CodingKeys。

extension Response: Codable {
  init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    totalItems = try container.decode(Int.self, forKey: .totalItems)
    pageSize = try container.decode(Int.self, forKey: .pageSize)
    venues = try container.decode(key: .venues)
  }
}

最后一行依赖于协议和扩展，您可以将其用于任何其他类似“编码”的类型。 ?

protocol GoofilyEncoded: Codable {
  /// Must have exactly one case.
  associatedtype GoofyCodingKey: CodingKey
}

extension KeyedDecodingContainer {
  func decode<Decodable: GoofilyEncoded>(key: Key) throws -> [Decodable] {
    let nestedContainer = try self.nestedContainer(
      keyedBy: Decodable.GoofyCodingKey.self,
      forKey: key
    )

    let key = nestedContainer.allKeys.first!

    do {
      return try nestedContainer.decode([Decodable].self, forKey: key)
    }
    catch {
      return try [nestedContainer.decode(Decodable.self, forKey: key)]
    }
  }
}

所有可能编码在数组中的类型，或没有 ?‍♂️，都需要一个单例枚举，如下所示：

extension Response.Venue: GoofilyEncoded {
  enum GoofyCodingKey: CodingKey {
    case venue
  }
}

Answer 2

您可以创建自己的解码器，

struct Response: Decodable {
    let totalItems: Int
    let pageSize: Int
    let venues: VenueWrapper

    struct VenueWrapper: Decodable {
        var venue: [Venue]

        init(from decoder: Decoder) throws {
            let values = try decoder.container(keyedBy: CodingKeys.self)
            venue = []
            if let singleVenue = try? values.decode(Venue.self, forKey: CodingKeys.venue) {
                //if a single venue decoded append it to array
                venue.append(singleVenue)
            } else if let multiVenue = try? values.decode([Venue].self, forKey: CodingKeys.venue) {
                //if a multi venue decoded, set it as venue
                venue = multiVenue
            }

            enum CodingKeys: String, CodingKey { case venue }
        }
    }

    struct Venue: Decodable {
        let name: String
        let location: String
        let showCount: String
    }
}