开源项目--cJSON6--JSON生成器

最新推荐文章于 2024-06-17 09:44:39 发布
最新推荐文章于 2024-06-17 09:44:39 发布
阅读量481 收藏
点赞数
分类专栏： # C/C++项目笔记整理 # C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it_is_me_a/article/details/101941156
版权

文章目录

什么是JSON生成器？

JSON生成器负责把树形数据结构转化为JSON文本，这个过程又称为字符串化（stringify）。

头文件

生成器的API：

char* lept_stringify(const lept_value* v, size_t* length);

在实现JSON解析的时候，我们加入了一个动态堆栈，用于存储临时的解析结果。而在JSON生成器中，也要存储生成的结果，所以最简单的再利用该数据结构，作为输出缓冲区。

因为我们已经写过JSON解析器，所以生成器的写法就照着解析器写就可以。

#ifndef LEPT_PARSE_STRINGIFY_INIT_SIZE
#define LEPT_PARSE_STRINGIFY_INIT_SIZE 256
#endif

//int lept_stringify(const lept_value* v, char** json, size_t* length){
//      lept_context c;
//      int ret;
//      assert(v != NULL);
//      assert(json != NULL);
//      c.stack = (char*)malloc(c.size = LEPT_PARSE_STRINGIFY_INIT_SIZE);
//      c.top = 0;
//      if (LEPT_PARSE_OK != (ret = lept_stringify_value(&c, v))){
//             free(c.stack);
//             *json = NULL;
//             return ret;
//      }
//      if (length)
//             *length = c.top;
//      PUTC(&c, '\0');
//      *json = c.stack;
//      return LEPT_PARSE_OK;
//}

char* lept_stringify(const lept_value* v, size_t* length)
{
       lept_context c;
       assert(v != NULL);
       c.stack = (char*)malloc(c.size = LEPT_PARSE_STRINGIFY_INIT_SIZE);
       c.top = 0;
       lept_stringify_value(&c, v);
       if (length)
              *length = c.top;
       PUTC(&c, '\0');
       return c.stack;
}
测试代码

测试代码编写的思路：将一个JSON进行解析生成字符串，然后利用这个字符串在生成JSON2，最后逐字符对比两个JSON是否相同，这种测试称为“往返测试”。

#define TEST_ROUNDTRIP(json)\
        do {\
               lept_value v; \
               char* json2; \
               size_t length; \
               lept_init(&v); \
               EXPECT_EQ_INT(LEPT_PARSE_OK, lept_parse(&v, json)); \
               json2 = lept_stringify(&v, &length); \
               EXPECT_EQ_STRING(json, json2, length); \
               lept_free(&v); \
               free(json2); \
        } while (0)

static void test_stringify_number() {
        TEST_ROUNDTRIP("0");
        TEST_ROUNDTRIP("-0");
        TEST_ROUNDTRIP("1");
        TEST_ROUNDTRIP("-1");
        TEST_ROUNDTRIP("1.5");
        TEST_ROUNDTRIP("-1.5");
        TEST_ROUNDTRIP("3.25");
        TEST_ROUNDTRIP("1e+20");
        TEST_ROUNDTRIP("1.234e+20");
        TEST_ROUNDTRIP("1.234e-20");

        TEST_ROUNDTRIP("1.0000000000000002"); /* the smallest number > 1 */
        TEST_ROUNDTRIP("4.9406564584124654e-324"); /* minimum denormal */
        TEST_ROUNDTRIP("-4.9406564584124654e-324");
        TEST_ROUNDTRIP("2.2250738585072009e-308");  /* Max subnormal double */
        TEST_ROUNDTRIP("-2.2250738585072009e-308");
        TEST_ROUNDTRIP("2.2250738585072014e-308");  /* Min normal positive double */
        TEST_ROUNDTRIP("-2.2250738585072014e-308");
        TEST_ROUNDTRIP("1.7976931348623157e+308");  /* Max double */
        TEST_ROUNDTRIP("-1.7976931348623157e+308");
}

