cJSON是C语言中的一个JSON编解码器，非常轻量级，C文件只有不到一千行，代码的可读性也很好，很适合作为C语言项目进行学习。项目主页：
https://sourceforge.net/projects/cjson/

对于json格式编码与解码，其实就是类似于一个解释器，主要原理还是运用递归。个人认为，如果能用一些支持面向对象的语言来做这个项目，代码实现起来应该会更加优雅。

先来看一下cJSON的数据结构：

/* The cJSON structure: */
typedef struct cJSON {
    struct cJSON *next,*prev;   /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
    struct cJSON *child;        /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */

    int type;                   /* The type of the item, as above. */

    char *valuestring;          /* The item's string, if type==cJSON_String */
    int valueint;               /* The item's number, if type==cJSON_Number */
    double valuedouble;         /* The item's number, if type==cJSON_Number */

    char *string;               /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
} cJSON;

不管是数值类型、字符串类型或者对象类型等都使用该结构体，类型信息通过标识符 type来进行判断，cJSON总共定义了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

另外，如果是对象或者数组，采用的是双向链表来实现，链表中的每一个节点表示数组中的一个元素或者对象中的一个字段。其中child表示头结点，next、prev分别表示下一个节点和前一个节点。valuestring、valueint、valuedouble分别表示字符串、整数、浮点数的字面量。string表示对象中某一字段的名称，比如有这样的一个json字符串：

{'age': 20}

'age'则用结构体中的string来表示。

cJSON的api使用起来非常简单：

char *out;cJSON *json;
    
json=cJSON_Parse(text);
if (!json) {
    printf("Error before: [%s]\n",cJSON_GetErrorPtr());
} else {
    out=cJSON_Print(json);
    cJSON_Delete(json);
    printf("%s\n",out);
    free(out);
}

代码都是自解释的就不啰嗦，唯一需要注意的是使用完成后，必须释放内存，以免内存泄露。

JSON的解析

下面我们先来看一下json字符串的解析，json的字符串的解析主要是通过cJSON_Parse函数来完成，打开cJSON_Parse函数后，我们发现该函数使用了另外一个辅助函数：

/* Default options for cJSON_Parse */
cJSON *cJSON_Parse(const char *value) {
    return cJSON_ParseWithOpts(value,0,0);
}

cJSON_ParseWithOpts提供了一些额外的参数选项：

/* Parse an object - create a new root, and populate. */
cJSON *cJSON_ParseWithOpts(const char *value, const char **return_parse_end, int require_null_terminated) {
    const char *end = 0;
    cJSON *c = cJSON_New_Item();
    ep = 0;
    if (!c) return 0;       /* memory fail */

    end = parse_value(c, skip(value));
    if (!end) {
        cJSON_Delete(c);
        return 0;
    }    /* parse failure. ep is set. */

    /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
    if (require_null_terminated) {
        end = skip(end);
        if (*end) {
            cJSON_Delete(c);
            ep = end;
            return 0;
        }
    }
    if (return_parse_end) *return_parse_end = end;
    return c;
}

第一步：先调用cJSON_New_Item创建一个节点，该函数实现非常简单，就是使用malloc分配一块内存，再将分配的内存使用0来进行初始化。

/* Internal constructor. */
static cJSON *cJSON_New_Item(void)
{
    cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON));
    if (node) memset(node,0,sizeof(cJSON));
    return node;
}

第二步：调用parse_value函数进行真正的解析，该函数是json解析的核心部分，后面我们会重点分析。而在解析前，先对json字符串调用了一次skip，其实就是将字符串前面的的一些空字符去除，代码如下：

/* Utility to jump whitespace and cr/lf */
static const char *skip(const char *in) {
    while (in && *in && (unsigned char) *in <= 32) in++;
    return in;
}

最后一步：函数中参数中提供了require_null_terminated是为了确保json字符串必须以'\0'字符作为结尾。若参数提供了return_parse_end，将返回json字符串解析完成后剩余的部分。

