Andy矢倉

老板 来杯董小姐 去冰 少糖 多放点小姐

曾梦想 仗贱走天涯 看尽女人和繁华


Swift4 终极解析方案:进阶篇

自定义Key

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

1
2
3
4
5
6
7
8
let json = """
{
"name": "Endeavor",
"abv": 8.9,
"brewery": "Saint Arnold",
"style": "ipa"
}
""".data(using: .utf8)! // our data in native (JSON) format
1
2
3
4
5
6
7
8
9
struct Beer : Codable {
// ...
enum CodingKeys : String, CodingKey {
case name
case abv = "alcohol_by_volume"
case brewery = "brewery_name"
case style
}
}

采用编码输出的方式:

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

输出结果为:

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

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

1
encoder.outputFormatting = .prettyPrinted

最终的编码输出:

1
2
3
4
5
6
{
"style" : "ipa",
"name" : "Endeavor",
"alcohol_by_volume" : 8.8999996185302734,
"brewery_name" : "Saint Arnold"
}

日期

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

以往的情况,前后端约定好之后,我们都是自行解析在转换。辣么现在好了,JSONEncoder会自行帮我们处理,不过默认的方式是.deferToDate酱紫:

1
2
3
4
5
struct Foo : Encodable {
let date: Date
}
let foo = Foo(date: Date())
try! encoder.encode(foo)

输出了这鸟样:

1
2
3
{
"date" : 519751611.12542897
}

我们改成.iso8601试试:

1
encoder.dateEncodingStrategy = .iso8601

输出这下就对了:

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

对于日期的编码策略,系统提供了如下几种:

  • .formatted(DateFormatter):当您有非标准日期格式字符串时,自行提供DateFormatter实例转换。
  • .custom( (Date, Encoder) throws -> Void ):你需要完全定制的时候,传递一个闭包自行处理时间。
  • .millisecondsSince1970.secondsSince1970:这种方式其实不是很推荐,因为完全没有办法区分到底是那个时区的时间戳。

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

浮点数

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

1
2
3
4
5
{
"a": "NaN",
"b": "+Infinity",
"c": "-Infinity"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
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)

输出结果就是:

1
2
3
4
▿ __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

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

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

对象结构:

1
2
3
4
struct Webpage : Codable {
let title: String
let url: URL
}

嵌套

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

1
2
3
{
"beers": [ {...} ]
}

直接映射即可:

1
2
3
struct BeerList : Codable {
let beers: [Beer]
}

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

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

1
2
3
4
5
6
7
8
9
10
11
[
{
"beer" : {
"id": "uuid12459078214",
"name": "Endeavor",
"abv": 8.9,
"brewery": "Saint Arnold",
"style": "ipa"
}
}
]

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

1
[[String:Beer]]

像这样处理即可:

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

输出结果:

1
2
3
4
5
6
7
8
9
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

继承

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

1
2
3
4
5
6
class Person : Codable {
var name: String?
}
class Employee : Person {
var employeeID: String?
}

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

1
2
3
let employee = Employee()
employee.employeeID = "emp123"
employee.name = "Joe"
1
2
3
4
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
let data = try! encoder.encode(employee)
print(String(data: data, encoding: .utf8)!)
1
2
3
{
"name" : "Joe"
}

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

Person : Codable {
1
2
3
4
5
6
7
8
9
10
11
    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)
}
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
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)
}
}

正确结果:

1
2
3
4
{
"name": "Joe",
"emp_id": "emp123"
}

结尾

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

最近的文章

RxSwift从零入手 - 介绍

译自:Introducing RxSwift: Reactive Programming with Swift! 简介 “If you’ve ever used an asynchronous callback based API, you’ve probably dealt with hand …

于  RxSwift, Swift4 继续阅读
更早的文章

Swift4 终极解析方案:基础篇

做过网络开发,特别是互联网,甚至移动端开发的,日常对于数据解析,早年主流的XML,现今主流的JSON都是非常熟悉的,说道解析,系统自带和各种第三方的解析库,除了解析当然也当不了懒癌的脚步,各种model反射库。对于Objective-C各种方案都尤为成熟,甚至还有专门的MacApp用于model生 …

于  Codable, JSON, Swift4 继续阅读