Swift 4 JSON 解析指南

Apple 终于在 Swift 4 的 Foundation 的模块中添加了对 JSON 解析的原生支持。

虽然已经有不少第三方类库实现了 JSON 解析，可是可以看到这样一个功能强大、易于使用的官方实现仍是难免有些兴奋。

值得注意的是，官方的实现方式适用于任何 Encoder/Decoder ，例如 PropertyListEncoder 。固然若是你须要 XML 格式的内容，能够进行自定义实现。在接下来的内容中，咱们将专一于 JSON 格式的解析，由于这是 iOS 开发中最多见的数据格式。

基础

若是你的 JSON 数据结构和你使用的 Model 对象结构一致的话，那么解析过程将会很是简单。

下面是一个JSON 格式的啤酒说明：

{
    "name": "Endeavor",
    "abv": 8.9,
    "brewery": "Saint Arnold",
    "style": "ipa"
}

对应的 Swift 数据结构以下：

enum BeerStyle : String {
    case ipa
    case stout
    case kolsch
    // ...
}

struct Beer {
    let name: String
    let brewery: String
    let style: BeerStyle
}

为了将 JSON 字符串转化为 Beer 类型的实例，咱们须要将 Beer 类型标记为 Codable。

Codable 其实是 Encodable & Decodable 两个协议的组合类型，因此若是你只须要单向转换的话，你能够只选用其中一个。该功能也是 Swift 4 中引入的最重要新特性之一。

Codable 带有默认实现，因此在大多数情形下，你能够直接使用该默认实现进行数据转换。

enum BeerStyle : String, Codable {
   // ...
}

struct Beer : Codable {
   // ...
}

下面只须要建立一个解码器：

let jsonData = jsonString.data(encoding: .utf8)!
let decoder = JSONDecoder()
let beer = try! decoder.decode(Beer.self, for: jsonData)

这样咱们就将 JSON 数据成功解析为了 Beer 实例对象。由于 JSON 数据的 Key 与 Beer 中的属性名一致，因此这里不须要进行自定义操做。

须要注意的是，这里直接使用了 try! 操做。由于这里只是简单示例，因此在真实程序中你应该对错误进行捕获并做出对应的处理。

可是，现实中不可能一直都是完美情形，很大概率存在 Key 值与属性名不匹配的情形。

自定义键值名

一般情形下，API 接口设计时会采用 snake-case 的命名风格，可是这与 Swift 中的编程风格有着明显的差别。

为了实现自定义解析，咱们须要先去看下 Codable 的默认实现机制。

默认情形下 Keys 是由编译器自动生成的枚举类型。该枚举遵照 CodingKey 协议并创建了属性和编码后格式之间的关系。

为了解决上面的风格差别须要对其进行自定义，实现代码：

struct Beer : Codable {
      // ...
      enum CodingKeys : String, CodingKey {
          case name
          case abv = "alcohol_by_volume"
          case brewery = "brewery_name"
          case style
    }
}

如今咱们将 Beer 实例转化为 JSON ，看看自定义以后的 JSON 数据格式：

let encoder = JSONEncoder()
let data = try! encoder.encode(beer)
print(String(data: data, encoding: .utf8)!)

输出以下：

{"style":"ipa","name":"Endeavor","alcohol_by_volume":8.8999996185302734,"brewery_name":"Saint Arnold"}

上面的输出格式对阅读起来并非太友好。不过咱们能够设置 JSONEncoder 的 outputFormatting 属性来定义输出格式。

默认 outputFormatting 属性值为 .compact，输出效果如上。若是将其改成 .prettyPrinted 后就能得到更好的阅读体检。

encoder.outputFormatting = .prettyPrinted

效果以下：

{
  "style" : "ipa",
  "name" : "Endeavor",
  "alcohol_by_volume" : 8.8999996185302734,
  "brewery_name" : "Saint Arnold"
}

JSONEncoder 和 JSONDecoder 其实还有不少选项能够自定义设置。其中有一个经常使用的需求就是自定义时间格式的解析。

时间格式处理

JSON 没有数据类型表示日期格式，所以须要客户端和服务端对序列化进行约定。一般情形下都会使用 ISO 8601 日期格式并序列化为字符串。

提示：nsdateformatter.com 是一个很是有用的网站，你能够查看各类日期格式的字符串表示，包括 ISO 8601。

其余格式多是参考日期起的总秒（或毫秒）数，并将其序列化为 JSON 格式中的数字类型。

以前，咱们必须本身处理这个问题。在数据结构中使用属性接收该字符串格式日期，而后使用 DateFormatter 将该属性转化为日期，反之亦然。

不过 JSONEncoder 和 JSONDecoder 自带了该功能。默认状况下，它们使用 .deferToDate 处理日期，以下：

struct Foo : Encodable {
    let date: Date
}

let foo = Foo(date: Date())
try! encoder.encode(foo)

{
  "date" : 519751611.12542897
}

固然，咱们也能够选用 .iso8601 格式：

encoder.dateEncodingStrategy = .iso8601

{
  "date" : "2017-06-21T15:29:32Z"
}

其余日期编码格式选择以下：

