文章目录
综述
- JSON: JavaScript Object Notation(JavaScript 对象表示法),
是轻量级的存储和交换文本信息的语法
,类似 XML . 特点是纯文本(纯字符串)、层级结构、使用数组。 - cJSON:一个基于 C 语言的 Json 库,下载地址:https://github.com/DaveGamble/cJSON
- cJSON的源码文件只有两个:
cJSON.h
和cJSON.c
- 在 cJSON 库中节点的从属关系是通过
树
来维护的,每一层节点都是通过链表
来维护的,这样就能分析出该函数参数的含义,每个对象是树的一个节点,每个节点由cJSON这个结构体组成,对象中的元素也可以由cJSON这个结构体组成,由child指针指向该结构体
API
cJSON结构体
typedef struct cJSON {
struct cJSON *next,*prev; //遍历数组或对象链的前向或后向链表指针
struct cJSON *child; //数组或对象的孩子节点
int type; //key的类型
char *valuestring; // value值是字符串类型
int valueint; // value值是整型类型
double valuedouble; // value值是浮点数类型
char *string; // key的名字
} cJSON;
结构体成员:
- cJOSN 结构体是一个
双向链表
,并且可通过child 指针访问下一层
。同一层的对象和元素是双向链表结构,由next和prev指针链接。不同层的对象或元素由child指针链接起来。 - 结构体成员 type 变量用于描述数据元素的类型(如果是键值对
表示 value 值的类型
),数据元素可以是字符串、整形、浮点型。- 如果是整形值的话可通过
valueint
将值取出 - 如果是浮点型的话可通过
valuedouble
将值取出 - 如果是字符串类型的话可通过
valuestring
将值取出
- 如果是整形值的话可通过
- 结构体成员 string 表示键值对中键值的名称。
节点类型值:7种
/* cJSON Types: */
#define cJSON_False 0
#define cJSON_True 1
#define cJSON_NULL 2
#define cJSON_Number 3
#define cJSON_String 4
#define cJSON_Array 5
#define cJSON_Object 6
#define cJSON_Raw 7 /* raw json */
数据的封装
在 cJSON.h 头文件中可以看到一些函数声明,通过调用这些创建函数就可以将 Json 支持的数据类型封装为 cJSON 结构体类型:
// 空值类型
extern cJSON *cJSON_CreateNull(void);
// 布尔类型
extern cJSON *cJSON_CreateTrue(void);
extern cJSON *cJSON_CreateFalse(void);
extern cJSON *cJSON_CreateBool(int b);
// 数值类型
extern cJSON *cJSON_CreateNumber(double num);
// 字符串类型
extern cJSON *cJSON_CreateString(const char *string);
创建数组或对象:
// json数组(创建空数组)
extern cJSON *cJSON_CreateArray(void);
// json对象(创建空对象)
extern cJSON *cJSON_CreateObject(void);
cJSON_CreateObject()和cJSON_CreateArray
函数创造的数据不使用时需要使用cJSON_Delete()
释放空间
在创建数组的同时还可以进行初始化:
// 创建一个Json数组, 元素为整形
extern cJSON *cJSON_CreateIntArray(const int *numbers,int count);
// 创建一个Json数组, 元素为浮点【这个使用会出问题,需要浮点型可以使用双浮点。】
extern cJSON *cJSON_CreateFloatArray(const float *numbers,int count);
// 创建一个Json数组, 元素为双浮点型
extern cJSON *cJSON_CreateDoubleArray(const double *numbers,int count);
// 创建一个Json数组, 元素为字符串类型【这个使用会出问题】
extern cJSON *cJSON_CreateStringArray(const char **strings,int count);
Json 对象操作
当得到一个 Json 对象之后,就可以往对象中添加键值对了
extern void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item);
参数:
- object:要添加的键值对从属于那个节点
- string:添加的键值对的键值
- item:添加的键值对的 value 值(需要先将其封装为 cJSON 类型的结构体)
在 cJSON 库中节点的从属关系是通过
树
来维护的,每一层节点都是通过链表
来维护的,这样就能分析出该函数参数的含义
为了让操作更加方便,cJson 库还提供了一些宏函数
,方便快速的往 Json 对象中添加键值对:
#define cJSON_AddNullToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateNull()) //在对象中添加null
#define cJSON_AddTrueToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateTrue()) //在对象中添加true
#define cJSON_AddFalseToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateFalse()) //在对象中添加false
#define cJSON_AddBoolToObject(object,name,b) cJSON_AddItemToObject(object, name, cJSON_CreateBool(b)) //在对象中添加布尔值
#define cJSON_AddNumberToObject(object,name,n) cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))//在对象中添加数字
#define cJSON_AddStringToObject(object,name,s) cJSON_AddItemToObject(object, name, cJSON_CreateString(s))//在对象中添加字符串
还可以根据 Json 对象中的键值取出相应的 value 值,API 函数原型如下:
extern cJSON *cJSON_GetObjectItem(cJSON *object,const char *string);
Json 数组操作
添加数据到 Json 数组中(原始数据需要先转换为 cJSON 结构体类型):
extern void cJSON_AddItemToArray(cJSON *array, cJSON *item);
参数:
- array:要添加的键值对从属于那个节点
- item:添加的键值对的 value 值(需要先将其封装为 cJSON 类型的结构体)
得到 Json 数组中元素的个数:
extern int cJSON_GetArraySize(cJSON *array);
得到 Json 数组中指定位置的元素,如果返回 NULL 表示取值失败:
extern cJSON *cJSON_GetArrayItem(cJSON *array,int item);
序列化
序列化就是将 Json 格式的数据转换为字符串的过程
,cJson 库中提供了 3 个转换函数:
extern char *cJSON_Print(cJSON *item);
extern char *cJSON_PrintUnformatted(cJSON *item);
extern char *cJSON_PrintBuffered(cJSON *item,int prebuffer,int fmt);
参数:
- 其中第一个参数 item 表示 Json 数据块的根节点。
区别:
- 调用 cJSON_Print() 函数可以得到一个带格式的 Json 字符串(有换行,看起来更直观)
- 调用 cJSON_PrintUnformatted() 函数会得到一个没有格式的 Json 字符串(没有换行,所有的数据都在同一行)。
- 调用 cJSON_PrintBuffered() 函数使用缓冲策略将 Json 实体转换为字符串,参数 prebuffer 是指定缓冲区的大小,参数
fmt==0
表示未格式化,fmt==1
表示格式化。
cJSON_PrintUnformatted,cJSON_Print,cJSON_PrintBuffered,这种转换函数,会自动为指针申请空间,我们使用完之后一定要及时释放空间:
free
。
Json 字符串的解析
如果得到了一个 Json 格式的字符串
,想要读出里边的数据,就需要对这个字符串进行解析,处理方式就是将字符串转换为 cJSON 结构体
,然后再基于这个结构体读里边的原始数据,转换函数的函数原型如下:
extern cJSON *cJSON_Parse(const char *value);
参数:
- value:Json格式的字符串
内存释放
cJSON的所有操作都是基于链表的,所以cJSON在使用过程中大量的使用malloc
从堆中分配动态内存的,所以在使用完之后,应当及时调用下面的函数,清空cJSON指针所指向的内存,可以调用 cJson 库提供的删除函数 cJSON_Delete():
extern void cJSON_Delete(cJSON *c);
该函数的参数为要释放的节点的地址,在此强调一点:在进行内存地址释放的时候,
当前节点以及其子节点(嵌套关系)都会被删除
。所以一旦我们删除了父对象再删除子对象会出现问题
Json 数据的封装
Json 对象操作举例
创建一个对象,并向这个对象里添加字符串和整型键值:
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"cJSON.h"
int main()
{
cJSON *root = NULL;//创建头指针
cJSON *arry = NULL;
root=cJSON_CreateObject(); // 创建头结点,并将头指针指向头结点
cJSON_AddStringToObject(root,"name","luffy"); // 添加键值对(向链表中添加节点)
cJSON_AddStringToObject(root,"sex","man"); // 添加键值对(向链表中添加节点)
cJSON_AddNumberToObject(root,"age",19); // 添加键值对(向链表中添加节点)
char *out = cJSON_Print(root); // 将json形式转换成字符串
printf("%s\n",out);
// 释放内存
cJSON_Delete(root);
free(out);//函数 cJSON_Print() 内部封装了 malloc 函数,所以需要使用 free() 函数释放被 out 占用的内存空间。
}
Json 数组操作举例
创建一个数组,并向数组添加一个字符串和一个数字:
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"cJSON.h"
int main(int argc, char **argv)
{
cJSON *root;
root = cJSON_CreateArray();
cJSON_AddItemToArray(root, cJSON_CreateString("Hello world"));
cJSON_AddItemToArray(root, cJSON_CreateNumber(10));
// char *s = cJSON_Print(root);
char *s = cJSON_PrintUnformatted(root);//序列化,不换行
if(s)
{
printf(" %s \n",s);
free(s);
}
cJSON_Delete(root);
return 0;
}
Json 对象、数组嵌套使用
数据格式:
{
"person":[{
"name":"luffy",
"age":19
}]
}
对象里面包括一个数组,数组里面包括对象,对象里面再添加一个字符串和一个数字:
int main(int argc, char **argv)
{
cJSON *root, *body, *list;
// josn 对象 root
root = cJSON_CreateObject();
// root 添加键值对 person:json数组A
cJSON_AddItemToObject(root,"person", body = cJSON_CreateArray());
// json数组A 添加Json对象B
cJSON_AddItemToArray(body, list = cJSON_CreateObject());
// 在json对象B中添加键值对: "name":"luffy"
cJSON_AddStringToObject(list,"name","luffy");
// 在json对象B中添加键值对: "age":19
cJSON_AddNumberToObject(list,"age",19);
// char *s = cJSON_Print(root);
char *s = cJSON_PrintUnformatted(root);//序列化,非格式化
if(s)
{
printf(" %s \n",s);
free(s);
}
if(root)
{
cJSON_Delete(root);
}
return 0;
}
解析 Json 字符串
解析 Json 对象
数据格式:
{\"name\":\"luffy\",\"sex\":\"man\",\"age\":19}
字符串中的双引号需要通过转义字符将其转译为普通字符:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cJSON.h"
int main()
{
cJSON *json, *name, *sex, *age;
char* out="{\"name\":\"luffy\",\"sex\":\"man\",\"age\":19}";
json = cJSON_Parse(out); //将json字符串转换为 cJSON 结构体
name = cJSON_GetObjectItem(json, "name"); //获取键值内容
sex = cJSON_GetObjectItem(json, "sex");
age = cJSON_GetObjectItem(json, "age");
//注:在本示例中,因为我提前知道数据的类型,比如字符型或者浮点型,所以我直接使用指针指向对应的数据域提取,
//在实际使用时,如果提前不确定数据类型,应该先判断type的值,确定数据类型,再从对应的数据域中提取数据。
printf("name:%s,sex:%s,age:%d\n", name->valuestring, sex->valuestring, age->valueint);
cJSON_Delete(json); //释放内存
}
解析嵌套的 Json 对象
数据格式:
{\"list\":{\"name\":\"luffy\",\"age\":19},\"other\":{\"name\":\"ace\"}}
解析一个嵌套的 Json 对象:
int main()
{
char *s = "{\"list\":{\"name\":\"luffy\",\"age\":19},\"other\":{\"name\":\"ace\"}}";
cJSON *root = cJSON_Parse(s); //将json字符串转换为 cJSON 结构体
if(!root)
{
printf("get root faild !\n");
return -1;
}
cJSON *js_list = cJSON_GetObjectItem(root, "list");
if(!js_list)
{
printf("no list!\n");
return -1;
}
printf("list type is %d\n",js_list->type);
cJSON *name = cJSON_GetObjectItem(js_list, "name");
if(!name)
{
printf("No name !\n");
return -1;
}
printf("name type is %d\n",name->type);
printf("name is %s\n",name->valuestring);
cJSON *age = cJSON_GetObjectItem(js_list, "age");
if(!age)
{
printf("no age!\n");
return -1;
}
printf("age type is %d\n", age->type);
printf("age is %d\n",age->valueint);
cJSON *js_other = cJSON_GetObjectItem(root, "other");
if(!js_other)
{
printf("no list!\n");
return -1;
}
printf("list type is %d\n",js_other->type);
cJSON *js_name = cJSON_GetObjectItem(js_other, "name");
if(!js_name)
{
printf("No name !\n");
return -1;
}
printf("name type is %d\n",js_name->type);
printf("name is %s\n",js_name->valuestring);
if(root)
{
cJSON_Delete(root);
}
return 0;
}
解析 Json 数组
数据格式:
{\"names\":[\"luffy\",\"robin\"]}
解析json数组:
int main(int argc, char **argv)
{
char *s = "{\"names\":[\"luffy\",\"robin\"]}";
cJSON *root = cJSON_Parse(s); //将json字符串转换为 cJSON 结构体
if(!root)
{
printf("get root faild !\n");
return -1;
}
cJSON *js_list = cJSON_GetObjectItem(root, "names");
if(!js_list)
{
printf("no list!\n");
return -1;
}
int array_size = cJSON_GetArraySize(js_list);
printf("array size is %d\n",array_size);
for(int i=0; i< array_size; i++)
{
cJSON *item = cJSON_GetArrayItem(js_list, i);
printf("item type is %d\n",item->type);
printf("%s\n",item->valuestring);
}
if(root)
{
cJSON_Delete(root);
}
return 0;
}
解析嵌套的 Json 对象和数组
数据格式:
{\"list\":[{\"name\":\"luffy\",\"age\":19},{\"name\":\"sabo\",\"age\":21}]}
在解析的时候,我们只需要按照从属关系,一层层解析即可:
- 根节点是一个 Json 对象,基于根节点中的 key 值取出对应的 value 值,得到一个 Json 数组
- 读出 Json 数组的大小,遍历里边的各个元素,每个元素都是一个 Json 对象
- 将 Json 对象中的键值对根据 key 值取出对应的 value 值
- 从取出的 Value 值中读出实际类型对应的数值 示例代码如下:
#include "cJSON.h"
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
char *s = "{\"list\":[{\"name\":\"luffy\",\"age\":19},{\"name\":\"sabo\",\"age\":21}]}";
cJSON *root = cJSON_Parse(s);//将json字符串转换为 cJSON 结构体
if(!root)
{
printf("get root faild !\n");
return -1;
}
cJSON *list = cJSON_GetObjectItem(root, "list");
if(!list)
{
printf("no list!\n");
return -1;
}
int array_size = cJSON_GetArraySize(list);
printf("array size is %d\n",array_size);
for(int i=0; i< array_size; i++)
{
cJSON* item = cJSON_GetArrayItem(list, i);//根据下标获取cJson对象
cJSON* name = cJSON_GetObjectItem(item, "name");
printf("name is %s\n",name->valuestring);
cJSON* age = cJSON_GetObjectItem(item, "age");
printf("age is %d\n",age->valueint);
}
if(root)
{
cJSON_Delete(root);
}
return 0;
}
参考博文:
C语言Json库 —— cJson