cjson如何嵌套

解析CJSON如何实现嵌套结构处理

在嵌入式开发和轻量级数据交换场景中，CJSON凭借其简洁高效的特点被广泛应用，处理复杂的JSON数据结构时，嵌套是常见需求，本文将详细介绍CJSON如何实现嵌套结构，包括创建、解析和操作嵌套JSON数据的方法。

CJSON嵌套的基本概念

CJSON中的嵌套指的是JSON对象或数组内部包含其他对象或数组的情况。

{
  "name": "John",
  "address": {
    "city": "New York",
    "zipcode": "10001"
  },
  "hobbies": ["reading", "swimming", "coding"]
}

在这个例子中，"address"是一个嵌套的对象，"hobbies"是一个嵌套的数组。

创建嵌套JSON结构

创建嵌套对象

要创建嵌套的JSON对象，需要先创建父对象,然后逐层添加子对象：

#include <stdio.h>
#include <stdlib.h>
#include "cjson/cJSON.h"
int main() {
    // 创建根对象
    cJSON *root = cJSON_CreateObject();
    // 添加简单字段
    cJSON_AddStringToObject(root, "name", "John");
    cJSON_AddNumberToObject(root, "age", 30);
    // 创建嵌套的address对象
    cJSON *address = cJSON_CreateObject();
    cJSON_AddStringToObject(address, "city", "New York");
    cJSON_AddNumberToObject(address, "zipcode", 10001);
    // 将address对象添加到root中
    cJSON_AddItemToObject(root, "address", address);
    // 创建嵌套的hobbies数组
    cJSON *hobbies = cJSON_CreateArray();
    cJSON_AddItemToArray(hobbies, cJSON_CreateString("reading"));
    cJSON_AddItemToArray(hobbies, cJSON_CreateString("swimming"));
    cJSON_AddItemToArray(hobbies, cJSON_CreateString("coding"));
    // 将hobbies数组添加到root中
    cJSON_AddItemToObject(root, "hobbies", hobbies);
    // 转换为字符串并打印
    char *json_string = cJSON_Print(root);
    printf("%s\n", json_string);
    // 释放内存
    free(json_string);
    cJSON_Delete(root);
    return 0;
}

创建多层嵌套

CJSON支持任意深度的嵌套,只需按照相同模式逐层创建即可：

// 创建更深的嵌套结构
cJSON *company = cJSON_CreateObject();
cJSON_AddStringToObject(company, "name", "Tech Corp");
cJSON_AddStringToObject(company, "location", "Silicon Valley");
cJSON *departments = cJSON_CreateArray();
cJSON *dept1 = cJSON_CreateObject();
cJSON_AddStringToObject(dept1, "name", "Engineering");
cJSON_AddNumberToObject(dept1, "employees", 50);
cJSON_AddItemToArray(departments, dept1);
cJSON *dept2 = cJSON_CreateObject();
cJSON_AddStringToObject(dept2, "name", "Marketing");
cJSON_AddNumberToObject(dept2, "employees", 20);
cJSON_AddItemToArray(departments, dept2);
cJSON_AddItemToObject(company, "departments", departments);
cJSON_AddItemToObject(root, "company", company);

解析嵌套JSON结构

访问嵌套对象

解析嵌套JSON时,需要逐层访问子对象：

const char *json_string = "{\"name\":\"John\",\"address\":{\"city\":\"New York\",\"zipcode\":10001},\"hobbies\":[\"reading\",\"swimming\",\"coding\"]}";
// 解析JSON
cJSON *root = cJSON_Parse(json_string);
if (!root) {
    printf("Error before: [%s]\n", cJSON_GetErrorPtr());
    return 1;
}
// 获取嵌套的address对象
cJSON *address = cJSON_GetObjectItem(root, "address");
if (address) {
    // 获取address中的字段
    cJSON *city = cJSON_GetObjectItem(address, "city");
    cJSON *zipcode = cJSON_GetObjectItem(address, "zipcode");
    if (city && zipcode && cJSON_IsString(city) && cJSON_IsNumber(zipcode)) {
        printf("City: %s, Zipcode: %d\n", city->valuestring, zipcode->valueint);
    }
}
// 获取嵌套的hobbies数组
cJSON *hobbies = cJSON_GetObjectItem(root, "hobbies");
if (hobbies && cJSON_IsArray(hobbies)) {
    int count = cJSON_GetArraySize(hobbies);
    printf("Hobbies (%d): ", count);
    for (int i = 0; i < count; i++) {
        cJSON *hobby = cJSON_GetArrayItem(hobbies, i);
        if (cJSON_IsString(hobby)) {
            printf("%s ", hobby->valuestring);
        }
    }
    printf("\n");
}
// 释放内存
cJSON_Delete(root);