下面来看json解析算法的核心部分：

static const char *parse_value(cJSON *item, const char *value) {
    if (!value) return 0;    /* Fail on null. */
    //若字符串等于null，直接将type标记为cJSON_NULL
    if (!strncmp(value, "null", 4)) {
        item->type = cJSON_NULL;
        return value + 4;
    }
    //若字符串等于false，直接将type标记为cJSON_False
    if (!strncmp(value, "false", 5)) {
        item->type = cJSON_False;
        return value + 5;
    }
    //若字符串等于true，直接将type标记为cJSON_True
    if (!strncmp(value, "true", 4)) {
        item->type = cJSON_True;
        item->valueint = 1;
        return value + 4;
    }
    //若字符串以\"开头，说明是一个字符串
    if (*value == '\"') { return parse_string(item, value); }
    //若字符串以0~9或者-开头，则是一个数值
    if (*value == '-' || (*value >= '0' && *value <= '9')) { return parse_number(item, value); }
    //若字符串以[开头，则是一个数组
    if (*value == '[') { return parse_array(item, value); }
    //若字符串以{开头，则是一个对象
    if (*value == '{') { return parse_object(item, value); }

    ep = value;
    return 0;    /* failure. */
}

上述 代码看上去应该清晰易懂，且都已加入注释。对于json为null、true或者false的情况，直接将type置为对应的类型即可。对于其他情况，需要分别再做处理，先来看json为字符串的情况：

static const char *parse_string(cJSON *item, const char *str) {
    const char *ptr = str + 1;
    char *ptr2;
    char *out;
    int len = 0;
    unsigned uc, uc2;
    if (*str != '\"') {
        ep = str;
        return 0;
    }    /* not a string! */

    /* 这一步主要是为了确定字符串的长度，以便下一步进行内存分配
     * 问题在于字符串中可能存在一定的转义字符，由于json字符串本身
     * 是一个字符串，碰到像双引号必须进行转义，另外像\t这样的转义
     * 字符，需要再次转义，用\\t来表示。而在解析的时候，我们不需要
     * 这些多余的转义字符。（说得有点绕，不知道能不能看明白）
     */
    while (*ptr != '\"' && *ptr && ++len) 
        if (*ptr++ == '\\') ptr++;   

    //分配内存，保存解析后的结果
    out = (char *) cJSON_malloc(len + 1);
    if (!out) return 0;

    ptr = str + 1; //跳过第一个\"
    ptr2 = out;
    //当遇到\"时，说明到达字符串的末尾
    while (*ptr != '\"' && *ptr) {
        //如果不是转义字符，直接原样复制
        if (*ptr != '\\') *ptr2++ = *ptr++;
        else { //碰到像\\b的再转义字符，改成\b
            ptr++;
            switch (*ptr) {
                case 'b':
                    *ptr2++ = '\b';
                    break;
                case 'f':
                    *ptr2++ = '\f';
                    break;
                case 'n':
                    *ptr2++ = '\n';
                    break;
                case 'r':
                    *ptr2++ = '\r';
                    break;
                case 't':
                    *ptr2++ = '\t';
                    break;
                case 'u':     /*这里将 utf16 转为 utf8，算法比较复杂，不做分析 */
                    uc = parse_hex4(ptr + 1);
                    ptr += 4;    /* get the unicode char. */

                    if ((uc >= 0xDC00 && uc <= 0xDFFF) || uc == 0) break;    /* check for invalid.  */

                    if (uc >= 0xD800 && uc <= 0xDBFF)    /* UTF16 surrogate pairs.  */
                    {
                        if (ptr[1] != '\\' || ptr[2] != 'u') break;    /* missing second-half of surrogate. */
                        uc2 = parse_hex4(ptr + 3);
                        ptr += 6;
                        if (uc2 < 0xDC00 || uc2 > 0xDFFF) break;    /* invalid second-half of surrogate.    */
                        uc = 0x10000 + (((uc & 0x3FF) << 10) | (uc2 & 0x3FF));
                    }

                    len = 4;
                    if (uc < 0x80) len = 1; else if (uc < 0x800) len = 2; else if (uc < 0x10000) len = 3;
                    ptr2 += len;

                    switch (len) {
                        case 4:
                            *--ptr2 = ((uc | 0x80) & 0xBF);
                            uc >>= 6;
                        case 3:
                            *--ptr2 = ((uc | 0x80) & 0xBF);
                            uc >>= 6;
                        case 2:
                            *--ptr2 = ((uc | 0x80) & 0xBF);
                            uc >>= 6;
                        case 1:
                            *--ptr2 = (uc | firstByteMark[len]);
                    }
                    ptr2 += len;
                    break;
                default:
                    *ptr2++ = *ptr;
                    break;
            }
            ptr++;
        }
    }
    *ptr2 = 0;
    if (*ptr == '\"') ptr++;
    item->valuestring = out;
    item->type = cJSON_String;
    return ptr;
}

