iOS - JSON 数据解析

 iOS - JSON 数据解析

前言

    NS_CLASS_AVAILABLE(10_7, 5_0) @interface NSJSONSerialization : NSObject
    @available(iOS 5.0, *)         public class NSJSONSerialization : NSObject

1、JSON 数据

• JSON（JavaScript Object Notation）是一种轻量级的数据交换格式。它基于 ECMAScript 的一个子集。JSON 采用完全独立于语言的文本格式，但是也使用了类似于 C 语言家族的习惯（包括 C、C++、 C#、Java、JavaScript、Perl、Python 等）。这些特性使 JSON 成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成（一般用于提升网络传输速率）。

1.1 JSON 语法规则

• JSON 语法是 JavaScript 对象表示语法的子集。
  • 数据在键值对中
  • 数据由逗号分隔
  • 花括号保存对象
  • 方括号保存数组

1.2 JSON 基础结构

• JSON 结构有两种，JSON 简单说就是 javascript 中的对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构。

  • 1、对象：对象在 JSON 中表示为 “{}” 括起来的内容，数据结构为 {key：value, key：value, ...} 的键值对的结构，在面向对象的语言中，key 为对象的属性，value 为对应的属性值，所以很容易理解，取值方法为 对象[key] 获取属性值，这个属性值的类型可以是数字、字符串、数组、对象几种。
  • 2、数组：数组在 JSON 中表示为 “[]” 括起来的内容，数据结构为 ["java", "javascript", "vb", ...]，取值方式和所有语言中一样，使用索引获取。字段值的类型可以是 数字、字符串、数组、对象几种。

1.3 JSON 名称/值对

• JSON 数据的书写格式是：名称/值对。
• 名称/值对组合中的名称写在前面（在双引号中），值对写在后面(同样在双引号中)，中间用冒号隔开："firstName":"John"

1.4 JSON 值

• JSON 值可以是：
  • 数字（整数或浮点数）
  • 字符串（在双引号中）
  • 逻辑值（true 或 false）
  • 数组（在方括号中）
  • 对象（在花括号中）
  • null

1.5 JSON 基础示例

• 简单地说，JSON 可以将 JavaScript 对象中表示的一组数据转换为字符串，然后就可以在函数之间轻松地传递这个字符串，或者在异步应用程序中将字符串从 Web 客户机传递给服务器端程序。这个字符串看起来有点儿古怪，但是 JavaScript 很容易解释它，而且 JSON 可以表示比 "名称/值对" 更复杂的结构。例如，可以表示数组和复杂的对象，而不仅仅是键和值的简单列表。

• 1、表示名称/值对:

  • 按照最简单的形式，可以用下面这样的 JSON 表示 "名称/值对"：

    {"firstName":"Brett"}

  • 这个示例非常基本，而且实际上比等效的纯文本 "名称/值对" 占用更多的空间：

        firstName=Brett

  • 但是，当将多个 "名称/值对" 串在一起时，JSON 就会体现出它的价值了。首先，可以创建包含多个 "名称/值对" 的记录，比如：

        {"firstName":"Brett", "lastName":"McLaughlin", "email":"aaaa"}

  • 从语法方面来看，这与 "名称/值对" 相比并没有很大的优势，但是在这种情况下 JSON 更容易使用，而且可读性更好。例如，它明确地表示以上三个值都是同一记录的一部分；花括号使这些值有了某种联系。

