Swift4 终极解析方案：进阶篇

转载请注明，原文地址：Swift4 终极解析方案：进阶篇

自定义Key

基础篇里面已经介绍了使用CodingKey协议来处理自定义字段的问题，这里我们反向编码来看一下，示例：

let json = """
{
    "name": "Endeavor",
    "abv": 8.9,
    "brewery": "Saint Arnold",
    "style": "ipa"
}
""".data(using: .utf8)! // our data in native (JSON) format

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

采用编码输出的方式：

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

这样看起来是不是很怪异，因为默认输出风格是.compact，没关系，修改下输出风格为.prettyPrinted就好了：

encoder.outputFormatting = .prettyPrinted

最终的编码输出：

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

日期

OK，我们上一节讲到使用JSONDecoder来编码对象，并输出为JSON，辣么这就来说说时间需要怎么个处理法。
JSON里面事并没有表示日期的方式，因此开发的时候都是前后端相互约定好固定的内容进行解析，有可能是以秒数为单位的时间戳，或者是特定格式的日期字符串。通常是ISO 8601的标准。

以往的情况，前后端约定好之后，我们都是自行解析在转换。辣么现在好了，JSONEncoder会自行帮我们处理，不过默认的方式是.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)：当您有非标准日期格式字符串时，自行提供DateFormatter实例转换。
.custom( (Date, Encoder) throws -> Void )：你需要完全定制的时候，传递一个闭包自行处理时间。
.millisecondsSince1970和.secondsSince1970：这种方式其实不是很推荐，因为完全没有办法区分到底是那个时区的时间戳。

解码也是相同的处理方式，详情请看查阅DecoderApi。

浮点数

服务端的Float类型和Swift的浮点数类型是互不兼容的，如果服务端出现NaN、Infinity等这种情况，系统并不会有任何值进行映射。
对于这种情况，系统默认是.throw的处理方式，也就是解析不到，那就直接抛出异常。如果我们需要处理这个问题，我们可以提供一个映射：

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

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

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

输出结果就是：

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

对于JSONEncoder，我们可以用nonConformingFloatEncodingStrategy进行反向操作。
这在大多数情况下不太可能需要，不保证总有一天它可能会派上用场。

二进制数据

对于二进制数据，系统会默认采用base64的字符串进行编码，当然也提供自定义方式。

JSONEncoder策略：

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

JSONDecoder策略：

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

URL

在数据解析中，如果有超链接的情况，我们直接提供类型匹配即可。

{
  "title": "NSDateFormatter - Easy Skeezy Date Formatting...",
  "url": "http://nsdateformatter.com"
}

对象结构：

struct Webpage : Codable {
  let title: String
  let url: URL
}

嵌套

有的时候后端会返回一个用key包起来的数组对象：

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

直接映射即可：

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

如果返回的数据是顶层，并没有任何key包裹，那就采用基础篇的数组解析方式即可。

再如果，是顶级嵌套，有被包裹，就像这种屌结构：

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

那我们就使用大杀器泛型：

[[String:Beer]]

像这样处理即可：

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

继承

我们来看看如下继承结构：

class Person : Codable {
    var name: String?
}
class Employee : Person {
    var employeeID: String?
}

尝试下编码会发生什么情况：

let employee = Employee()
employee.employeeID = "emp123"
employee.name = "Joe"

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

{
  "name" : "Joe"
}

事实上，对象继承并不能如我们所愿可以直接编码解码，所以还是得处理下自定义编码解码方法：

    var name: String?

    private enum CodingKeys : String, CodingKey {
        case name
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(name, forKey: .name)
    }
}

子类也使用相同的处理方式

class Employee : Person {
    var employeeID: String?

    private enum CodingKeys : String, CodingKey {
        case employeeID = "emp_id"
    }

    override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(employeeID, forKey: .employeeID)
    }
}

正确结果：

{
    "name": "Joe",
    "emp_id": "emp123"
}

结尾

相信两篇教程里面的示例已经能满足日常开发95%的需求了，如果你们的后端非要奇葩到那5%，那你就自求多福，自己去啃文档，妈宝是当不完的，白白。