static void test_stringify_string() {
        TEST_ROUNDTRIP("\"\"");
        TEST_ROUNDTRIP("\"Hello\"");
        TEST_ROUNDTRIP("\"Hello\\nWorld\"");
        TEST_ROUNDTRIP("\"\\\" \\\\ / \\b \\f \\n \\r \\t\"");
        TEST_ROUNDTRIP("\"Hello\\u0000World\"");
}

static void test_stringify_array() {
        TEST_ROUNDTRIP("[]");
        TEST_ROUNDTRIP("[null,false,true,123,\"abc\",[1,2,3]]");
}

static void test_stringify_object() {
        TEST_ROUNDTRIP("{}");
        TEST_ROUNDTRIP("{\"n\":null,\"f\":false,\"t\":true,\"i\":123,\"s\":\"abc\",\"a\":[1,2,3],\"o\":{\"1\":1,\"2\":2,\"3\":3}}");
}
static void test_stringify() {
        TEST_ROUNDTRIP("null");
        TEST_ROUNDTRIP("false");
        TEST_ROUNDTRIP("true");
        test_stringify_number();
        test_stringify_string();
        test_stringify_array();
        test_stringify_object();
}
函数实现

首先看看lept_parse_value函数的实现。

//解析的代码
static int lept_parse_value(lept_context* c, lept_value* v) {
    switch (*c->json) {
        case 't':  return lept_parse_literal(c, v, "true", LEPT_TRUE);
        case 'f':  return lept_parse_literal(c, v, "false", LEPT_FALSE);
        case 'n':  return lept_parse_literal(c, v, "null", LEPT_NULL);
        default:   return lept_parse_number(c, v);//对于number的情况，可以这样处理。
        case '\0': return LEPT_PARSE_EXPECT_VALUE;
    }
}

//仿写生成的函数
#define PUTS(c, s, len)     memcpy(lept_context_push(c, len), s, len)
static int lept_stringify_value(lept_context* c, const lept_value* v) {
    size_t i;
    int ret;
    switch (v->type) {
        case LEPT_NULL:   PUTS(c, "null",  4); break;
        case LEPT_FALSE:  PUTS(c, "false", 5); break;
        case LEPT_TRUE:   PUTS(c, "true",  4); break;
        /* ... */
    }
    return LEPT_STRINGIFY_OK;
}
生成数字
case LEPT_NUMBER:
            {
                char buffer[32];
                int length = sprintf(buffer, "%.17g", v->u.n);
                PUTS(c, buffer, length);
            }
            break;

但这样需要在 PUTS() 中做一次 memcpy()，实际上我们可以避免这次复制，只需要生成的时候直接写进 c 里的推栈，然后再按实际长度调查 c->top：


case LEPT_NUMBER:
            {
                char* buffer = lept_context_push(c, 32);
                int length = sprintf(buffer, "%.17g", v->u.n);
                c->top -= 32 - length;
                
            }
            break;

简写成：


case LEPT_NUMBER:
			c->top -= 32 - sprintf(lept_context_push(c, 32), "%.17g", v->u.n);
            break;
生成字符串
static void lept_stringify_string(lept_context* c, const char* s, size_t len) {
    size_t i;
    assert(s != NULL);
    PUTC(c, '"');
    for (i = 0; i < len; i++) {
        unsigned char ch = (unsigned char)s[i];
        switch (ch) {
            case '\"': PUTS(c, "\\\"", 2); break;
            case '\\': PUTS(c, "\\\\", 2); break;
            case '\b': PUTS(c, "\\b",  2); break;
            case '\f': PUTS(c, "\\f",  2); break;
            case '\n': PUTS(c, "\\n",  2); break;
            case '\r': PUTS(c, "\\r",  2); break;
            case '\t': PUTS(c, "\\t",  2); break;
            default:
                if (ch < 0x20) {
                    char buffer[7];
                    sprintf(buffer, "\\u%04X", ch);
                    PUTS(c, buffer, 6);
                }
                else
                    PUTC(c, s[i]);
        }
    }
    PUTC(c, '"');}

