閱讀這一篇文章，需要你對 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 解析函數？（下）—— 函數式編程以及協議