• 2、表示数组

  • 当需要表示一组值时，JSON 不但能够提高可读性，而且可以减少复杂性。例如，假设您希望表示一个人名列表。在 XML 中，需要许多开始标记和结束标记；如果使用典型的 "名称/值对"（就像在本系列前面文章中看到的那种名 "名称/值对"），那么必须建立一种专有的数据格式，或者将键名称修改为 person1-firstName 这样的形式。如果使用 JSON，就只需将多个带花括号的记录分组在一起：

        {
            "people":[
                    {"firstName":"Brett", "lastName":"McLaughlin", "email":"aaaa"},
                    {"firstName":"Jason", "lastName":"Hunter", "email":"bbbb"},
                    {"firstName":"Elliotte", "lastName":"Harold", "email":"cccc"}
                    ]
        }

  • 这不难理解。在这个示例中，只有一个名为 people 的变量，值是包含三个条目的数组，每个条目是一个人的记录，其中包含名、姓和电子邮件地址。上面的示例演示如何用括号将记录组合成一个值。当然，可以使用相同的语法表示多个值（每个值包含多个记录）：

        {
            "programmers":[
                        {"firstName": "Brett", "lastName": "McLaughlin", "email": "aaaa"},
                        {"firstName": "Jason", "lastName": "Hunter", "email": "bbbb"},
                        {"firstName": "Elliotte", "lastName": "Harold", "email": "cccc"}
                        ],
    
            "authors":[
                    {"firstName": "Isaac", "lastName": "Asimov", "genre": "sciencefiction"},
                    {"firstName": "Tad", "lastName": "Williams", "genre": "fantasy"},
                    {"firstName": "Frank", "lastName": "Peretti", "genre": "christianfiction"
                    }
                    ],
    
            "musicians":[
                        {"firstName": "Eric", "lastName": "Clapton", "instrument": "guitar"},
                        {"firstName": "Sergei", "lastName": "Rachmaninoff", "instrument": "piano"
                        }
                        ]
        }

  • 这里最值得注意的是，能够表示多个值，每个值进而包含多个值。但是还应该注意，在不同的主条目（programmers、authors 和 musicians）之间，记录中实际的 "名称/值对" 可以不一样。JSON 是完全动态的，允许在 JSON 结构的中间改变表示数据的方式。在处理 JSON 格式的数据时，没有需要遵守的预定义的约束。所以，在同样的数据结构中，可以改变表示数据的方式，甚至可以以不同方式表示同一事物。

1.6 JSON 具体形式

• 1、对象是一个无序的 “名称/值对” 集合

  • 1）一个对象以 “{” 左括号开始，“}” 右括号结束。
  • 2）每个 “名称” 后跟一个 “:” 冒号；

  • 3）“名称/值对” 之间使用 “,” 逗号分隔。

  • 例子：表示人的一个对象：

        {
            "姓名":"大憨",
            "年龄":24
        }

• 2、数组是值（value）的有序集合

  • 1）一个数组以 “[” 左中括号开始，“]” 右中括号结束。

  • 2）值之间使用 “,” 逗号分隔。

  • 例子：一组学生

        {
            "学生": [{"姓名":"小明","年龄":23}, {"姓名":"大憨","年龄":24}]
        }
    
        说明：此 Json 对象包括了一个学生数组，而学生数组中的值又是两个 Json 对象。

• 3、值（value）可以是双引号括起来的字符串（string）、数值（number）、true、false、 null、对象（object）或者数组（array）。这些结构可以嵌套。

• 4、字符串（string）是由双引号包围的任意数量 Unicode 字符的集合，使用反斜线转义。一个字符（character）即一个单独的字符串（character string）。 字符串（string）与 C 或者 Java 的字符串非常相似。

• 5、数值（number）也与 C 或者 Java 的数值非常相似。除去未曾使用的八进制与十六进制格式。除去一些编码细节。

1.7 JSON 和 XML 的比较

• 可读性
  • JSON 和 XML 的可读性可谓不相上下，一边是简易的语法，一边是规范的标签形式，很难分出胜负。
• 可扩展性
  • XML 天生有很好的扩展性，JSON 当然也有，没有什么是 XML 可以扩展而 JSON 却不能扩展的。不过 JSON 在 Javascript 主场作战，可以存储 Javascript 复合对象，有着 XML 不可比拟的优势。
• 编码难度
  • XML 有丰富的编码工具，比如 Dom4j、JDom 等，JSON 也有提供的工具。无工具的情况下，相信熟练的开发人员一样能很快的写出想要的 XML 文档和 JSON 字符串，不过，XML 文档要多很多结构上的字符。