static void lept_stringify_value(lept_context* c, const lept_value* v) {
    switch (v->type) {
        /* ... */
        case LEPT_STRING: lept_stringify_string(c, v->u.s.s, v->u.s.len); break;
    }
}

优化 lept_stringify_string()

上面的 lept_stringify_string() 实现中，每次输出一个字符／字符串，都要调用 lept_context_push()。如果我们使用一些性能剖测工具，也可能会发现这个函数消耗较多 CPU。

static void* lept_context_push(lept_context* c, size_t size) {
    void* ret;
    assert(size > 0);
    if (c->top + size >= c->size) { // (1)
        if (c->size == 0)
            c->size = LEPT_PARSE_STACK_INIT_SIZE;
        while (c->top + size >= c->size)
            c->size += c->size >> 1;  /* c->size * 1.5 */
        c->stack = (char*)realloc(c->stack, c->size);
    }
    ret = c->stack + c->top;       // (2)
    c->top += size;                // (3)
    return ret;                    // (4)
}

中间最花费时间的，应该会是 (1)，需要计算而且作分支检查。即使使用 内联函数去减少函数调用的开销，这个分支也无法避免。所以，一个优化的点子是，预先分配足够的内存，每次加入字符就不用做这个检查了。但多大的内存才足够呢？我们可以看到，每个字符可生成最长的形式是 \u00XX，占 6 个字符，再加上前后两个双引号，也就是共 len * 6 + 2 个输出字符。那么，使用 char* p = lept_context_push() 作一次分配后，便可以用 *p++ = c 去输出字符了。最后，再按实际输出量调整堆栈指针。另一个小优化点，是自行编写十六进位输出，避免了 printf() 内解析格式的开销。

static void lept_stringify_string(lept_context* c, const char* s, size_t len) {
    static const char hex_digits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    size_t i, size;
    char* head, *p;
    assert(s != NULL);
    p = head = lept_context_push(c, size = len * 6 + 2); /* "\u00xx..." */
    *p++ = '"';
    for (i = 0; i < len; i++) {
        unsigned char ch = (unsigned char)s[i];
        switch (ch) {
            case '\"': *p++ = '\\'; *p++ = '\"'; break;
            case '\\': *p++ = '\\'; *p++ = '\\'; break;
            case '\b': *p++ = '\\'; *p++ = 'b';  break;
            case '\f': *p++ = '\\'; *p++ = 'f';  break;
            case '\n': *p++ = '\\'; *p++ = 'n';  break;
            case '\r': *p++ = '\\'; *p++ = 'r';  break;
            case '\t': *p++ = '\\'; *p++ = 't';  break;
            default:
                if (ch < 0x20) {
                    *p++ = '\\'; *p++ = 'u'; *p++ = '0'; *p++ = '0';
                    *p++ = hex_digits[ch >> 4];
                    *p++ = hex_digits[ch & 15];
                }
                else
                    *p++ = s[i];
        }
    }
    *p++ = '"';
    c->top -= size - (p - head);
}

要注意的是，很多优化都是有代价的。第一个优化采取空间换时间的策略，对于只含一个字符串的 JSON，很可能会分配多 6 倍内存；但对于正常含多个值的 JSON，多分配的内存可在之后的值所利用，不会造成太多浪费。而第二个优化的缺点，就是有稍增加了一点程序体积。也许有人会问，为什么 hex_digits 不用字符串字面量 “0123456789ABCDEF”？其实是可以的，但这会多浪费 1 个字节（实际因数据对齐可能会浪费 4 个或更多）。

生成数组和对象

生成数组也是非常简单，只要输出 [ 和 ]，中间对逐个子值递归调用 lept_stringify_value()。只要注意在第一个元素后才加入 ,。而对象也仅是多了一个键和 :。


