SwiftyJSON
1. 优点：
在获取多层次结构的JSON数据时。 SwiftyJSON不需要一直判断这个节点是否存在，是不是我们想要的类型，下一个节点是否存在，是不是我们想要的类型。
同时，SwiftyJSON内部会自动对 optional（可选类型）进行拆包（Wrapping ），大大简化了代码。
2. 使用方法：
测试数据：
{"msg":"OK","data":{"_ts":1621321596832,"dataId":"10000000","data":[{"id":"100000000","type":1,"contents":[{"verse":[{"id":"1000001","content":"床前明月光","control":0},{"id":"1000002","content":"疑是地上霜","control":0},{"id":"1000003","content":"举头望明月","control":0},{"id":"1000004","content":"低头思故乡","control":0}],"id":"1000001","pic":"https:PIC.jpg","TitleName":"静夜思","Type":"poetry","author":"李白","authorId":"1000001","dynasty":"唐朝"}],"_ts":1621321596832,"name":"唐诗大全","recommendId":""}]},"code":200}
2.1 初始化
let json1 = JSON.init(value)
let json2 = JSON(value)
2.2 读
let context = json["data", "data", 0, "contents", 0, "verse", 0, "content"]
或
let context = json["data"]["data"][0]["contents"][0]["verse"][0]["content"]
FOR-IN获取数据
let contextArr = json["data"]["data"][0]["contents"][0]["verse"]
for (index ,contextJson):(String, JSON) in contextArr {
print("\(index)-\(contextJson)")
}
2.3 改
json["data", "data", 0, "contents", 0, "verse", 0, "content"] = "白日依山尽"
3. 源码浅析
3.1 初始化：
每一种初始化的办法，都判断是否为空、是否是data类型等。最后都走到这里
fileprivate init(jsonObject: Any) {
object = jsonObject
}
通过set-get object的方法，对JSON的object进行操作。这个object是any类型。
/// Object in JSON
public var object: Any {
get {...}
set {
error = nil
switch unwrap(newValue) {
case let number as NSNumber:
if number.isBool {
type = .bool
rawBool = number.boolValue
} else {
type = .number
rawNumber = number
}
case let string as String:
type = .string
rawString = string
case _ as NSNull:
type = .null
case nil:
type = .null
case let array as [Any]:
type = .array
rawArray = array
case let dictionary as [String: Any]:
type = .dictionary
rawDictionary = dictionary
default:
type = .unknown
error = SwiftyJSONError.unsupportedType
}
}
}
使用unwrap方法进行类型判断，解包json数据，拆分多层嵌套，将每一个字段进行类型判断:
private func unwrap(_ object: Any) -> Any {
switch object {
case let json as JSON:
return unwrap(json.object)
case let array as [Any]:
return array.map(unwrap)
case let dictionary as [String: Any]:
var d = dictionary
dictionary.forEach { pair in
d[pair.key] = unwrap(pair.value)
}
return d
default:
return object
}
}
这样就将获取来的数据，生成新SwiftyJSON类型数据。
3.2 获取数据
通过”下标“的写法，获取需要获取的数据的key或index。
备注资料：
Swift - 下标（Subscript）
Swift5.1 - 下标（subscript）
public subscript(path: JSONSubscriptType...) -> JSON {
get {
return self[path]
}
set { ... }
}
public subscript(path: [JSONSubscriptType]) -> JSON {
get {
return path.reduce(self) { $0[sub: $1] }
}
set { ... }
}
其中
path.reduce(self) { $0[sub: $1] }
reduce：可以把数组变成一个元素，首先需要指定一个初始值（在此处是self），然后在闭包中写一个规则。按此规则，会开始对数组中的元素进行递归闭包运算，直到算到最后一个。
每一层的嵌套，都通过sub方法拿到数据
fileprivate subscript(sub sub: JSONSubscriptType) -> JSON {
get {
switch sub.jsonKey {
case .index(let index): return self[index: index]
case .key(let key): return self[key: key]
}
}
set { ... }
}
其中，如果jsonKey是Int类型，就通过下标获取数组中数据的信息；如果是String，就用字典获取。如果不存在，也会返回一个null，而不是崩溃。如果存在了，就初始化一个新的JSON类型数据，返回。
fileprivate subscript(index index: Int) -> JSON {
get {
if type != .array {
var r = JSON.null
r.error = self.error ?? SwiftyJSONError.wrongType
return r
} else if rawArray.indices.contains(index) {
return JSON(rawArray[index])
} else {
var r = JSON.null
r.error = SwiftyJSONError.indexOutOfBounds
return r
}
}
set { ... }
}
fileprivate subscript(key key: String) -> JSON {
get {
var r = JSON.null
if type == .dictionary {
if let o = rawDictionary[key] {
r = JSON(o)
} else {
r.error = SwiftyJSONError.notExist
}
} else {
r.error = self.error ?? SwiftyJSONError.wrongType
}
return r
}
set { ... }
}
3.3 设置数据
同获取数据方式一样，走同样的俩接口，只不过一个是set一个是get
public subscript(path: JSONSubscriptType...) -> JSON {
get { ... }
set {
self[path] = newValue
}
}
public subscript(path: [JSONSubscriptType]) -> JSON {
get { ... }
set {
switch path.count {
case 0: return
case 1: self[sub:path[0]].object = newValue.object
default:
var aPath = path
aPath.remove(at: 0)
var nextJSON = self[sub: path[0]]
nextJSON[aPath] = newValue
self[sub: path[0]] = nextJSON
}
}
}
通过var nextJSON = self[sub: path[0]]一层一层展开path，将newValue赋值进正确位置。
self[sub: path[0]] = nextJSON
再按照层级，将nextJSON一层一层赋值回上一层。
3.4 自动拆包解包为空的写法
swiftJson优秀的地方在于，如果set-get时，key错误或者index不存在，不会导致崩溃。
具体做法是：
无论是set还是get，都会走
fileprivate subscript(sub sub: JSONSubscriptType) -> JSON {
get {
switch sub.jsonKey {
case .index(let index): return self[index: index]
case .key(let key): return self[key: key]
}
}
set {
switch sub.jsonKey {
case .index(let index): self[index: index] = newValue
case .key(let key): self[key: key] = newValue
}
}
}
通过对int和String类型的扩展，自动区分字典需要的key，数组需要的index。
如果要取一个数组，先做如下判断。判断要取值的部分type是否是array。
再用array.indices.contains(index)判断数组是否越界。如果都不是，则正常取值。
fileprivate subscript(index index: Int) -> JSON {
get {
if type != .array {
var r = JSON.null
r.error = self.error ?? SwiftyJSONError.wrongType
return r
} else if rawArray.indices.contains(index) {
return JSON(rawArray[index])
} else {
var r = JSON.null
r.error = SwiftyJSONError.indexOutOfBounds
return r
}
}
set { ... }
}
字典类型也是一样的。就不赘述了。