• 解码难度
  • XML 的解析方式有两种：
    • 一是通过文档模型解析，也就是通过父标签索引出一组标记。例如：xmlData.getElementsByTagName("tagName")，但是这样是要在预先知道文档结构的情况下使用，无法进行通用的封装。
    • 另外一种方法是遍历节点（document 以及 childNodes）。这个可以通过递归来实现，不过解析出来的数据仍旧是形式各异，往往也不能满足预先的要求。
    • 凡是这样可扩展的结构数据解析起来一定都很困难。
  • JSON 也同样如此:
    • 如果预先知道 JSON 结构的情况下，使用 JSON进 行数据传递简直是太美妙了，可以写出很实用美观可读性强的代码。如果你是纯粹的前台开发人员，一定会非常喜欢 JSON。但是如果你是一个应用开发人员，就不是那么喜欢了，毕竟 XML 才是真正的结构化标记语言，用于进行数据传递。
    • 而如果不知道 JSON 的结构而去解析 JSON 的话，那简直是噩梦。费时费力不说，代码也会变得冗余拖沓，得到的结果也不尽人意。但是这样也不影响众多前台开发人员选择 JSON。因为 json.js 中的 toJSONString() 就可以看到 JSON 的字符串结构。当然不是使用这个字符串，这样仍旧是噩梦。常用 JSON 的人看到这个字符串之后，就对 JSON 的结构很明了了，就更容易的操作 JSON。

  • 以上是在 Javascript 中仅对于数据传递的 XML 与 JSON 的解析。在 Javascript 地盘内，JSON 毕竟是主场作战，其优势当然要远远优越于 XML。如果 JSON 中存储 Javascript 复合对象，而且不知道其结构的话，我相信很多程序员也一样是哭着解析 JSON 的。

  • 除了上述之外，JSON 和 XML 还有另外一个很大的区别在于有效数据率。JSON 作为数据包格式传输的时候具有更高的效率，这是因为 JSON 不像 XML 那样需要有严格的闭合标签，这就让有效数据量与总数据包比大大提升，从而减少同等数据流量的情况下，网络的传输压力 。

1.8 iOS JSON 解析第三方框架

• JSON 解析常用的第三方框架有：JSONKit、SBJson、TouchJSON，其性从左到右依次降低。

• JSONKit 已经在 2012 年停止更新，官方说 JSONKit 比苹果原生的 NSJSONSerialization 解析速度快，实测其实苹果原生的 NSJSONSerialization 解析速度更快。

• 由于 NSJSONSerialization 在 iOS 5.0 之后才出现，NSJSONSerialization 适用于 iOS 5.0+ 版本的 iOS 开发。JSONKit 框架适用于 iOS 4.0 及以前版本的 iOS 开发。

回到顶部

2、系统方式 JSON 数据解析

• Objective-C

  • 解析 json 数据

        /*
            反序列化：将从服务器接收到的二进制数据转换成 NSDictionary / NSArray 的过程，简化程序开发，便于后续的字典转模型。
            数据必须符合 json 格式，用来接收的容器必须和 json 的最外层保持一致。
    
            NSJSONReadingMutableContainers  = (1UL << 0),  // 容器可变，NSMutableDictionary 或 NSMutableArray。
            NSJSONReadingMutableLeaves      = (1UL << 1),  // 叶子可变，返回的 JSON 对象中字符串的值为 NSMutableString。
            NSJSONReadingAllowFragments     = (1UL << 2)   // 允许 JSON 字符串最外层既不是 NSArray 也不是 NSDictionary，
                                                              但必须是有效的 JSON 片段
    
                反序列化中的可变不可变，实际用处不大，后续紧接着就是字典转模型。因此输入 0 效率最好。如果今后看到 ** 类型的参数，
            又不想获取对应的内容，传递 NULL 即可。传入 nil 不会抱错。
        */
    
        // 从本地文件中读取数据
        NSData *jsonData = [NSData dataWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"JsonDataFile" ofType:@"txt"]];
    
        // 解析 json 数据
        id result = [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:NULL];

  • 生成 json 数据

        /*
            序列化：将字典或者数组发送给服务器之前，转换成二进制数据，方便网络传输。
    
            生成 json 数据的对象必须满足以下条件：
                对象最外层必须是 NSArray 或者 NSDictionary。
                容器内的所有数据必须是 NSString, NSNumber, NSArray, NSDictionary, 或者 NSNull 类型。
                字典的所有 key 都是 NSString 格式。
                NSNumber 不能是 NaN（非数值） 或者 infinity（无限大）。
    
            NSJSONWritingOptions：
                NSJSONWritingPrettyPrinted = (1UL << 0)             漂亮的格式打印
    
                使用 0 时，生成的数据格式如下，将 JSON 数据发送给服务器时可以使用该种格式。
    
                {"age":8,"score":99,"add":"beijing","name":"xiaoxin"}
    
                使用 1 时，生成的数据格式如下，将 JSON 数据保存到本地时可以使用该种格式。
    
                {
                    "age" : 8,
                    "score" : 99,
                    "add" : "beijing",
                    "name" : "xiaoxin"
                }
        */
    
        // Foundation object
        NSDictionary *dicitionary = @{@"name":@"xiaoxin", @"age":@8, @"score":@99, @"add":@"beijing"};
    
        // 判断 Foundation 对象是否可以生成 json 数据
        BOOL isValid = [NSJSONSerialization isValidJSONObject:dicitionary];
    
        // 生成 json 数据
        NSData *jData = [NSJSONSerialization dataWithJSONObject:dicitionary options:0 error:NULL];