解析字符串的困难之处在于可能会碰到转义字符，需要将类似于\\t这样的再转义字符转化为\t，对于如何将utf16转为utf8的算法比较复杂，我就不做分析了。其他情况原样复制即可。

下面是解析数值类型的代码：

static const char *parse_number(cJSON *item, const char *num) {
    double n = 0, sign = 1, scale = 0;
    int subscale = 0, signsubscale = 1;

    if (*num == '-') sign = -1, num++;    /*如果是负数，将sign置位-1 */
    if (*num == '0') num++;            /* 如果是0，直接越过 */
    if (*num >= '1' && *num <= '9') /* 碰到数字1~9，用循环计算整数部分的数值 */
        do n = (n * 10.0) + (*num++ - '0'); while (*num >= '0' && *num <= '9');    
    if (*num == '.' && num[1] >= '0' && num[1] <= '9') { /* 遇到小数点，计算小数位的数值，用scale来标记小数有多少位 */
        num++;
        do n = (n * 10.0) + (*num++ - '0'), scale--; while (*num >= '0' && *num <= '9');
    }    
    if (*num == 'e' || *num == 'E')     /* 遇到指数，计算指数位的数值 */
    {
        num++;
        if (*num == '+') num++; else if (*num == '-') signsubscale = -1, num++;       
        while (*num >= '0' && *num <= '9') subscale = (subscale * 10) + (*num++ - '0');   
    }

   /* 最后根据前面的得到的数值，计算最终的结果 */
    n = sign * n * pow(10.0, (scale + subscale * signsubscale));    /* number = +/- number.fraction * 10^+/- exponent */

    item->valuedouble = n;
    item->valueint = (int) n;
    item->type = cJSON_Number;
    return num;
}

这部分代码也不难，花点时间应该就能看懂。主要是考虑了小数和指数的情况，会带来一定的复杂性。 吐槽一下作者把if语句块中的代码都写在一行上，导致看起来很费劲。

接下来是如何解析数组：

static const char *parse_array(cJSON *item, const char *value) {
    cJSON *child;
    if (*value != '[') { //不是一个数组，直接返回
        ep = value;
        return 0;
    }   

    item->type = cJSON_Array;
    value = skip(value + 1); //跳过前面的空白字符
    if (*value == ']') return value + 1;    /* 空数组 */

    //创建数组的头结点，表示数组的第一个元素
    item->child = child = cJSON_New_Item();
    if (!item->child) return 0;      
    //对数组中的第一个元素递归调用parse_value 
    value = skip(parse_value(child, skip(value))); 
    if (!value) return 0;

    //如果数组第一个元素后面存在逗号，说明还有其他元素
    //对剩下的元素同样递归调用parse_value，并将后面的元素
    //放在child节点的尾部，形成一个链表
    while (*value == ',') {
        cJSON *new_item;
        if (!(new_item = cJSON_New_Item())) return 0;   
        //移动指针
        child->next = new_item;
        new_item->prev = child;
        child = new_item;
        
        value = skip(parse_value(child, skip(value + 1)));
        if (!value) return 0;
    }

    if (*value == ']') return value + 1;    /* 达到数组的尾部 */
    ep = value;
    return 0;
}