• .formatted(DateFormatter) - 当你的日期字符串是非标准格式时使用。须要提供你本身的日期格式化器实例。
• .custom( (Date, Encoder) throws -> Void ) - 当你须要真正意义上的自定义时，使用一个闭包进行实现。
• .millisecondsSince1970、 .secondsSince1970 - 这在 API 设计中不是很常见。 因为时区信息彻底不在编码表示中，因此不建议使用这样的格式，这使得人们更容易作出错误的假设。

对日期进行 Decoding 时基本上是相同的选项，可是 .custom 形式是 .custom( (Decoder) throws -> Date )，因此咱们给了一个解码器并将任意类型转换为日期格式。

浮点类型处理

浮点是 JSON 与 Swift 另外一个存在不匹配情形的类型。若是服务器返回的事无效的 "NaN" 字符串会发生什么？无穷大或者无穷大？这些不会映射到 Swift 中的任何特定值。

默认的实现是 .throw，这意味着若是上述数值出现的话就会引起错误，不过对此咱们能够自定义映射。

{
   "a": "NaN",
   "b": "+Infinity",
   "c": "-Infinity"
}

struct Numbers {
  let a: Float
  let b: Float
  let c: Float
}
decoder.nonConformingFloatDecodingStrategy =
  .convertFromString(
      positiveInfinity: "+Infinity",
      negativeInfinity: "-Infinity",
      nan: "NaN")

let numbers = try! decoder.decode(Numbers.elf, from: jsonData)
dump(numbers)

上述处理后：

__lldb_expr_71.Numbers
  - a: inf
  - b: -inf
  - c: nan

固然，咱们也可使用 JSONEncoder 的 nonConformingFloatEncodingStrategy 进行反向操做。

虽然大多数情形下上述处理不太可能出现，可是以防万一也不给过。

Data 处理

有时候服务端 API 返回的数据是 base64 编码过的字符串。

对此，咱们能够在 JSONEncoder 使用如下策略：

• .base64
• .custom( (Data, Encoder) throws -> Void)

反之，编码时可使用：

• .base64
• .custom( (Decoder) throws -> Data)

显然，.base64 时最多见的选项，但若是须要自定义的话能够采用 block 方式。

Wrapper Keys

一般 API 会对数据进行封装，这样顶级的 JSON 实体 始终是一个对象。

例如：

{
  "beers": [ {...} ]
}

在 Swift 中咱们能够进行对应处理：

struct BeerList : Codable {
    let beers: [Beer]
}

由于键值与属性名一致，全部上面代码已经足够了。

Root Level Arrays

若是 API 做为根元素返回数组，对应解析以下所示：

let decoder = JSONDecoder()
let beers = try decoder.decode([Beer].self, from: data)

须要注意的是，咱们在这里使用Array做为类型。只要 T 可解码，Array <T> 就可解码。

Dealing with Object Wrapping Keys

另外一个常见的场景是，返回的数组对象里的每个元素都被包装为字典类型对象。

[
  {
    "beer" : {
      "id": "uuid12459078214",
      "name": "Endeavor",
      "abv": 8.9,
      "brewery": "Saint Arnold",
      "style": "ipa"
    }
  }
]

你可使用上面的方法来捕获此 Key 值，但最简单的方式就是认识到该结构的可编码的实现形式。

以下：

[[String:Beer]]

或者更易于阅读的形式：

Array<Dictionary<String, Beer>>

与上面的 Array<T> 相似，若是 K 和 T 是可解码 Dictionary<K,T> 就能解码。

let decoder = JSONDecoder()
let beers = try decoder.decode([[String:Beer]].self, from: data)
dump(beers)

1 element
  ▿ 1 key/value pair
    ▿ (2 elements)
      - key: "beer"
      ▿ value: __lldb_expr_37.Beer
        - name: "Endeavor"
        - brewery: "Saint Arnold"
        - abv: 8.89999962
        - style: __lldb_expr_37.BeerStyle.ipa

更复杂的嵌套

有时候 API 的响应数据并非那么简单。顶层元素不必定只是一个对象，并且一般状况下是多个字典结构。

例如：

{
    "meta": {
        "page": 1,
        "total_pages": 4,
        "per_page": 10,
        "total_records": 38
    },
    "breweries": [
        {
            "id": 1234,
            "name": "Saint Arnold"
        },
        {
            "id": 52892,
            "name": "Buffalo Bayou"
        }
    ]
}

在 Swift 中咱们能够进行对应的嵌套定义处理：

struct PagedBreweries : Codable {
    struct Meta : Codable {
        let page: Int
        let totalPages: Int
        let perPage: Int
        let totalRecords: Int
        enum CodingKeys : String, CodingKey {
            case page
            case totalPages = "total_pages"
            case perPage = "per_page"
            case totalRecords = "total_records"
        }
    }

    struct Brewery : Codable {
        let id: Int
        let name: String
    }

    let meta: Meta
    let breweries: [Brewery]
}

该方法的最大优势就是对同一类型的对象作出不一样的响应（可能在这种状况下，“brewery” 列表响应中只须要 id 和 name 属性，可是若是查看详细内容的话则须要更多属性内容）。由于该情形下 Brewery 类型是嵌套的，咱们依旧能够在其余地方进行不一样的 Brewery 类型实现。

结论

Swift 4 中基础 Codable API 的内容已经介绍差很少了。更多的内容能够查看Codable.swift、Using JSON with Custom Types 。

更多内容，能够去我个站