• Swift

  • 解析 json 数据

        /*
            反序列化：将从服务器接收到的二进制数据转换成 NSDictionary / NSArray 的过程，简化程序开发，便于后续的字典转模型。
            数据必须符合 json 格式，用来接收的容器必须和 json 的最外层保持一致。
    
            MutableContainers  // 容器可变，NSMutableDictionary 或 NSMutableArray。
            MutableLeaves      // 叶子可变，返回的 JSON 对象中字符串的值为 NSMutableString。
            AllowFragments     // 允许 JSON 字符串最外层既不是 NSArray 也不是 NSDictionary，但必须是有效的 JSON 片段
    
                反序列化中的可变不可变，实际用处不大，后续紧接着就是字典转模型。因此输入 0 效率最好。如果今后看到 ** 类型的参数，
            又不想获取对应的内容，传递 NULL 即可。传入 nil 不会抱错。
        */
    
        // 解析 json 数据
        let jsonDataDic: AnyObject? = try? NSJSONSerialization.JSONObjectWithData(jsonData!, options: .MutableContainers)

  • 生成 json 数据

        /*
            序列化：将字典或者数组发送给服务器之前，转换成二进制数据，方便网络传输。
    
            生成 json 数据的对象必须满足以下条件：
    
                对象最外层必须是 NSArray 或者 NSDictionary。
                容器内的所有数据必须是 NSString, NSNumber, NSArray, NSDictionary, 或者 NSNull 类型。
                字典的所有 key 都是 NSString 格式。
                NSNumber 不能是 NaN（非数值） 或者 infinity（无限大）。
        */
    
        // Foundation object
        let dicitionary:[String:AnyObject] = ["name":"xiaoxin", "age":8, "score":99, "add":"beijing"]
    
        // 判断 Foundation 对象是否可以生成 json 数据
        let isValid:Bool = NSJSONSerialization.isValidJSONObject(dicitionary)
    
        // 生成 json 数据
        let jData:NSData? = try? NSJSONSerialization.dataWithJSONObject(dicitionary, options: .PrettyPrinted)

回到顶部

3、JSONKit 方式 JSON 数据解析

3.1 添加 JSONKit

• GitHub 网址：https://github.com/johnezang/JSONKit

• JSONKit 使用 MRC

• Objective-C

      // 添加第三方库文件
      JSONKit
  
      // 在 TARGETS -> Build Phases -> Compile Sources -> ...in .../JSONKit 后添加
      -fno-objc-arc
  
      // 包含头文件
      #import "JSONKit.h"

• Swift

      // 添加第三方库文件
      JSONKit
  
      // 在 TARGETS -> Build Phases -> Compile Sources -> ...in .../JSONKit 后添加
      -fno-objc-arc
  
      // 创建名为 “项目名-Bridging-Header.h” 的桥接头文件，如：
      SwiftJSON-Bridging-Header.h
  
      // 在 TARGETS -> Build Setting -> Swift Compiler - Code generation -> Objective-C Bridging Header 中
      // 添加 “项目名/项目名-Bridging-Header.h” 路径，如：
      SwiftJSON/SwiftJSON-Bridging-Header.h
  
      // 在创建的桥接头文件中包含头文件
      #import "JSONKit.h"

3.2 JSONKit 数据解析

