如何用 Swift 优雅地写一个 JSON 解析函数？（上）——

阅读这一篇文章，需要你对 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<T>(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<T>(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 解析函数？（下）—— 函数式编程以及协议