Swift Mirror 类型实践 —— 快速将类转换为 Json

前一段时间看 Chris Eidhof 的个人网站的时候，注意到一篇博客。
使用 Swift Mirror 快速将类转换为 Json 的方法。
Swift Mirrors and JSON
但是原文已经不适应 Swift 2.2 的版本了，我将修改过的代码贴在这里（还是不少要改的），并附上一些可能需要解释的部分的注释：

//定义的示范用的结构体
struct Person {
    var name: String = "John"
    var age: Int = 50
    var dutch: Bool = false
    var address: Address? = Address(street: "Market St.")
    var Some: Int = 60
}

struct Address {
    var street: String
}

let john = Person()

//可以转换为 Json 的协议
protocol JSON {
    func toJSON() throws -> AnyObject?
}

//没有实现 JSON 协议的错误类型
enum CouldNotSerializeError {
    case NoImplementation(source: Any, type: Mirror)
}

extension CouldNotSerializeError: ErrorType { }

//使用 extension 对 JSON 添加方法的默认实现
extension JSON {
    func toJSON() throws -> AnyObject? {
        //创建 Mirror 类型
        let mirror = Mirror(reflecting: self)
        //Mirror 的 children 是一个 (label: String?, value: Any) 元组类型，表示该类的所有属性的名字和类型
        if mirror.children.count > 0  {
            var result: [String:AnyObject] = [:]
            for case let (label?, value) in mirror.children {
                //如果这个类型没有实现 JSON 协议，则抛出错误
                if let value = value as? JSON {
                    //递归调用
                    result[label] = try value.toJSON()
                } else {
                    throw CouldNotSerializeError.NoImplementation(source: self, type: Mirror(reflecting: value))
                }
            }
            return result
        }
         //如果没有属性（一般类，String，Int 等），则直接返回
        return self as? AnyObject
    }
}

//将一般类型都遵从 JSON 协议
extension Person: JSON { }
extension String: JSON { }
extension Int: JSON { }
extension Bool: JSON { }
extension Address: JSON { }

//Optionai 需要特别对待，原因是如果直接返回，则会是 .Some: [...] 
extension Optional: JSON {
    func toJSON() throws -> AnyObject? {
        if let x = self {
            if let value = x as? JSON {
                return try value.toJSON()
            }
            throw CouldNotSerializeError.NoImplementation(source: x, type: Mirror(reflecting: x))
        }
        return nil
    }
}

do {
    print(try john.toJSON())
} catch {
    print(error)
}
//输出：Optional({ Some = 60;  address =  { street = "Market St." ; }; age = 50; dutch = 0; name = John; })

是不是非常方便？我自己想了一个更加方便的，只要一个方法：

//泛型
func mkJson<T>(a: T?) -> AnyObject? {
    //如果为空，则不将该属性加入 Json
    guard let a = a else { return nil }
    let mirror = Mirror(reflecting: a)
    let num = mirror.children.count
    if num > 0  {
        var result: [String:AnyObject] = [:]
        for case let (label?, value) in mirror.children {
            //这里有点 Trick，如果是一个有值的 Optional（Some），则直接载入warp下的值。
            //后一个条件是防止如果有类型是叫做 Some（一般不会有吧）的属性的情况，见注1
            if label == "Some" && mirror.children.count == 1 {
                return toJson(value)
            }
            result[label] = toJson(value)
        }
        return result
    }
    
    return a as? AnyObject
}

let json = mkJson(john)
print(json)
//得到的结果完全一样
//注1：也就是说，如果你有一个类或者结构体，里面只有一个属性叫做 Some ，那么这个 Some 会被跳过直接读取里面的类型。当然，这种情况微乎其微。

唯一不太好的就是，使用 Mirror 有性能上的损失，我在Xcode上跑了一下测试，用的我自己的一个成员类
用时如下：
类创建：

func testInit() {
    self.measureBlock{
        for _ in 1...2000 {
            let _ = User()
        }
    }
}
//0.400 (0.401) seconds

Mirror：

func testMirror() {
    self.measureBlock {
        let user = User()
        for _ in 1...2000 {
            mkJson(user)
        }
    }
}
//4.147 (4.147) seconds
//我的天呐

if let 方式加入 dictionary：

func testIfLet() {
    self.measureBlock {
        let user = User()
        for _ in 1...2000 {
            let _ = user.parameters
        }
    }
}

extension User {

public var parameters: [String: AnyObject]  {
    var parms:[String : AnyObject] = [ : ]
    if let email = email {
        parms["email"] = email
    }
    if let nickName = nickName {
        parms["nickName"] = nickName
    }
    if let phoneNumber = phoneNumber {
        parms["phoneNumber"] = phoneNumber
    }
    return parms
}

//in 0.531 (0.532) seconds
//嗯……

所以说，虽然方便，还是慎用吧。