阅读这一篇文章，需要你对 Swift 的特性有一定的了解。至少要熟悉泛型以及扩展。
这篇文章的目的旨在分享一种将 Swift 的各种特性相结合，使写代码更加高效的可能性，实用性就各位自己斟酌啦。
这里用到的代码我都写在了 playground 里，放到了 Github 上。
比如说我们有一个这样的数据结构：
struct User {
var userId: Int64
var name: String
var admin: Bool = false
var signature: String?
var registerTime: NSDate?
init(userId: Int64,
name: String,
admin: Bool? = nil,
signature: String? = nil,
registerTime: NSDate? = nil) {
self.userId = userId
self.name = name
self.signature = signature
self.registerTime = registerTime
if let admin = admin { self.admin = admin }
}
}
为了方便测试，我们给这个 User 扩展一个 CustomStringConvertible 协议：
extension User: CustomStringConvertible {
var description: String {
return "userId = \(userId)," +
" name = \(name)," +
" admin : \(admin)," +
" signature = \(signature)," +
" registerTime = \(registerTime)"
}
}
我们和后端朋友定义好了，从某个接口的返回 JSON 大概为：
typealias JSON = [String : AnyObject]
//使用 typealias 能让可读性更强
let json: JSON = [
"code": 0,
"data": [
"users": [
[
"uid": 2,
"nam": "FrainTest",
"ada": true,
"rgt": "2016-03-04",
],
[
"uid": 3,
"nam": "Frain",
"sgt": "buzy",
"rgt": "2016-03-05",
]
]
]
]
我们能够怎么样高雅地解析这样一个 JSON ？
我们先定义一个这样的测试用 JSON ，一步一步来：
let userJSON = [
"uid": 2,
"nam": "FrainTest",
"sgt": "buzy",
"ada": true,
"rgt": "2016-03-04"
]
1. 不太优雅的解析方式
好了，在正式解析这个 JSON 的前，我们有一步工作要做，就是将 "yyyy-MM-dd" 这样的格式转换成 NSDate 类型，怎么样转换呢？简单，我们从 StackOverFlow 上复制一份：
func toDate(input: String?) -> NSDate? {
guard let input = input else { return nil }
let formatter = NSDateFormatter()
formatter.dateFormat = "yyyy-MM-dd"
formatter.timeZone = NSTimeZone.defaultTimeZone()
let date = formatter.dateFromString(input)
return date
}
好了，有了这一步准备工作，我们就能正式开始写了：
func parseUser1(json: JSON?) -> User? {
if let json = json {
if let id = json["uid"] as? Int {
if let name = json["nam"] as? String {
var user = User(userId: Int64(id), name: name)
if let signature = json["sgt"] as? String {
user.signature = signature
}
if let admin = json["ada"] as? Bool {
user.admin = admin
}
if let registerTime = toDate(json["rgt"] as? String) {
user.registerTime = (registerTime)
}
return user
}
}
}
return nil
}
let user1 = parseUser1(userJSON)
我们得到了想要的结果，可是……我们写了四个 if let，而且这里 if let 的嵌套也造成了一定的可读性下降，最重要的是，这不太优雅。
这个简单，我们可以使用 user 的初始化器来省去一部分 if let，剩下的，我们可以使用 guard。
2. 使用 Guard
func parseUser2(json: JSON?) -> User? {
guard let json = json else { return nil }
guard let id = json["uid"] as? Int else { return nil }
guard let name = json["nam"] as? String else { return nil }
return User(userId: Int64(id),
name: name,
admin: json["ada"] as? Bool,
signature: json["sgt"] as? String,
registerTime: toDate(json["rgt"] as? String))
}
let user2 = parseUser2(userJSON)
使用 guard let 有效的减少了 if let 的嵌套，看上去似乎好了一点，用 user 自带的初始化器节省了一定的 if let 判断。
也许对很多人来说，一般平时的项目到这儿就足够了，但是其实，我们还可以更优雅一点。
3. 使用 Generic
注意到我们这里使用了许多 as? 推断类型，这其实是可以通过泛型来省去的。
我们定义一个这样的泛型函数：
func fatch(json: JSON, key: String) -> T? {
let maybeAny = json[key]
return maybeAny as? T
}
使用这个泛型函数，编译器能够自动联系上下文，对 T 进行推断，联系到我们使用的 User 的初始化器，我们可以这样写：
func parseUser3(json: JSON?) -> User? {
guard let json = json else { return nil }
guard let id: Int = fatch(json, key: "uid") else { return nil }
guard let name: String = fatch(json, key: "nam") else { return nil }
return User(userId: Int64(id),
name: name,
admin: fatch(json, key: "ada"),
signature: fatch(json, key: "sgt"),
registerTime: toDate(fatch(json, key: "rgt")))
}
let user3 = parseUser3(userJSON)
注意到我们这里仍旧需要指定 id 和 name 的类型，让编译器能够根据类型来判断 T 。
如果还是觉得使用 fatch 觉得麻烦的话，我们还可以这样：
4. 使用 extension
extension String {
func fatch(json: JSON) -> T? {
let maybeAny = json[self]
return maybeAny as? T
}
}
这样有什么好处？这样一来，我们可以这样写：
func parseUser4(json: JSON?) -> User? {
guard let json = json else { return nil }
guard let id: Int = "uid".fatch(json) else { return nil }
guard let name: String = "nam".fatch(json) else { return nil }
return User(userId: Int64(id),
name: name,
admin: "ada".fatch(json),
signature: "sgt".fatch(json),
registerTime: toDate("rgt".fatch(json)))
}
let user4 = parseUser4(userJSON)
就能直接在字符后面就能使用这个函数啦。
注意，这样虽然方便了，但是会造成一定的可读性下降，实际项目中如果是多人协作，写这样的方法就需要斟酌啦。
到这里，我们使用了泛型和扩展，是不是已经足够优雅了？
还能不能再优雅一点？
当然可以，下一篇再继续介绍，通过函数式编程更优雅地解析 JSON
如何用 Swift 优雅地写一个 JSON 解析函数？（下）—— 函数式编程以及协议