解析数组时，其基本思想是对数组中每一个元素递归调用parse_value，再将这些元素连接形成一个链表。

如果能看懂数组的解析过程，对象的解析对你来说应该也不难，直接来看代码：

static const char *parse_object(cJSON *item, const char *value) {
    cJSON *child;
    if (*value != '{') {
        ep = value;
        return 0;
    }    //不是一个对象，直接返回

    item->type = cJSON_Object;
    value = skip(value + 1);
    if (*value == '}') return value + 1;    /* 空对象 */

    //创建节点，用于保存对象中的第一个字段
    item->child = child = cJSON_New_Item();
    if (!item->child) return 0;
    
    //调用parse_string，解析第一个字段的名称
    value = skip(parse_string(child, skip(value)));
    if (!value) return 0;
    child->string = child->valuestring;
    child->valuestring = 0;

    //如果字段名称后面不是冒号，则不是一个合法的json字符串，直接返回
    if (*value != ':') {
        ep = value;
        return 0;
    }    

    //递归调用parse_value解析第一个字段的值
    value = skip(parse_value(child, skip(value + 1)));    
    if (!value) return 0;

   //若第一个字段后面存在逗号，则说明json对象存在其他的字段
   //后面的步骤基本跟解析数组时相同，也就是将各个字段放在
   //child节点后面，形成一个链表，唯一不同的是需要解析每个
   //字段的名称
    while (*value == ',') {
        cJSON *new_item;
        if (!(new_item = cJSON_New_Item())) return 0; 
        child->next = new_item;
        new_item->prev = child;
        child = new_item;
        value = skip(parse_string(child, skip(value + 1)));
        if (!value) return 0;
        child->string = child->valuestring;
        child->valuestring = 0;
        if (*value != ':') {
            ep = value;
            return 0;
        }  
        value = skip(parse_value(child, skip(value + 1)));   
        if (!value) return 0;
    }

    if (*value == '}') return value + 1;    /* 达到对象的末尾 */
    ep = value;
    return 0; 
}

最后，客户端代码在使用完成后，需要将分配的内存释放掉：

void cJSON_Delete(cJSON *c) {
    cJSON *next;
    while (c) { //循环删除链表中所有节点
        next = c->next;
        if (c->child) cJSON_Delete(c->child); //存在子节点，递归删除
        if (c->valuestring) cJSON_free(c->valuestring); 
        if (c->string) cJSON_free(c->string);
        cJSON_free(c); //删除结构体本身
        c = next;
    }
}

cJSON对于json字符串的解析基本就结束了。后面还有关于一个生成好的json对象如何打印，其实就是解析的逆向过程，我就不赘述了。老实说，代码的基本原理很简单，无非就是使用递归，如果让我写个demo，花一个小时就能写出来。但是这样的代码之所以值得我去阅读，不光是对于代码的风格、设计还有可读性上。更重要的是，作者能考虑到很多我不会去考虑的东西，比如说对于字符串的解析，如果是我自己写，可能不会考虑存在转义字符或者utf16的情况。在解析数值时，也不会考虑存在指数的情况。如果给定的字符串不是一个合法的json字符串，又该去如何处理？这也是一个代码新手做出来的东西与一款成熟产品的区别所在。

如果有时间，我想根据cJSON的思路，用java面向对象的方式来进行实现，并且在这基础上加入类型信息，而不是通过一个type标识符来判断类型。