static void lept_stringify_value(lept_context* c, const lept_value* v) {
    size_t i;
    switch (v->type) {
        /* ... */
        case LEPT_ARRAY:
            PUTC(c, '[');
            for (i = 0; i < v->u.a.size; i++) {
                if (i > 0)
                    PUTC(c, ',');
                lept_stringify_value(c, &v->u.a.e[i]);
            }
            PUTC(c, ']');
            break;
        case LEPT_OBJECT:
            PUTC(c, '{');
            for (i = 0; i < v->u.o.size; i++) {
                if (i > 0)
                    PUTC(c, ',');
                lept_stringify_string(c, v->u.o.m[i].k, v->u.o.m[i].klen);
                PUTC(c, ':');
                lept_stringify_value(c, &v->u.o.m[i].v);
            }
            PUTC(c, '}');
            break;
        /* ... */
    }}
最终代码
#ifndef LEPT_PARSE_STRINGIFY_INIT_SIZE
#define LEPT_PARSE_STRINGIFY_INIT_SIZE 256
#endif

#define PUTS(c, s, len) memcpy(lept_context_push(c,len),s,len)

static void lept_stringify_string(lept_context* c, const char* s, size_t len){
        static const char hex_digits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', 
'9', 'A', 'B', 'C', 'D', 'E', 'F' };
        size_t i, size;
        char* head, *p;
        assert(s != NULL);
        p = head = lept_context_push(c, size = len * 6 + 2);//每个字符可生成最长的形式是\u00XX，占 6 个字符，再加上前后两个双引号，也就是共 len * 6 + 2 个输出字符
        *p++ = '"';
        //PUTC(c, '"');  //PUTC 函数每次都会调用lept_context_push函数，这个函数的if(c->top + size >= c->size) 这一句开销比较大，需要计算而且作分支检查。即使使用 C99 的inline 关键字（或使用宏）去减少函数调用的开销，这个分支也无法避免；  写成*p++比较好
        for (i = 0; i < len; i++){
               unsigned char ch = (unsigned char)s[i];
               switch (ch)
               {
               /*case '\"': PUTC(c, "\\\"", 2); break;
               case '\\': PUTC(c, "\\\\", 2); break;
               case '\b': PUTC(c, "\\b", 2); break;
               case '\f': PUTC(c, "\\f", 2); break;
               case '\n': PUTC(c, "\\n", 2); break;
               case '\r': PUTC(c, "\\r", 2); break;
               case '\t': PUTC(c, "\\t", 2); break;*/

               case '\"': *p++ = '\\'; *p++ = '\"'; break;
               case '\\': *p++ = '\\'; *p++ = '\\'; break;
               case '\b': *p++ = '\\'; *p++ = 'b';  break;
               case '\f': *p++ = '\\'; *p++ = 'f';  break;
               case '\n': *p++ = '\\'; *p++ = 'n';  break;
               case '\r': *p++ = '\\'; *p++ = 'r';  break;
               case '\t': *p++ = '\\'; *p++ = 't';  break;
               default:
                       if (ch < 0x20){
                              //char buffer[7];
                              //sprintf(buffer, "\\u%04X", ch);//其他少于 0x20 的字符需要转义为 \u00xx 形式。
                              //PUTS(c, buffer, 0);
                              *p++ = '\\'; *p++ = 'u'; *p++ = '0'; *p++ = '0';
                              *p++ = hex_digits[ch >> 4];
                              *p++ = hex_digits[ch & 15];

                      }
                       else
                              //PUTC(c, s[i]);
                              *p++ = s[i];
               }
        }
        //PUTC(c, '"');
        *p++ = '"';
        c->top -= size - (p - head);
}