• Objective-C

  • JSONDecoder 方式解析

        // 从本地文件中读取数据
        NSData *jsonData = [NSData dataWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"JsonDataFile" ofType:@"txt"]];
    
        id result = [[JSONDecoder decoder] objectWithData:jsonData];
    
        NSLog(@"%@ %@", result, [result class]);

  • JSONString 解析

        // 单层 JSONString 解析
        /*
            如果 json 是 “单层” 的，即 value 都是字符串、数字，可以使用 objectFromJSONString
        */
    
            // 单层 JSONString 数据
            NSString *jsonStr1 = @"{\"a\":123, \"b\":\"abc\"}";
    
            // 返回可变结果使用 mutableObjectFromJSONString 方法
            NSDictionary *jsonStrDic1 = [jsonStr1 objectFromJSONString];
    
        // 嵌套 JSONString 解析
        /*
                如果 json 有嵌套，即 value 里有 array、object，如果再使用 objectFromJSONString，程序可能会报错，
            测试结果表明：使用由网络或得到的 php/json_encode 生成的 json 时会报错，但使用 NSString 定义的 json 字符串时，
            解析成功，最好使用 objectFromJSONStringWithParseOptions：
        */
    
            // 嵌套 JSONString 数据
            NSString *jsonStr2 = @"{\"a\":123, \"b\":\"abc\", \"c\":[456, \"hello\"], \"d\":{\"name\":\"张三\", \"age\":\"32\"}}";
    
            // 返回可变结果使用 mutableObjectFromJSONStringWithParseOptions 方法
            NSDictionary *jsonStrDic2 = [jsonStr2 objectFromJSONStringWithParseOptions:JKParseOptionLooseUnicode];

  • JSONData 解析

        // 单层 JSONData 解析
    
            NSData *jsonData1 = [@"{\"a\":123, \"b\":\"abc\"}" dataUsingEncoding:NSUTF8StringEncoding];
    
            // 返回可变结果使用 mutableObjectFromJSONData 方法
            NSDictionary *jsonDataDic1 = [jsonData1 objectFromJSONData];
    
        // 嵌套 JSONData 解析
    
            // 从本地文件中读取数据
            NSData *jsonData2 = [NSData dataWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"JsonDataFile" ofType:@"txt"]];
    
            // 返回可变结果使用 mutableObjectFromJSONStringWithParseOptions 方法
            NSDictionary *jsonDataDic2 = [jsonData2 objectFromJSONDataWithParseOptions:JKParseOptionLooseUnicode];

  • 生成 JSONString 数据

        // NSString -> JSONString
    
            NSString *str1 = @"{a\":123, \"b\":\"abc\"}";
    
            // 默认参数为 JKSerializeOptionNone，includeQuotes 为 YES
            NSString *jsonStrFromStr1 = [str1 JSONString];
    
            // includeQuotes 为 NO 时，编码后的数据最外层不含引号
            NSString *jsonStrFromStr2 = [str1 JSONStringWithOptions:JKSerializeOptionNone includeQuotes:NO error:nil];
    
        // NSArray/NSDictionary -> JSONString
    
            NSDictionary *dic1 = @{@"name":@"xiaoxin", @"age":@8, @"Info":@{@"score":@99, @"add":@"beijing"}};
    
            // 默认参数为 JKSerializeOptionNone
            NSString *jsonStrFromDic1 = [dic1 JSONString];
    
            NSString *jsonStrFromDic2 = [dic1 JSONStringWithOptions:JKSerializeOptionEscapeUnicode error:nil];

  • 生成 JSONData 数据

        // NSString -> JSONData
    
            NSString *str2 = @"{a\":123, \"b\":\"abc\"}";
    
            // 默认参数为 JKSerializeOptionNone，includeQuotes 为 YES
            NSData *jsonDataFromStr1 = [str2 JSONData];
    
            NSData *jsonDataFromStr2 = [str2 JSONDataWithOptions:JKSerializeOptionNone includeQuotes:NO error:nil];
    
        // NSArray/NSDictionary -> JSONData
    
            NSDictionary *dic2 = @{@"name":@"xiaoxin", @"age":@8, @"Info":@{@"score":@99, @"add":@"beijing"}};
    
            // 默认参数为 JKSerializeOptionNone
            NSData *jsonDataFromDic1 = [dic2 JSONData];
    
            NSData *jsonDataFromDic2 = [dic2 JSONDataWithOptions:JKSerializeOptionEscapeUnicode error:nil];

