c如何循环读取json

C语言中循环读取JSON数据的实用指南**

在C语言中处理JSON数据，相较于一些现代高级语言，确实需要借助第三方库，因为C语言本身并没有内置JSON解析的支持，通过选择合适的库，我们同样可以实现高效、灵活的JSON数据读取，包括循环读取JSON对象或数组中的元素，本文将以广泛使用的cJSON库为例,详细介绍如何在C语言中循环读取JSON数据。

为什么选择cJSON？

cJSON是一个轻量级、简单易用的C语言JSON解析器，它将JSON文本解析成C语言中的数据结构（主要是链表和树形结构），使得我们可以方便地遍历和操作JSON数据,其优点包括：

轻量级：代码量小,依赖少。
简单易用：API设计直观,易于上手。
功能完善：支持JSON对象的创建、解析、打印、修改和释放等操作。

准备工作：安装cJSON

在使用cJSON之前，你需要将其集成到你的项目中,通常有两种方式：

源码集成：
- 从cJSON的GitHub仓库下载最新源码。
- 将cJSON.h和cJSON.c文件添加到你的项目中。
- 在编译时，将cJSON.c一同编译链接。
包管理器：
- 如果你使用的是Linux系统，可以通过包管理器安装，
  - Ubuntu/Debian: sudo apt-get install libcjson-dev
  - Fedora: sudo dnf install cJSON-devel
- 安装后，编译时需要链接cjson库，gcc your_program.c -lcjson -o your_program

循环读取JSON数据的核心概念

cJSON将JSON数据解析后，会形成一种树状或链表状的结构，主要的结构体是cJSON,它通过成员变量来表示不同类型的JSON数据以及父子关系：

typedef struct cJSON { ... } cJSON;
类型标识：type成员变量，表明该节点是对象、数组、字符串、数字等。
子节点/成员：
- 对于JSON对象（），child指向第一个成员（键值对），成员之间通过next和prev指针链接。
- 对于JSON数组（[]），child指向第一个元素，元素之间通过next和prev指针链接。
值：valuestring, valueint, valuedouble等用于存储节点的实际值。
键：对于对象的成员，string成员存储键名。

理解了这些，循环读取的关键就是利用child、next、prev这些指针来遍历。

循环读取JSON对象

JSON对象是一组无序的键值对，要循环读取一个JSON对象的所有键值对,可以按照以下步骤：

使用cJSON_Parse()函数解析JSON字符串，得到cJSON根对象。
检查根对象的type是否为cJSON_Object。
通过根对象的child指针获取第一个成员。
使用一个循环，沿着next指针遍历所有成员，直到next为NULL。
在循环体内，通过成员的string获取键名，通过valuestring/valueint/valuedouble等获取值，并根据子节点的type处理嵌套的JSON对象或数组。
使用cJSON_Delete()释放解析后的JSON结构体内存。

示例代码：

#include <stdio.h>
#include <stdlib.h>
#include "cJSON.h"
void print_json_object(cJSON *item) {
    cJSON *child = item->child;
    while (child != NULL) {
        printf("Key: %s, ", child->string);
        switch (child->type) {
            case cJSON_String:
                printf("Value: %s\n", child->valuestring);
                break;
            case cJSON_Number:
                if (child->valuedouble == child->valueint) {
                    printf("Value: %d\n", child->valueint);
                } else {
                    printf("Value: %f\n", child->valuedouble);
                }
                break;
            case cJSON_Object:
                printf("Value: (Nested Object)\n");
                print_json_object(child); // 递归处理嵌套对象
                break;
            case cJSON_Array:
                printf("Value: (Array - to be handled separately)\n");
                break;
            default:
                printf("Value: (Other type)\n");
                break;
        }
        child = child->next;
    }
}
int main() {
    const char *json_string = "{"
                              "\"name\": \"John Doe\","
                              "\"age\": 30,"
                              "\"is_student\": false,"
                              "\"address\": {"
                              "    \"street\": \"123 Main St\","
                              "    \"city\": \"New York\""
                              "},"
                              "\"hobbies\": [\"reading\", \"swimming\", \"cycling\"]"
                              "}";
    cJSON *root = cJSON_Parse(json_string);
    if (root == NULL) {
        const char *error_ptr = cJSON_GetErrorPtr();
        if (error_ptr != NULL) {
            fprintf(stderr, "Error before: %s\n", error_ptr);
        }
        return 1;
    }
    // 假设我们知道根对象是一个对象，直接遍历
    if (root->type == cJSON_Object) {
        printf("Looping through JSON object:\n");
        print_json_object(root);
    }
    cJSON_Delete(root);
    return 0;
}

循环读取JSON数组

JSON数组是一组有序的值，循环读取JSON数组的元素与读取对象类似,但更简单：

解析JSON字符串，得到根对象（假设根节点是数组，或数组是某个对象的值）。
检查该节点的type是否为cJSON_Array。
通过该节点的child指针获取第一个元素。
使用一个循环，沿着next指针遍历所有元素，直到next为NULL。
在循环体内，根据每个元素的type处理其值。
释放内存。

示例代码（接上文，处理"hobbies"数组）：

// ... (前面的include和print_json_object函数保持不变) ...
void print_json_array(cJSON *array_item) {
    cJSON *element = array_item->child;
    int index = 0;
    printf("Array elements:\n");
    while (element != NULL) {
        printf("  Element %d: ", index++);
        switch (element->type) {
            case cJSON_String:
                printf("%s\n", element->valuestring);
                break;
            case cJSON_Number:
                if (element->valuedouble == element->valueint) {
                    printf("%d\n", element->valueint);
                } else {
                    printf("%f\n", element->valuedouble);
                }
                break;
            case cJSON_Object:
                printf("(Nested Object)\n");
                print_json_object(element); // 递归处理嵌套对象
                break;
            default:
                printf("(Other type)\n");
                break;
        }
        element = element->next;
    }
}
int main() {
    const char *json_string = "{"
                              "\"name\": \"John Doe\","
                              "\"age\": 30,"
                              "\"is_student\": false,"
                              "\"address\": {"
                              "    \"street\": \"123 Main St\","
                              "    \"city\": \"New York\""
                              "},"
                              "\"hobbies\": [\"reading\", \"swimming\", \"cycling\"]"
                              "}";
    cJSON *root = cJSON_Parse(json_string);
    if (root == NULL) {
        const char *error_ptr = cJSON_GetErrorPtr();
        if (error_ptr != NULL) {
            fprintf(stderr, "Error before: %s\n", error_ptr);
        }
        return 1;
    }
    if (root->type == cJSON_Object) {
        printf("Looping through JSON object:\n");
        print_json_object(root);
        // 查找并循环读取"hobbies"数组
        cJSON *hobbies_array = cJSON_GetObjectItem(root, "hobbies");
        if (hobbies_array != NULL && hobbies_array->type == cJSON_Array) {
            print_json_array(hobbies_array);
        }
    }
    cJSON_Delete(root);
    return 0;
}