static int lept_stringify_value(lept_context* c, const lept_value* v){
        size_t i;
        int ret;
        switch (v->type)
        {
        case LEPT_NULL: PUTS(c, "null", 4); break;
        case LEPT_FALSE: PUTS(c, "false", 5); break;
        case LEPT_TRUE: PUTS(c, "true", 4); break;
        case LEPT_NUMBER: 
        //{
        //           char* buffer = lept_context_push(c, 32);
        //            int length = sprintf(buffer, "%.17g", v->u.n);//sprintf把浮点数转换为文本
        //      c->top -= 32 - length;   
        //}
               c->top -= 32 - sprintf(lept_context_push(c, 32), "%.17g", v->u.n);
               break;
        case LEPT_STRING: lept_stringify_string(c, v->u.s.s, v->u.s.len); break;
        case LEPT_ARRAY:
               PUTC(c, '[');
               for (i = 0; i < v->u.a.size; i++){
                       if (i > 0)
                              PUTC(c, ',');
                       lept_stringify_value(c, &v->u.a.e[i]);
               }
               PUTC(c, ']');
               break;
        case LEPT_OBJECT:
               PUTC(c, '{');
               for (i = 0; i < v->u.o.size; i++){
                       if (i>0)
                              PUTC(c, ',');
                       lept_stringify_string(c, v->u.o.m[i].k, v->u.o.m[i].klen);
                       PUTC(c, ':');
                       lept_stringify_value(c, &v->u.o.m[i].v);
               }
               PUTC(c, '}');
               break;
        default:
               assert(0 && "invalid type");
        }
     

}