• Swift

  • JSONDecoder 方式解析

        // 从本地文件中读取数据
        let jsonData:NSData = NSData(contentsOfFile: NSBundle.mainBundle().pathForResource("JsonDataFile", ofType: "txt")!)!
    
        let result:AnyObject = JSONDecoder.decoder().objectWithData(jsonData)
    
        print(result);

  • JSONString 解析

        // 单层 JSONString 解析
        /*
            如果 json 是 “单层” 的，即 value 都是字符串、数字，可以使用 objectFromJSONString
        */
    
            // 单层 JSONString 数据
            let jsonStr1:String = "{\"a\":123, \"b\":\"abc\"}"
    
            // 返回可变结果使用 mutableObjectFromJSONString 方法
            let jsonStrDic1:AnyObject = jsonStr1.objectFromJSONString()
    
        // 嵌套 JSONString 解析
        /*
                如果 json 有嵌套，即 value 里有 array、object，如果再使用 objectFromJSONString，程序可能会报错，
            测试结果表明：使用由网络或得到的 php/json_encode 生成的 json 时会报错，但使用NSString 定义的 json 字符串时，
            解析成功，最好使用 objectFromJSONStringWithParseOptions：
        */
    
            // 嵌套 JSONString 数据
            let jsonStr2:String = "{\"a\":123, \"b\":\"abc\", \"c\":[456, \"hello\"], \"d\":{\"name\":\"张三\", \"age\":\"32\"}}"
    
            // 返回可变结果使用 mutableObjectFromJSONStringWithParseOptions 方法
            let jsonStrDic2:AnyObject = jsonStr2.objectFromJSONStringWithParseOptions(UInt(JKParseOptionLooseUnicode))

  • JSONData 解析

        // 单层 JSONData 解析
    
            let jsonData1:NSData = "{\"a\":123, \"b\":\"abc\"}".dataUsingEncoding(NSUTF8StringEncoding)!
    
            // 返回可变结果使用 mutableObjectFromJSONData 方法
            let jsonDataDic1:AnyObject = jsonData1.objectFromJSONData()
    
        // 嵌套 JSONData 解析
    
            // 从本地文件中读取数据
            let jsonData2:NSData = NSData(contentsOfFile: NSBundle.mainBundle().pathForResource("JsonDataFile", ofType: "txt")!)!
    
            // 返回可变结果使用 mutableObjectFromJSONDataWithParseOptions 方法
            let jsonDataDic2:AnyObject = jsonData2.objectFromJSONDataWithParseOptions(UInt(JKParseOptionLooseUnicode))

  • 生成 JSONString 数据

        // String -> JSONString
    
            let str1:String = "{a\":123, \"b\":\"abc\"}"
    
            // 默认参数为 JKSerializeOptionNone，includeQuotes 为 YES
            let jsonStrFromStr1:String = str1.JSONString()
    
            // includeQuotes 为 NO 时，编码后的数据最外层不含引号
            let jsonStrFromStr2:String = try! str1.JSONStringWithOptions(UInt(JKSerializeOptionNone), includeQuotes:false)
    
        // NSArray/NSDictionary -> JSONString
    
            let dic1:NSDictionary = ["name":"xiaoxin", "age":8, "Info":["score":99, "add":"beijing"]]
    
            // 默认参数为 JKSerializeOptionNone
            let jsonStrFromDic1:String = dic1.JSONString()
    
            let jsonStrFromDic2:String = try! dic1.JSONStringWithOptions(UInt(JKSerializeOptionEscapeUnicode))

  • 生成 JSONData 数据

        // String -> JSONData
    
            let str2:String = "{a\":123, \"b\":\"abc\"}"
    
            // 默认参数为 JKSerializeOptionNone，includeQuotes 为 YES
            let jsonDataFromStr1:NSData = str2.JSONData()
    
            // includeQuotes 为 NO 时，编码后的数据最外层不含引号
            let jsonDataFromStr2:NSData = try! str2.JSONDataWithOptions(UInt(JKSerializeOptionNone), includeQuotes:false)
    
        // NSArray/NSDictionary -> JSONData
    
            let dic2:NSDictionary = ["name":"xiaoxin", "age":8, "Info":["score":99, "add":"beijing"]]
    
            // 默认参数为 JKSerializeOptionNone
            let jsonDataFromDic1:NSData = dic2.JSONData()
    
            let jsonDataFromDic2:NSData = try! dic2.JSONDataWithOptions(UInt(JKSerializeOptionEscapeUnicode))

4、JSONKit 与 NSJSONSerialization 对比测试

    static int largeNumber = 100 * 1000;

    // JSONKit 解析

        NSData *jsonData = [NSData dataWithContentsOfURL:[NSURL URLWithString:@"http://192.168.88.200/demo.json"]];

        NSLog(@"JSONKit start");
        CFAbsoluteTime start1 = CFAbsoluteTimeGetCurrent();
        for (int i = 0; i < largeNumber; ++i) {
            [[JSONDecoder decoder] objectWithData:jsonData];
        }
        NSLog(@"JSONKit end: %f \n", CFAbsoluteTimeGetCurrent() - start1);

    // NSJSONSerialization 解析

        NSData *jsonData = [NSData dataWithContentsOfURL:[NSURL URLWithString:@"http://192.168.88.200/demo.json"]];

        NSLog(@"NSJSONSerialization start");
        CFAbsoluteTime start2 = CFAbsoluteTimeGetCurrent();
        for (int i = 0; i < largeNumber; ++i) {
            [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:NULL];
        }
        NSLog(@"NSJSONSerialization end: %f", CFAbsoluteTimeGetCurrent() - start2);