JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。JSON采用完全独立于语言的文本格式，这些特性使JSON成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成。
基础结构
JSON建构于两种结构：
1. “名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），记录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。
2. 值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）。
基础示例
简单地说，JSON 可以将 JavaScript 对象中表示的一组数据转换为字符串，然后就可以在函数之间轻松地传递这个字符串，或者在异步应用程序中将字符串从 Web 客户机传递给服务器端程序。这个字符串看起来有点儿古怪，但是 JavaScript 很容易解释它，而且 JSON 可以表示比"名称 / 值对"更复杂的结构。例如，可以表示数组和复杂的对象，而不仅仅是键和值的简单列表。
表示名称 / 值对
按照最简单的形式，可以用下面这样的 JSON 表示 "名称 / 值对" ：{ "firstName": "Brett" }
这个示例非常基本，而且实际上比等效的纯文本 "名称 / 值对" 占用更多的空间：firstName=Brett
但是，当将多个"名称 / 值对"串在一起时，JSON 就会体现出它的价值了。首先，可以创建包含多个"名称 / 值对"的 记录，比如：
{ "firstName": "Brett", "lastName":"McLaughlin", "email": "aaaa" }
从语法方面来看，这与"名称 / 值对"相比并没有很大的优势，但是在这种情况下 JSON 更容易使用，而且可读性更好。例如，它明确地表示以上三个值都是同一记录的一部分；花括号使这些值有了某种联系。
表示数组
当需要表示一组值时，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": "science fiction" },
{ "firstName": "Tad", "lastName": "Williams", "genre": "fantasy" },
{ "firstName": "Frank", "lastName": "Peretti", "genre": "christian fiction" }
],
"musicians": [
{ "firstName": "Eric", "lastName": "Clapton", "instrument": "guitar" },
{ "firstName": "Sergei", "lastName": "Rachmaninoff", "instrument": "piano" }
] }
这里最值得注意的是，能够表示多个值，每个值进而包含多个值。但是还应该注意，在不同的主条目（programmers、authors 和 musicians）之间，记录中实际的名称 / 值对可以不一样。JSON 是完全动态的，允许在 JSON 结构的中间改变表示数据的方式。
在处理 JSON 格式的数据时，没有需要遵守的预定义的约束。所以，在同样的数据结构中，可以改变表示数据的方式，甚至可以以不同方式表示同一事物。
格式应用
掌握了 JSON 格式之后，在 JavaScript 中使用它就很简单了。JSON 是 JavaScript 原生格式，这意味着在 JavaScript 中处理 JSON 数据不需要任何特殊的 API 或工具包。
将 JSON 数据赋值给变量
例如，可以创建一个新的 JavaScript 变量，然后将 JSON 格式的数据字符串直接赋值给它：
var 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": "science fiction" },
{ "firstName": "Tad", "lastName": "Williams", "genre": "fantasy" },
{ "firstName": "Frank", "lastName": "Peretti", "genre": "christian fiction" }
],
"musicians": [
{ "firstName": "Eric", "lastName": "Clapton", "instrument": "guitar" },
{ "firstName": "Sergei", "lastName": "Rachmaninoff", "instrument": "piano" }
] }
这非常简单；现在 people包含前面看到的 JSON 格式的数据。但是，这还不够，因为访问数据的方式似乎还不明显。
访问数据
尽管看起来不明显，但是上面的长字符串实际上只是一个数组；将这个数组放进 JavaScript 变量之后，就可以很轻松地访问它。实际上，只需用点号表示法来表示数组元素。所以，要想访问 programmers 列表的第一个条目的姓氏，只需在 JavaScript 中使用下面这样的代码：
people.programmers[0].lastName;
注意，数组索引是从零开始的。所以，这行代码首先访问 people变量中的数据；然后移动到称为 programmers的条目，再移动到第一个记录（[0]）；最后，访问 lastName键的值。结果是字符串值 “McLaughlin”。
下面是使用同一变量的几个示例。
people.authors[1].genre // Value is "fantasy"
people.musicians[3].lastName // Undefined. This refers to the fourth entry, and there isn't one
people.programmers[2].firstName // Value is "Elliotte"
利用这样的语法，可以处理任何 JSON 格式的数据，而不需要使用任何额外的 JavaScript 工具包或 API。
修改 JSON 数据
正如可以用点号和括号访问数据，也可以按照同样的方式轻松地修改数据：
people.musicians[1].lastName = "Rachmaninov";
在将字符串转换为 JavaScript 对象之后，就可以像这样修改变量中的数据。
转换回字符串
当然，如果不能轻松地将对象转换回本文提到的文本格式，那么所有数据修改都没有太大的价值。在 JavaScript 中这种转换也很简单：
String newJSONtext = people.toJSONString();
这样就行了！现在就获得了一个可以在任何地方使用的文本字符串，例如，可以将它用作 Ajax 应用程序中的请求字符串。
更重要的是，可以将任何JavaScript 对象转换为 JSON 文本。并非只能处理原来用 JSON 字符串赋值的变量。为了对名为 myObject的对象进行转换，只需执行相同形式的命令：
String myObjectInJSON = myObject.toJSONString();
这就是 JSON 与本系列讨论的其他数据格式之间最大的差异。如果使用 JSON，只需调用一个简单的函数，就可以获得经过格式化的数据，可以直接使用了。对于其他数据格式，需要在原始数据和格式化数据之间进行转换。即使使用 Document Object Model 这样的 API（提供了将自己的数据结构转换为文本的函数），也需要学习这个 API 并使用 API 的对象，而不是使用原生的 JavaScript 对象和语法。
最终结论是，如果要处理大量 JavaScript 对象，那么 JSON 几乎肯定是一个好选择，这样就可以轻松地将数据转换为可以在请求中发送给服务器端程序的格式。
概念比较
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的。
◆实例比较
XML和JSON都使用结构化方法来标记数据，下面来做一个简单的比较。
用XML表示中国部分省市数据如下：
<?xml version="1.0" encoding="utf-8"?>
<country>
<name>中国</name>
<province>
<name>黑龙江</name>
<cities>
<city>哈尔滨</city>
<city>大庆</city>
</cities>
</province>
<province>
<name>广东</name>
<cities>
<city>广州</city>
<city>深圳</city>
<city>珠海</city>
</cities>
</province>
</country>
用JSON表示如下：
{
{name:"中国", province:[ { name:"黑龙江", cities:{ city:["哈尔滨","大庆"] },
{name:"广东", cities:{ city:["广州","深圳","珠海"] }
}
编码的可读性，xml有明显的优势，毕竟人类的语言更贴近这样的说明结构。json读起来更像一个数据块，读起来就比较费解了。不过，我们读起来费解的语言，恰恰是适合机器阅读，所以通过json的索引.province[0].name就能够读取“黑龙江”这个值。
编码的手写难度来说，xml还是舒服一些，好读当然就好写。不过写出来的字符JSON就明显少很多。去掉空白制表以及换行的话，JSON就是密密麻麻的有用数据，而xml却包含很多重复的标记字符。
最新版本: https://github.com/json-c/json-c
编译假如出错时:忽略指定库libcmt.lib libcmdtd.lib(debug) 在哪加不用我说吧
解析的时候有一点点小问题 :比如 http://baidu.com 解出来后是http:/baidu.com ，需修改原代码
json_object.c 中 json_escape_st函数大约第20行的位置
else if(c == '/') printbuf_memappend(pb, "\/", 2);
改为else if(c == '/') printbuf_memappend(pb, "/", 1);
我是这么做的，成功！
json_object的格式:（注意：一个json对象内可以包含多个json对象）
{'latitude':116.40091896057129,'longitude':39.931129903495886}
json_object数组的格式：
"[{'latitude':116.40091896057129,'longitude':39.931129903495886},
{'latitude':116.40194892883301,'longitude':39.946134395563796},
{'latitude':116.39645576477051,'longitude':39.95488549657055}]"
序言：json提供的方法就是处理：
基础数据类型（在json中冶同为json对象）：int,bool,float,double等等，
json类型：与{'latitude':116.40091896057129,'longitude':39.931129903495886}（这里面包含了2个json对象，而每个json对象{'latitude':116.40091896057129}中又包含了一个json对象：39.95488549657055）
json数组
一，json_object.h：创建Json对象：json_object_new 开头
A，创建一个Json对象：
struct json_object * json_object_new_object (void)
B,创建一个Json数组对象：
struct json_object * json_object_new_array (void)
二，json_tokener.h：将json格式的string转化为json对象的方法：失败返回null
1.structjson_object* json_tokener_parse(const char *str)
//例如：json_object *req_json = json_tokener_parse( req_buf->buf );
三，json_object.h：将json对象转化为json格式的string：失败返回null
const char * json_object_to_json_string (struct json_object *obj)
//将json_object转化为json格式的string,这个方法与后面的json_object_get_string不同，大家知道json对象的结构为：key:test value :haha ；那么to_json_string对象后，结构为：='latitude':116.40091896057129,'longitude':39.931129903495886
而json_object_get_string仅仅负责对单纯"test"的json对象转化，例如：
json_object * j_o = json_object_new_string("test");
char * pointer_char = json_object_get_string(j_o); //结果pointer_char 为"test"
四，json_object.h：向json_object内的增删查：无改操作
添加：void json_object_object_add (struct json_object *obj, const char *key, struct json_object *val)
//例如：json_object_object_add(item, "id", json_object_new_int(_id));
查询：struct json_object * json_object_object_get (struct json_object *obj, const char *key)
删除：void json_object_object_del (struct json_object *obj, const char *key)
五，json_object.h：将其他基础数据类型转化为json基础类型的方法：
1,struct json_object * json_object_new_int (int i)
2,struct json_object * json_object_new_double (double d)
3,struct json_object * json_object_new_string (const char *s)
4,struct json_object * json_object_new_boolean (boolean b)
5,struct json_object * json_object_new_string_len (const char *s, int len)
(获得s的部分字符串，并转换为json对象)
六，json_object.h：将基础数据类型的Json对象转化为另外一个json对象以及转化为其他基础数据类型：json_object_get
1,struct json_object * json_object_get (struct json_object *obj)
//将json对象转化为另外一个json对象
2.struct lh_table * json_object_get_object (struct json_object *obj)
//将json_object转化为lh_table
3.struct array_list * json_object_get_array (struct json_object *obj) //将
json_object转化为array_list
4,boolean json_object_get_boolean (struct json_object *obj)
//将json_object转化为boolean
5.int json_object_get_int (struct json_object *obj)
//将json_object转化为int
6,double json_object_get_double (struct json_object *obj)
//将json_object 转化为double
7.const char * json_object_get_string (struct json_object *obj)
//将json_object转化为char *
七，json_object.h：销毁一个json对象：
void json_object_put (struct json_object *obj)
八，json_object.h：判断json_object的类型是否为基础数据类型type，是：0，否：1：
int json_object_is_type (struct json_object *obj, enum json_type type)
九，json_object.h：获得json_object的基础类型：
enum json_type json_object_get_type (struct json_object *obj)
其中：enum json_type 为：
Enumerator:
json_type_null
json_type_boolean
json_type_double
json_type_int
json_type_object
json_type_array
json_type_string
十，json_object.h：json数组：注意：json数组本身也为json_object，其为基类
1，创建json数组：
struct json_object * json_object_new_array (void)
2，将json数组转化为arraylist：
struct array_list * json_object_get_array (struct json_object *obj)
3，获得json数组的长度：
int json_object_array_length (struct json_object *obj)
4，向json数组obj内添加一个json_object：val
int json_object_array_add (struct json_object *obj, struct json_object *val)
，其中obj为json数组，val为需要添加的对象
5，Insert or replace an element at a specified index in an array (a json_object of type json_type_array)
int json_object_array_put_idx (struct json_object *obj, int idx, struct json_object *val)
//向obj中的idx位置，update或insert 对象val
6，获得json数组中的某一特定的对象：
struct json_object * json_object_array_get_idx (struct json_object *obj, int idx)
3.struct json_object * json_object_object_get (struct json_object *obj, const char *key)
//从json_object对象中，通过key，获得value，例如：
json_object *req_json = NULL; json_object_object_get(req_json,"ver"));
json对象结构 key：value
过程：使用JSON从接收的数据中，先查询到相应的对象（集体）JsonInit，比较对象中的key找到需要的对象名，把对象名转换为常量字符串
实际使用例子：
//解析app发过来的绑定报文
if((pMsgObj = json_tokener_parse((LD_S8 *)(pReqMsg+1))))//将json格式的string转化为json对象
{
while(i < 2)//使用JSON从接收的数据中，先查询到相应的对象（集体）JsonInit，
{//比较对象中的key找到需要的对象名，把对象名转换为常量字符串
if((pTmpObj = json_object_object_get(pMsgObj, pArgType[i])))////从json_object对象中，通过key，获得value
{//value为JSON基础类型JSON对象
break;
}
++i;
}
if(i >= 2 || !(pTmpStr = json_object_get_string(pTmpObj)))//将JSON基础类型JSON对象转换为字符串
{
goto exit1;
}
}
else
{
//return NULL;
goto exit1;
}
if(!(pBody = json_object_new_object()))//创建新的对象
{
goto exit1;
}
//生成向云服务器发起的绑定请求
json_object_object_add(pBody, pArgType[i],
json_object_new_string(pTmpStr));//在对象里添加key vaule
json_object_object_add(pBody, K_TOKEN,
json_object_new_string(token));
if(gpCC->ccArg.resetFlag)
{
json_object_object_add(pBody, K_RESET_FLAG,
json_object_new_boolean(LD_TRUE));//布尔型转换为JSON基础类型
}
else
{
json_object_object_add(pBody, K_RESET_FLAG,
json_object_new_boolean(LD_FALSE));//vaule为JSON基础类型
}
JsonInit（）
json_tokener_parse
json_object_new_object()
json_object_object_add(pResBody, K_TOKEN, json_object_new_string(token));
json_object_object_add(pResRoot, K_BODY, pResBody);
if((pRootStr = json_object_get_string(pResRoot)))//
json_object_get（obj） //将json对象转换为另外一个json对象
json_object_get_object（obj）//将json对象转换为Ih_table
json_object_object_get(resInfo.pResBody, K_RESULT_CODE)
查询，resInfo.pResBody对象名，K_RESULT_CODE常量字符key
json_object_put(obj)//销毁一个json对象
json_object_new_array()//创建一个json数组对象
json_object_array_add(pListObj, pTmpObj);//pListObj为json数组，pTmpObj为需要添加的对象
使用方法
pBody = json_object_new_object()//创建一个json对象,返回值是一个对象（字符串）结构体
json_object_object_add(pBody, K_TOKEN, json_object_new_string(token));//向对象内增加一对名称/值，返回值空
pBody为对象，K_TOKEN为常量字符key，json_object_new_string(token)为值
json_object_new_string(token)//将其他基础数据类型转换为json基础类型
token为常量字符串，返回值是一个对象（字符串）结构体
pReqStr = json_object_get_string(pBody）//将JSON对象名称转换为JSON格式的STRING
将json对象转化会char*，返回值为const char * （常量字符串）
json_object_object_get(resInfo.pResBody, K_RESULT_CODE)返回值是一个对象结构体（查询到的）
查询，resInfo.pResBody对象名，K_RESULT_CODE常量字符key
json_object_put(obj)//销毁一个json对象
JSON建构于两种结构：
1. “名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），记录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。
按照最简单的形式，可以用下面这样的 JSON 表示 "名称 / 值对" ：{ "firstName": "Brett" }
2. 值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）。
{ "people": [
{ "firstName": "Brett", "lastName":"McLaughlin", "email": "aaaa" },
{ "firstName": "Jason", "lastName":"Hunter", "email": "bbbb"},
{ "firstName": "Elliotte", "lastName":"Harold", "email": "cccc" }
]}
在这个示例中，只有一个名为 people的变量，值是包含三个条目（三个对象元素）的数组，每个条目是一个人的记录，其中包含名、姓和电子邮件地址