char* lept_stringify(const lept_value* v, size_t* length)
{
        lept_context c;
        assert(v != NULL);
        c.stack = (char*)malloc(c.size = LEPT_PARSE_STRINGIFY_INIT_SIZE);
        c.top = 0;
        lept_stringify_value(&c, v);
        if (length)
               *length = c.top;
        PUTC(&c, '\0');
        return c.stack;
}
Emma-Zhang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言：使用cJSON库构造JSON
MQ0522的博客
12-19 3305
一、构造简单的JSON格式 1. 数字 cJSON库函数： //在对象中添加数字 CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number); 2. 字符串 cJSON库函数： //在对象中添加字符串 CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, cons
程序员为什么还要刷题-centijson:CJSON解析器（SAX-like&fullDOM）
07-07
机器很容易解析和生成。 它基于 JavaScript 编程语言标准 ECMA-262 第 3 版 - 1999 年 12 月的一个子集。 JSON 是一种文本格式，它完全独立于语言，但使用 C 系列语言（包括 C）程序员熟悉的约定、C++、C#、Java、...
C语言版json解析生成器
lamdonn的博客
02-14 1555
C语言json解释器。包含json文本文件解析和生成，占用空间小、安全高效、简洁灵活，能无差别或者小修改移植到大部分C语言平台。
推荐一款强大的假JSON数据生成器 —— Apidemic
最新发布
gitblog_00072的博客
06-17 472
???? 推荐一款强大的假JSON数据生成器 —— Apidemic ???? apidemicFake JSON response server项目地址:https://gitcode.com/gh_mirrors/ap/apidemic 在软件测试和开发过程中，真实数据的模拟总是让人头疼不已。如何高效地生成高质量的假数据？今天，我将向大家介绍一款名为 Apidemic 的开源项目，它能轻松解决这个问题！...
6 款好用到爆的 JSON 处理工具，极大提高效率！
Java知音
04-30 6966
点击关注公众号，实用技术文章及时了解前言JSON(JavaScript 对象标注)是一种流行的轻量级数据交换格式，在网络上已很常见。众所周知，JSON 让开发人员易于使用，又让机器易于解析和生成。JSON 吸引了工具构建者的注意，它们开发了用于重新格式化、验证和解析 JSON 的众多工具，这不足为奇。这些工具既有在 Web浏览器 中运行的在线实用程序，又有面向代码编辑器和...
【Groovy】Json、Xml、Swing 生成器 ( Json 生成器 JsonBuilder | Xml 生成器 MarkupBuilder | Swing 生成器 SwingBuilder)
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
02-10 1310
文章目录一、Json 生成器 JsonBuilder二、Xml 生成器 MarkupBuilder三、Swing 生成器 SwingBuilder 一、Json 生成器 JsonBuilder JsonBuilder 原型如下 , 该类继承自 GroovyObjectSupport 类 , 其核心是 invokeMethod , 利用元编程实现 Json 生成器的作用 , 帮助生成 Json 字符串 ; public class JsonBuilder extends GroovyObject
由excel一键生成json的小工具（基于python，仅支持单层嵌套）
ChessZH的博客
04-15 2032
最近空闲的时候做了点小游戏，小游戏开发过程中需要大量json处理，但是手动用文本编辑器调整json又不是很舒服，于是自己造了个由excel一键生成json的小工具，想到好久没发博客了，干脆传上来分享一下 目录下载链接 下载链接 github（可以下载到py版本或exe版本）： https://github.com/ZhChessOvO/basic_excel_to_json 百度网盘（可以下载到exe版本）：
json-original-code.zip
10-08
这些源代码可能是实现JSON解析器和生成器的库，使得开发者可以方便地在C++或C项目中集成JSON支持。 在C++中，处理JSON的方法有很多，例如使用开源库如nlohmann/json、RapidJSON、jsoncpp等。这些库提供了API来解析...
cJSON-master.zip
05-12
cJSON是一个轻量级的开源JSON解析器和生成器，主要针对C和C++语言。在Android或Java等平台广泛使用的JSON库中，cJSON以其高效、小巧的特点，成为C/C++开发者处理JSON数据的首选工具。本篇文章将深入探讨cJSON的使用...
cJSON-v1.7.12
05-08
cJSON是一个针对C语言编写的开源JSON解析器和生成器，它在资源有限的环境中表现优异，比如单片机和嵌入式系统。cJSON-v1.7.12是这个库的一个版本，提供了稳定和高效的功能。 **一、cJSON的主要功能** 1. **解析...
stm32+esp8266-WiFi收发json数据
02-28
同时，还需要熟悉JSON的语法和解析方法，例如使用开源库如cJSON来处理JSON数据。在STM32端，需要正确配置UART参数，确保与ESP8266之间的通信顺畅；在ESP8266端，需要设置恰当的WiFi模式和TCP客户端参数。 总结来说...
Jackson 2.x 系列【2】生成器 JsonGenerator
记录知识、锤炼自我
03-19 1743
其中jackson-core是核心中的核心，其他模块都需要引入，提供了一些基本的API和公共类，jackson-core中的API可以理解为Low Level API，业务开发人员一般不需要接触，因为有更易用的高级API，低级API更加复杂可读性较差，但是更加灵活，某些场景下能完成高级API做不到的事情。
javaScript蓝桥杯---JSON 生成器
平安喜乐
06-09 1714
JSON 已经是大家必须掌握的知识点，JSON 数据格式为前后端通信带来了很大的便利。在开发中，前端开发工程师可以借助于 JSON 生成器快速构建一个 JSON 用来模拟数据。本题请你开发一个简易的 JSON 生成器工具，使它能根据模板生成对应格式的 JSON。
蓝桥杯：JSON生成器
weixin_47308482的博客
06-03 146
蓝桥杯代码
动态解析JSON和生成JSON 工具
zuichu_2001的博客
04-07 761
以下属于转载我忘了是哪位的了 , 如果发现了请在评论帮我标明出处 import java.util.*; import com.fasterxml.jackson.databind.ObjectMapper; import net.sf.json.JSONArray; import net.sf.json.JSONObject; /* * JsonUtils生成json数据和解析json数据 */ public class JsonUtils { static ObjectMapper ob
推荐BiSON.js：一个高性能的JSON解析器和生成器
gitblog_00004的博客
03-11 402
推荐BiSON.js：一个高性能的JSON解析器和生成器 在开发Web应用时，我们经常会遇到需要序列化和反序列化JSON数据的情况。然而，JavaScript内置的JSON.stringify()和JSON.parse()方法在处理大量数据时性能并不理想。这时，我们可以考虑使用第三方库如BiSON.js来提高效率。 BiSON.js是什么？ BiSON.js是一个轻量级、高效的JSON解析器和生...
4 款好用到爆的 JSON 处理工具，极大提高效率！
码匠笔记
05-05 7688
今天的文章是之前筹划的《那些程序员提效的必备神器》系列文章。JSON是一种流行的轻量级数据交换格式，在网络上已很常见。众所周知，JSON 让开发人员易于使用，又让机器易于解析和生成。JSON 在线工具之所以能吸引开发者们纷纷使用，还是得益于这些工具不需要安装，浏览器打开直接使用，同时还可以便捷的格式化、验证和解析 JSON。今天给大家介绍几款 JSON 工具：JSON E...
推荐开源项目：cJSON - 轻量级JSON解析器与生成器
gitblog_00021的博客
03-20 373
推荐开源项目：cJSON - 轻量级JSON解析器与生成器 项目地址:https://gitcode.com/DaveGamble/cJSON cJSON 是一个由 Dave Gamble 创建的小巧、高效的C语言实现的JSON（JavaScript Object Notation）解析器和生成器。在当今的数据交换中，JSON作为轻量级的文本数据格式广泛应用，而cJSON就是处理这种数据的理想工具...
JSON 数据生成器 - 创新数据模拟解决方案
gitblog_00081的博客
04-26 390
JSON 数据生成器 - 创新数据模拟解决方案 json-data-generator项目地址:https://gitcode.com/gh_mirrors/jso/json-data-generator 在软件开发、测试和数据分析中，常常需要大量的结构化数据来进行模拟操作。JSON 数据生成器就是这样一个工具，它可以帮助你快速创建和自定义复杂的 JSON 对象，以满足你的各种需求。 项目简介 ...
uc/os-II使用CJSON
07-15
UC/OS-II 是一个实时操作系统，而 cJSON 是一个轻量级的 JSON 解析器和生成器库。如果你想在 UC/OS-II 中使用 cJSON，你需要将 cJSON 的源代码添加到你的项目中，并进行相应的配置。 以下是在 UC/OS-II 中使用 cJSON 的一般步骤： 1. 将 cJSON 的源代码添加到你的 UC/OS-II 项目中。可以将 cJSON 的源文件（cJSON.c 和 cJSON.h）直接复制到你的项目目录中，或者将其放在一个单独的文件夹中，并将该文件夹添加到你的项目的 include 路径中。 2. 在你的 UC/OS-II 任务中包含 cJSON 头文件，并在任务初始化的地方进行 cJSON 的初始化。例如，你可以在任务初始化函数中调用 `cJSON_Init()` 函数来初始化 cJSON： ```c #include "cJSON.h" void YourTask(void *p_arg) { // 初始化 cJSON cJSON_Init(); // 其他任务代码... } ``` 3. 在你的任务中使用 cJSON 解析和生成 JSON 数据。你可以使用 cJSON 的 API 来解析和生成 JSON 数据。例如，使用 `cJSON_Parse()` 函数解析 JSON 字符串，使用 `cJSON_CreateObject()` 和 `cJSON_AddItemToObject()` 函数创建和添加 JSON 对象等。 以下是一个简单的例子，演示了如何使用 cJSON 解析和生成 JSON 数据： ```c #include "cJSON.h" void YourTask(void *p_arg) { cJSON *root = NULL; char *jsonStr = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}"; // 解析 JSON 字符串 root = cJSON_Parse(jsonStr); if (root != NULL) { // 从 JSON 对象中获取字段值 cJSON *name = cJSON_GetObjectItem(root, "name"); cJSON *age = cJSON_GetObjectItem(root, "age"); cJSON *city = cJSON_GetObjectItem(root, "city"); if (name != NULL && age != NULL && city != NULL) { // 打印字段值 printf("Name: %s\n", name->valuestring); printf("Age: %d\n", age->valueint); printf("City: %s\n", city->valuestring); } // 释放 cJSON 对象 cJSON_Delete(root); } // 生成 JSON 对象 cJSON *newRoot = cJSON_CreateObject(); cJSON_AddStringToObject(newRoot, "name", "Alice"); cJSON_AddNumberToObject(newRoot, "age", 25); cJSON_AddStringToObject(newRoot, "city", "London"); // 将 JSON 对象转换为字符串 char *newJsonStr = cJSON_Print(newRoot); if (newJsonStr != NULL) { printf("New JSON string: %s\n", newJsonStr); free(newJsonStr); } // 释放 cJSON 对象 cJSON_Delete(newRoot); // 其他任务代码... } ``` 这只是一个简单的示例，你可以根据你的具体需求使用其他 cJSON 的 API 来解析和生成 JSON 数据。希望对你有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值