处理多层嵌套

对于更深的嵌套结构,只需继续逐层访问：

// 假设有如下的嵌套JSON
const char *deep_json = "{\"company\":{\"name\":\"Tech Corp\",\"departments\":[{\"name\":\"Engineering\",\"employees\":50},{\"name\":\"Marketing\",\"employees\":20}]}}";
cJSON *deep_root = cJSON_Parse(deep_json);
if (!deep_root) {
    printf("Error before: [%s]\n", cJSON_GetErrorPtr());
    return 1;
}
// 获取company对象
cJSON *company = cJSON_GetObjectItem(deep_root, "company");
if (company) {
    cJSON *company_name = cJSON_GetObjectItem(company, "name");
    printf("Company: %s\n", company_name->valuestring);
    // 获取departments数组
    cJSON *departments = cJSON_GetObjectItem(company, "departments");
    if (departments && cJSON_IsArray(departments)) {
        int dept_count = cJSON_GetArraySize(departments);
        for (int i = 0; i < dept_count; i++) {
            cJSON *dept = cJSON_GetArrayItem(departments, i);
            cJSON *dept_name = cJSON_GetObjectItem(dept, "name");
            cJSON *emp_count = cJSON_GetObjectItem(dept, "employees");
            if (dept_name && emp_count && cJSON_IsString(dept_name) && cJSON_IsNumber(emp_count)) {
                printf("  Department: %s, Employees: %d\n", dept_name->valuestring, emp_count->valueint);
            }
        }
    }
}
cJSON_Delete(deep_root);

操作嵌套结构

修改嵌套值

修改嵌套结构中的值与创建类似，先定位到目标位置,然后进行修改：

// 修改嵌套值
cJSON *address = cJSON_GetObjectItem(root, "address");
if (address) {
    cJSON *city = cJSON_GetObjectItem(address, "city");
    if (city) {
        // 修改城市名称
        city->valuestring = strdup("Los Angeles");
    }
    // 添加新字段
    cJSON_AddStringToObject(address, "country", "USA");
}

删除嵌套项

删除嵌套项需要先定位到父对象,然后删除指定项：

// 删除嵌套项
cJSON *hobbies = cJSON_GetObjectItem(root, "hobbies");
if (hobbies) {
    // 删除数组的第一个元素
    cJSON_DeleteItemFromArray(hobbies, 0);
}
// 删除整个嵌套对象
cJSON *address = cJSON_GetObjectItem(root, "address");
if (address) {
    cJSON_DeleteItemFromObject(root, "address");
}

注意事项

1. 内存管理：所有通过CJSON创建的对象和数组都需要使用cJSON_Delete释放,避免内存泄漏。
2. 错误处理：在访问嵌套结构时，应始终检查返回值是否为NULL,避免空指针解引用。
3. 类型检查：使用cJSON_IsObject、cJSON_IsArray等函数验证节点类型,确保操作安全。
4. 字符串处理：修改字符串值时，需要先释放原有内存（如果有）,再分配新内存。

CJSON通过简单的API设计实现了强大的嵌套结构处理能力，无论是创建复杂的JSON数据树，还是解析和操作现有的嵌套结构，CJSON都能高效完成任务，嵌套结构的处理方法，是灵活运用CJSON进行JSON数据交换的关键，在实际应用中，合理组织嵌套层次，注意内存管理和错误处理,可以确保程序稳定可靠地运行。