前一段时间看 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
//嗯……
所以说，虽然方便，还是慎用吧。
