深入学习ArduinoJson库 V6版本

发布时间：2024-11-23 21:13

使用Git进行深度学习项目的版本控制 #生活技巧# #学习技巧# #深度学习技巧#

❤️博主介绍❤️
作者：单片机菜鸟哥
火爆博客：ESP8266 Arduino教程

零基础从入门到熟悉Arduino平台下开发ESP8266，同时会涉及网络编程知识。专栏文章累计超过60篇，分为基础篇、网络篇、应用篇、高级篇，涵盖ESP8266大部分开发技巧。

最近更新：ESP32 MicroPython应用

讲解Python在esp32上的应用，包括网络请求、爬虫

快速导航
单片机菜鸟的博客快速索引(快速找到你要的)

共同学习成长QQ群 622368884，不喜勿加，里面有一大群志同道合的探路人

如果觉得有用，麻烦点赞收藏，您的支持是博主创作的动力。

文章目录 1.前言2.ArduinoJson V6版本2.0 解析、构造相关2.0.1 deserializeJson —— 解析json2.0.2 serializeJson —— 构造序列化json2.0.3 serializeJsonPretty —— 构造序列化json，格式化输出2.0.4 measureJson —— 计算构造序列化json的长度2.0.5 measureJsonPretty —— 计算构造序列化格式化json的长度 2.1 JsonDocument2.1.1 as —— 获取顶节点，并把它转成T类型2.1.2 add —— 往jsondocument添加元素2.1.3 clear —— 清除JsonDocument并释放内存空间2.1.4 createNestedArray —— 创建空json数组，并为它分配内存空间2.1.5 createNestedObject —— 创建空json对象，并为它分配内存空间2.1.6 getElement —— 获取index位置/key的元素2.1.7 getMember —— 获取key对应的value2.1.8 getOrCreateMember —— 获取或者创建key对应的value2.1.9 operator[] —— 快捷操作符2.1.10 isNull —— 判断jsondocument是否为空2.1.11 memoryUsage —— jsondocument已使用内存字节数2.1.12 to —— jsondocument转成T类型 2.2 JsonObject2.2.1 begin/end —— 返回一个迭代器,可用于对象中的所有键值对2.2.2 containsKey —— 判断对象是否包含某一个key2.2.3 createNestedArray —— 在当前对象中添加子key，子value为json数组2.2.4 createNestedObject —— 在当前对象中添加子key，子value为json对象2.2.5 getMember —— 获取对象中给到key的value2.2.6 getOrCreateMember —— 获取对象中给到key的value,如果没有就创建2.2.7 isNull —— 判断对象是否为空2.2.8 operator[] —— get/set快捷方式2.2.9 remove —— 移除特定key和value2.2.10 set —— 把一个json对象的内容设置给当前json对象2.2.11 size —— 返回对象键值对的个数 2.3 JsonArray2.3.1 add —— 往数组中加入value2.3.2 begin/end —— 返回一个迭代器,可用于数组中的所有对象2.3.3 createNestedArray —— 添加json数组2.3.4 createNestedObject —— 添加json对象2.3.5 getElement —— 获取对应index的值2.3.6 isNull —— 判断json数组是否为空2.3.7 operator[] —— set/get快捷方式2.3.8 remove —— 移除某一个index位置的元素2.3.9 set —— 用另一个jsonArray代替当前jsonArray2.3.10 size —— 返回json数组元素的个数 3.实验代码3.1 编码Json字符串3.2 解码Json字符串 4. ArduinoJson V6版本编译配置5.总结

1.前言

前面，博主已经讲解了ArduinoJson库的V5版本。为了节省时间以及不讨论重复内容，博主建议读者先去阅读一下 玩转ArduinoJson库 V5版本 。重点了解几个东西：

JSON协议JsonBufferJsonObjectJsonArray

接下来，我们直接进入V6版本的学习，尽量和V5版本类比。

2.ArduinoJson V6版本

假设读者下载的V6版本的，那么可以参考这里的API说明。读者需要注意一下JsonDocument（可类比V5版本的JsonBuffer），因为V6版本的json操作都是在它上面。
对于开发者来说，使用JSON无非就是编码或者解码，所以博主也会分出两种情况来讲解。
首先我们来看看V6版本常用的百度脑图：

在这里插入图片描述

可以看出，方法主要分为三大类：

JsonDocument相关，这是整个json库的入口，它负责高效管理内存以及调用json解析器；JsonObject相关；JsonArray相关；解析、构造相关； 2.0 解析、构造相关 2.0.1 deserializeJson —— 解析json

函数说明：
详细可以参考 wiki

/** * 解析json * @param doc jsondocument对象 * @param input 输入内容 * @return DeserializationError 解析结果 */ // writable input => zero-copy DeserializationError deserializeJson(JsonDocument& doc, char* input); DeserializationError deserializeJson(JsonDocument& doc, char* input, size_t inputSize); // read-only input => duplication DeserializationError deserializeJson(JsonDocument& doc, const char* input); DeserializationError deserializeJson(JsonDocument& doc, const char* input, size_t inputSize); DeserializationError deserializeJson(JsonDocument& doc, const __FlashStringHelper* input); DeserializationError deserializeJson(JsonDocument& doc, const __FlashStringHelper* input, size_t inputSize); DeserializationError deserializeJson(JsonDocument& doc, const String& input); DeserializationError deserializeJson(JsonDocument& doc, const std::string& input); DeserializationError deserializeJson(JsonDocument& doc, Stream& input); DeserializationError deserializeJson(JsonDocument& doc, std::istream& input); 12345678910111213141516171819

DeserializationError具体内容请参考 wiki

例子说明：

//Read-only input const char* json = "{\"hello\":\"world\"}"; StaticJsonDocument<200> doc; deserializeJson(doc, json); const char* world = doc["hello"]; //Zero-copy mode char json[] = "{\"hello\":\"world\"}"; StaticJsonDocument<200> doc; deserializeJson(doc, json); const char* world = doc["hello"]; //Raise the nesting limit char json[] = "[[[[[[[[[[[[[[[42]]]]]]]]]]]]]]]"; StaticJsonDocument<200> doc; deserializeJson(doc, json, DeserializationOption::NestingLimit(15));; int answer = doc[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0]; 1234567891011121314151617 2.0.2 serializeJson —— 构造序列化json

函数说明：
详细可以参考 wiki

/** * 构造序列化json * @param doc jsondocument对象 * @param output 输出内容 */ serializeJson(const JsonDocument& doc, char* output, size_t outputSize); serializeJson(const JsonDocument& doc, char output[size]); serializeJson(const JsonDocument& doc, Print& output); serializeJson(const JsonDocument& doc, String& output); serializeJson(const JsonDocument& doc, std::string& output); serializeJson(const JsonDocument& doc, std::ostream& output); 1234567891011

例子说明：

StaticJsonDocument<200> doc; doc["hello"] = "world"; serializeJson(doc, Serial); 123

打印结果：

{"hello":"world"} 1

注意：

此方法属于精简压缩化输出； 2.0.3 serializeJsonPretty —— 构造序列化json，格式化输出

函数说明：
详细可以参考 wiki

/** * 构造序列化json，格式化输出 * @param doc jsondocument对象 * @param output 输出内容 */ size_t serializeJsonPretty(const JsonDocument& doc, char* output, size_t outputSize); size_t serializeJsonPretty(const JsonDocument& doc, char output[size]); size_t serializeJsonPretty(const JsonDocument& doc, Print& output); size_t serializeJsonPretty(const JsonDocument& doc, String& output); size_t serializeJsonPretty(const JsonDocument& doc, std::string& output); 12345678910

例子说明：

StaticJsonDocument<200> doc; doc["hello"] = "world"; serializeJsonPretty(doc, Serial); 123

打印结果：

{ "hello": "world" } 123

注意：

此方法属于格式化输出，需要考虑内存消耗； 2.0.4 measureJson —— 计算构造序列化json的长度

函数说明：
详细可以参考 wiki

/** * 计算构造序列化json的长度 * @param doc jsondocument对象 * @Note 关联方法 serializeJson */ size_t measureJson(const JsonDocument& doc); 123456

例子说明：

// Send headers client.println("Content-Type: application/json"); client.print("Content-Length: "); client.println(measureJson(doc)); // Terminate headers client.println(); // Send body serializeJson(doc, client); 12345678910 2.0.5 measureJsonPretty —— 计算构造序列化格式化json的长度

函数说明：
详细可以参考 wiki

/** * 计算构造序列化格式化json的长度 * @param doc jsondocument对象 * @Note 关联方法 serializeJsonPretty */ size_t measureJsonPretty(const JsonDocument& doc); 123456

例子说明：

// Send headers client.println("Content-Type: application/json"); client.print("Content-Length: "); client.println(measureJsonPretty(doc)); // Terminate headers client.println(); // Send body serializeJsonPretty(doc, client); 12345678910 2.1 JsonDocument

JsonDocument作为整个V6版本ArduinoJson库的内存入口，负责处理整个json数据的内存管理，这是我们需要首先重点关注的内容。
它包括两个实现类：

DynamicJsonDocument，内存分配在heap区，无固定大小，可以自动增长所需空间，方法调用完自动回收，建议内存大小大于1KB使用；

DynamicJsonDocument doc(2048); 1 StaticJsonDocument，内存分配在stack区，有固定大小，大小值由开发者定义，方法调用完自动回收，建议内存大小小于1KB使用；

StaticJsonDocument<256> doc; 1

使用JsonDocument
当你创建一个JsonDocument之后，默认初始化为空，调用 JsonDocument::isNull()会返回true，这个时候既可以代表当做jsonObject，也可以当做jsonArray，这取决于你插入第一个value的类型。

以下会作为JsonObject使用：

DynamicJsonDocument doc(1024); doc["answer"] = 42; // the doc contains {"answer":42} 123

以下会作为JsonArray使用：

DynamicJsonDocument doc(1024); doc.add(42); // the doc contains [42] 123

接下来，看看JsonDocument的一些常用方法：

2.1.1 as —— 获取顶节点，并把它转成T类型

函数说明：

/** * 获取顶节点，并把它转成T类型 * @return JsonArray/JsonObject/JsonVariant */ JsonArray as<JsonArray>(); JsonObject as<JsonObject>(); JsonVariant as<JsonVariant>(); 1234567

例子说明：

DynamicJsonBuffer doc(1024); deserializeJson(doc, "{\"key\":\"value\")"); // get the JsonObject in the JsonDocument JsonObject root = doc.as<JsonObject>(); // get the value in the JsonObject const char* value = root["key"]; 12345678

注意:

此方法不会改变 JsonDocument的内容（JsonDocument::to()会改变）此方法只会返回JsonDocument顶节点的引用。如果顶节点的类型和强转的T类型不匹配，此方法将会返回空引用（比如，如果JsonDocument是一个jsonArray，当调用JsonDocument::as()，会返回空JsonObject）。 2.1.2 add —— 往jsondocument添加元素

函数说明：

/** * 往jsondocument添加元素 * @param value 元素 */ // add the specified value to the array bool add(bool value); bool add(float value); bool add(double value); bool add(signed char value); bool add(signed long value); bool add(signed int value); bool add(signed short value); bool add(unsigned char value); bool add(unsigned long value); bool add(unsigned int value); bool add(unsigned short value); bool add(char *value); // see Remarks bool add(const char *value); bool add(const __FlashStringHelper *value); // see Remarks bool add(const String &value); // see Remarks bool add(const std::string &value); // see Remarks bool add(JsonArray array); bool add(JsonObject object); bool add(JsonVariant variant); 1234567891011121314151617181920212223242526272829

例子说明：

StaticJsonDocument<200> doc; array.add("hello"); // null -> ["hello"] array.add(3.14156); // ["hello"] -> ["hello",3.14156] serializeJson(doc, Serial); 1234

打印结果：

["hello",3.14156] 1

注意:

如果JsonDocument顶节点是一个JsonArray，add方法会追加一个value到数组；如果JsonDocument顶节点是一个JsonObject，add无效；如果JsonDocument是一个空对象，add方法会把JsonDocument变成一个包含一个元素的数组，这是一个创建数组的方式； 2.1.3 clear —— 清除JsonDocument并释放内存空间

函数说明：

/** * 清除JsonDocument并释放内存空间 */ void clear(); 1234

注意:

这个方法和JsonBuffer的clear方法不一样； 2.1.4 createNestedArray —— 创建空json数组，并为它分配内存空间

函数说明：

/** * 创建空json数组，并为它分配内存空间 * @param key key名称 * @return JsonArray */ // similar to JsonArray::createNestedArray() JsonArray createNestedArray(); // similar to JsonObject::createNestedArray() JsonArray createNestedArray(char* key); JsonArray createNestedArray(const char* key); JsonArray createNestedArray(const __FlashStringHelper* key); JsonArray createNestedArray(const String& key); JsonArray createNestedArray(const std::string& key); 1234567891011121314

例子说明：

DynamicJsonDocument doc(1024); JsonArray ports = doc.createNestedArray("ports"); ports.add("80"); ports.add("443"); 1234

打印结果：

{ "ports": [ 80, 443 ] } 123456

注意:

对于无参数的createNestedArray()方法，会创建一个Json数组并把它追加到顶节点的数组中。如果document的顶节点不是数组，这个方法无效；如果document是空的，这个方法会初始化一个数组顶节点，参考以下代码：

StaticJsonDocument<200> doc; JsonArray arr = doc.createNestedArray(); arr.add("hello world"); serializeJson(doc, Serial); 123456

打印结果：

[["hello world"]] 1 对于有参数的createNestedArray()方法，会创建一个json数组并把它指向这个特定的key。如果document的顶节点不是对象，这个方法无效；如果document是空的，这个方法会初始化一个对象顶节点，参考以下代码：

StaticJsonDocument<200> doc; JsonArray array = doc.createNestedArray("hello"); array.add("world"); serializeJson(doc, Serial); 123456

打印结果：

{"hello":["world"]} 1 2.1.5 createNestedObject —— 创建空json对象，并为它分配内存空间

函数说明：

/** * 创建空json对象，并为它分配内存空间 * @param key key名称 * @return JsonObject */ // similar to JsonArray::createNestedArray() // similar to JsonArray::createNestedObject() JsonObject createNestedObject(); // similar to JsonObject::createNestedObject() JsonObject createNestedObject(char* key); JsonObject createNestedObject(const char* key); JsonObject createNestedObject(const __FlashStringHelper* key); JsonObject createNestedObject(const String& key); JsonObject createNestedObject(const std::string& key); 123456789101112131415

例子说明：

DynamicJsonDocument doc(1024); JsonArray wifi = doc.createNestedObject("wifi"); wifi["SSID"] = "TheBatCave"; 123

打印结果：

{ "wifi": { "SSID": "TheBatCave" } } 12345

注意:

对于无参数的createNestedObject()方法，会创建一个Json对象并把它追加到顶节点的数组中。如果document的顶节点不是数组，这个方法无效；如果document是空的，这个方法会初始化一个数组顶节点，参考以下代码：

StaticJsonDocument<200> doc; JsonObject obj = doc.createNestedObject(); obj["hello"] = "world"; serializeJson(doc, Serial); 123456

打印结果：

[{"hello":"world"}] 1 对于有参数的createNestedObject()方法，会创建一个json数组并把它指向这个特定的key。如果document的顶节点不是对象，这个方法无效；如果document是空的，这个方法会初始化一个对象顶节点，参考以下代码：

StaticJsonDocument<200> doc; JsonObject obj = doc.createNestedObject("nested"); obj["hello"] = "world"; serializeJson(doc, Serial); 123456

打印结果：

{"nested":{"hello":"world"}} 1 2.1.6 getElement —— 获取index位置/key的元素

函数说明：

/** * 获取index位置/key的元素 * @param index 索引位置 * @return JsonVariant 如果找不到匹配的返回null */ JsonVariant getElement(size_t index); 123456 2.1.7 getMember —— 获取key对应的value

函数说明：

/** * 获取key对应的value * @param key 对应的key * @param JsonVariant key对应的value，如果不匹配返回null */ JsonVariant getMember(const char* key); JsonVariant getMember(String key); JsonVariant getMember(std::string key); JsonVariant getMember(const __FlashStringHelper* key); 123456789 2.1.8 getOrCreateMember —— 获取或者创建key对应的value

函数说明：

/** * 获取或者创建key对应的value * @param key 对应的key * @param JsonVariant key对应的value，如果不匹配返回null */ JsonVariant getOrCreateMember(const char* key); JsonVariant getOrCreateMember(String key); JsonVariant getOrCreateMember(std::string key); JsonVariant getOrCreateMember(const __FlashStringHelper* key); 123456789

注意：

如果JsonDocument包含一个对象，那么getOrCreateMember方法会获取指定key的值，如果对象不存在该key，这个方法会往对象添加一个新的key-value键值对；如果JsonDocument是空，那么getOrCreateMember方法将创建一个对象给到JsonDocument；如果属于以上两种情况之外的，此方法无效； 2.1.9 operator[] —— 快捷操作符

函数说明：

/** * 快捷操作符 * @param key 对象中对应的key * @param index 数组中对应的索引 */ // mimics a JsonArray ElementProxy operator[](size_t index); // mimics a JsonObject MemberProxy operator[](const char* key); MemberProxy operator[](char* key); MemberProxy operator[](const String& key); MemberProxy operator[](const std::string& key); MemberProxy operator[](const __FlashStringHelper* key); 1234567891011121314

例子说明：

StaticJsonDocument<256> doc; doc["wifi"]["SSID"] = "TheBatCave"; 12

打印内容：

{ "wifi": { "SSID": "TheBatCave" } } 12345 2.1.10 isNull —— 判断jsondocument是否为空

函数说明：

/** * 判断jsondocument是否为空 */ bool isNull() const; 1234

例子说明：

//Result is true DynamicJsonDocument doc(1024); doc.isNull(); // true serializeJson(doc, Serial); // prints "null" //Result is false DynamicJsonDocument doc(1024); doc.to<JsonArray>(); doc.isNull(); // false serializeJson(doc, Serial); // prints "[]" 12345678910 2.1.11 memoryUsage —— jsondocument已使用内存字节数

函数说明：

/** * jsondocument已使用内存字节数 */ size_t memoryUsage() const; 1234

例子说明：

char json[] = "{\"hello\":\"world\"}"; StaticJsonDocument<200> doc; deserializeJson(doc, json); Serial.println(doc.memoryUage()); // prints 26 on AVR 123456 2.1.12 to —— jsondocument转成T类型

函数说明：

/** * jsondocument转成T类型,T为JsonArray、JsonObject、JsonVariant */ JsonArray to<JsonArray>(); JsonObject to<JsonObject>(); JsonVariant to<JsonVariant>(); 123456

例子说明：

// allocate the JsonDocument StaticJsonDocument<200> doc; // convert it to a JsonObject JsonObject root = doc.to<JsonObject>(); // set values root["hello"] = "world"; 12345678

注意：

此方法是释放jsondocument的内存空间，也就是说之前已经分配的引用无效，参考代码：

DynamicJsonBuffer doc(1024); JsonObject root1 = doc.to<JsonObject>(); JsonObject root2 = doc.to<JsonObject>(); // Don't use root1 here, because it's dangling! 1234567 2.2 JsonObject

在JsonDocument所构造出来的内存空间中，Json对象的入口就是JsonObject。
让我们看看它的常用操作方法：

2.2.1 begin/end —— 返回一个迭代器,可用于对象中的所有键值对

函数说明：

/** * 返回一个迭代器,可用于对象中的所有键值对 */ JsonObject::iterator begin() const; JsonObject::iterator end() const; 12345

例子说明：

char json[] = "{\"first\":\"hello\",\"second\":\"world\"}"; DynamicJsonDocument doc(1024); deserializeJson(doc, json); JsonObject root = doc.as<JsonObject>(); // using C++11 syntax (preferred): for (JsonPair kv : root) { Serial.println(kv.key().c_str()); Serial.println(kv.value().as<char*>()); } // using C++98 syntax (for older compilers): for (JsonObject::iterator it=root.begin(); it!=root.end(); ++it) { Serial.println(it->key().c_str()); Serial.println(it->value().as<char*>()); } 12345678910111213141516

打印结果：

first hello second world 1234 2.2.2 containsKey —— 判断对象是否包含某一个key

函数说明：

/** * 判断对象是否包含某一个key * @param key key名字 * @return bool */ bool containsKey(const char* key) const; bool containsKey(const String& key) const; bool containsKey(const std::string& key) const; bool containsKey(const __FlashStringHelper& key) const; 123456789

例子说明：

StaticJsonDocument<256> doc; JsonObject root = doc.to<JsonObject>(); root["city"] = "Paris"; bool hasCity = root.containsKey("city"); // true bool hasCountry = root.containsKey("country"); // false } 1234567

注意：

json库的开发者不建议使用该方法，因为就算没有值也会返回一个空值。库开发者给了例子建议：

if (root.containsKey("error")) { const char* error = root["error"] Serial.println(error); return; } 12345

可以改成：

JsonVariant error = root["error"]; if (!error.isNull()) { Serial.println(error.as<char*>()); return; } 12345

或者更加简单快速的方法：

const char* error = root["error"]; if (error) { Serial.println(error); return; } 12345 2.2.3 createNestedArray —— 在当前对象中添加子key，子value为json数组

函数说明：

/** * 在当前对象中添加子key，子value为json数组 * @param key key名字 * @return JsonArray */ JsonArray createNestedArray(char* key) const; JsonArray createNestedArray(const char* key) const; JsonArray createNestedArray(const __FlashStringHelper* key) const; JsonArray createNestedArray(const String& key) const; JsonArray createNestedArray(const std::string& key) const; 1234567891011

例子说明：

StaticJsonDocument<256> doc; JsonObject root = doc.to<JsonObject>(); root["status"] = "on"; JsonArray levels = root.createNestedArray("levels"); levels.add(10); levels.add(30); serializeJsonPretty(root, Serial); 1234567

打印结果：

{ "status": "on", "levels": [ 10, 20 ] } 1234567 2.2.4 createNestedObject —— 在当前对象中添加子key，子value为json对象

函数说明：

/** * 在当前对象中添加子key，子value为json对象 * @param key key名字 * @return JsonObject对象 */ JsonObject createNestedObject(char* key) const; JsonObject createNestedObject(const char* key) const; JsonObject createNestedObject(const __FlashStringHelper* key) const; JsonObject createNestedObject(const String& key) const; // see Remarks JsonObject createNestedObject(const std::string& key) const; // see Remarks 1234567891011

例子说明：

StaticJsonDocument<256> doc; JsonObject root = doc.to<JsonObject>(); root["city"] = "Paris"; JsonObject weather = root.createNestedObject("weather"); weather["temp"] = 14.2; weather["cond"] = "cloudy"; serializeJsonPretty(root, Serial); 1234567

打印结果：

{ "city": "Paris", "weather": { "temp": 14.20, "cond": "cloudy" } } 1234567 2.2.5 getMember —— 获取对象中给到key的value

函数说明：

/** * 获取对象中给到key的value * @param key key名字 * @return JsonVariant对象 */ JsonVariant getMember(const char* key) const; JsonVariant getMember(const __FlashStringHelper* key) const; JsonVariant getMember(const String& key) const; JsonVariant getMember(const std::string& key) const; 12345678910

例子说明：
例子1：

//The key is not found char json[] = "{\"username\":\"the_duke\"}"; StaticJsonDocument<256> doc; deserializeJson(doc, json); JsonObject object = doc.as<JsonObject>(); JsonVariant password = object.getMember("password"); if (password.isNull()) { Serial.println(F("Error: password is missing")); } 123456789101112

打印结果：

Error: password is missing 1

例子2：

//The key is found char json[] = "{\"username\":\"the_duke\"}"; StaticJsonDocument<256> doc; deserializeJson(doc, json); JsonObject object = doc.as<JsonObject>(); JsonVariant username = object.getMember("username"); Serial.println(F("Your name is: ")); Serial.println(username.as<const char*>()); 1234567891011

打印结果：

Your name is: the_duke 1 2.2.6 getOrCreateMember —— 获取对象中给到key的value,如果没有就创建

函数说明：

/** * 获取对象中给到key的value,如果没有就创建 * @param key key名字 * @return JsonVariant对象 */ JsonVariant getOrCreateMember(char* key) const; JsonVariant getOrCreateMember(const char* key) const; JsonVariant getOrCreateMember(const __FlashStringHelper* key) const; JsonVariant getOrCreateMember(const String& key) const; JsonVariant getOrCreateMember(const std::string& key) const; 1234567891011 2.2.7 isNull —— 判断对象是否为空

函数说明：

/** * 判断对象是否为空 * @Note You can use this function to: * check if the object was successfully parsed, or * check if the object was successfully allocated. */ bool isNull() const; 1234567

例子说明：

//Example 1: parsing success: StaticJsonDocument<200> doc; deserializeJson(doc, "{\"hello\":\"world\"}"); JsonObject object = doc.as<JsonObject>(); Serial.println(object.isNull()); // false //Example 2: parsing failure: StaticJsonDocument<200> doc; deserializeJson(doc, "[\"hello\",\"world\"]"); JsonObject object = doc.as<JsonObject>(); Serial.println(object.isNull()); // true //Example 3: allocation success: StaticJsonDocument<200> doc; JsonObject object = doc.to<JsonObject>(); Serial.println(object.isNull()); // false //Example 4: allocation failure: StaticJsonDocument<1> doc; JsonObject object = doc.to<JsonObject>(); Serial.println(object.isNull()); // true 123456789101112131415161718192021 2.2.8 operator[] —— get/set快捷方式

函数说明：

/** * get/set快捷方式 */ MemberProxy operator[](char* key) const; MemberProxy operator[](const char* key) const; MemberProxy operator[](const __FlashStringHelper* key) const; MemberProxy operator[](const String& key) const; MemberProxy operator[](const std::string& key) const; 123456789

例子说明：

//以下两行代码效果等同 JsonVariant value = object["key"]; JsonVariant value = object.getMember("key"); //以下两行代码效果等同 object["key"] = "value"; object.getOrCreateMember("key").set("value"); StaticJsonDocument<256> doc; JsonObject object = doc.to<JsonObject>(); object["hello"] = "world"; const char* world = object["hello"]; 123456789101112 2.2.9 remove —— 移除特定key和value

函数说明：

/** * 移除特定key和value * @param key key名 */ void remove(const char* key) const; void remove(const __FlashStringHelper* key) const; void remove(const String& key) const; void remove(const std::string& key) const; 123456789

例子说明：

JsonObject object = doc.to<JsonObject>(); object["A"] = 1; object["B"] = 2; object["C"] = 3; object.remove("B"); serializeJson(object, Serial); 123456

打印结果：

{"A":1,"C":3} 1

注意：

该方法只会移除key-value，但是并不会释放key-value对应的jsondocument空间，也不建议在循环中同时add和remove key-value； 2.2.10 set —— 把一个json对象的内容设置给当前json对象

函数说明：

/** * 把一个json对象的内容设置给当前json对象 */ bool set(JsonObjectConst obj) const; 1234 2.2.11 size —— 返回对象键值对的个数

函数说明：

/** * 返回对象键值对的个数 * @return size_t 个数 */ size_t size() const; 12345

例子说明：

JsonObject object = doc.to<JsonObject>(); object["hello"] = "world"; Serial.println(object.size()); // 1 123 2.3 JsonArray

在JsonDocument所构造出来的内存空间中，Json数组的入口就是JsonArray。
让我们看看它的常用操作方法：

2.3.1 add —— 往数组中加入value

函数说明：

/** * 往数组中加入value * @param value 值 * @return bool 是否添加成功，如果返回false一般都是jsonbuffer没有足够的空间 */ bool add(bool value) const; bool add(float value) const; bool add(double value) const; bool add(signed char value) const; bool add(signed long value) const; bool add(signed int value) const; bool add(signed short value) const; bool add(unsigned char value) const; bool add(unsigned long value) const; bool add(unsigned int value) const; bool add(unsigned short value) const; bool add(const char *value) const; bool add(char *value) const; bool add(const __FlashStringHelper *value) const; bool add(const String &value) const; bool add(const std::string &value) const; bool add(JsonArray array) const; bool add(JsonObject object) const; bool add(JsonVariant variant) const; 1234567891011121314151617181920212223242526272829

例子说明：

StaticJsonDocument<200> doc; JsonArray array = doc.to<JsonArray>(); array.add("hello"); array.add(3.14156); serializeJson(doc, Serial); 12345

打印结果：

["hello",3.14156] 1 2.3.2 begin/end —— 返回一个迭代器,可用于数组中的所有对象

函数说明：

/** * 返回一个迭代器,可用于数组中的所有对象 * @return iterator */ JsonArray::iterator begin() const; JsonArray::iterator end() const; 123456

例子说明：

char json[] = "[\"one\",\"two\",\"three\"]"; DynamicJsonDocument doc(1024); deserializeJson(doc, json); JsonArray arr = doc.as<JsonArray>(); // using C++11 syntax (preferred): for (JsonVariant value : arr) { Serial.println(value.as<char*>()); } // using C++98 syntax (for older compilers): for (JsonArray::iterator it=arr.begin(); it!=arr.end(); ++it) { Serial.println(it->as<char*>()); } 1234567891011121314

打印结果：

one two three 123 2.3.3 createNestedArray —— 添加json数组

函数说明：

/** * 添加json数组 * @return JsonArray json数组 */ JsonArray createNestedArray() const; 12345

例子说明：

StaticJsonDocument<200> doc; JsonArray array = doc.to<JsonArray>(); array.add("hello"); JsonArray nested = array.createNestedArray(); nested.add("world"); serializeJson(array, Serial); 123456

打印结果：

["hello",["world"]] 1 2.3.4 createNestedObject —— 添加json对象

函数说明：

/** * 添加json对象 * @return JsonObject json对象 */ JsonObject createNestedObject() const; 12345

例子说明：

StaticJsonDocument<200> doc; JsonArray array = doc.to<JsonArray>(); JsonObject nested = array.createNestedObject(); nested["hello"] = "world"; serializeJson(array, Serial); 12345

打印结果：

[{"hello":"world"}] 1 2.3.5 getElement —— 获取对应index的值

函数说明：

/** * 获取对应index的值 */ JsonVariant getElement(size_t index) const;; 1234 2.3.6 isNull —— 判断json数组是否为空

函数说明：

/** * 判断json数组是否为空 * @Note You can use this function to: * check if the array was successfully parsed, or * check if the array was successfully allocated. */ bool isNull() const; 1234567

例子说明：

//Example 1: parsing success: StaticJsonDocument<200> doc; deserializeJson(doc, "[1,2]"); JsonArray array = doc.as<JsonArray>(); Serial.println(array.isNull()); // false //Example 2: parsing failure: StaticJsonDocument<200> doc; deserializeJson(doc, "{1,2}"); JsonArray array = doc.as<JsonArray>(); Serial.println(array.isNull()); // true //Example 3: allocation success: StaticJsonDocument<200> doc; JsonArray array = doc.to<JsonArray>(); Serial.println(array.isNull()); // false //Example 4: allocation failure: StaticJsonDocument<1> doc; JsonArray array = doc.to<JsonArray>(); Serial.println(array.isNull()); // true 123456789101112131415161718192021 2.3.7 operator[] —— set/get快捷方式

函数说明：

/** * set/get快捷方式 */ ElementProxy operator[](size_t index) const; 1234

例子说明：

//以下两句代码含义一样 JsonVariant value = array[0]; JsonVariant value = array.getElement(0); //以下两句代码含义一样 array[0] = "value"; array.getElement(0).set("value"); JsonArray array = doc.to<JsonArray>(); array.add(42); int value = array[0]; array[0] = 666; 12345678910111213 2.3.8 remove —— 移除某一个index位置的元素

函数说明：

/** * 移除某一个index位置的元素 * @param index 索引 */ void remove(size_t index) const; 12345

例子说明：

JsonArray array = doc.to<JsonArray>(); array.add("A"); array.add("B"); array.add("C"); array.remove(1); serializeJson(array, Serial); 123456

打印结果：

["A","C"] 1

注意：

该方法只会移除索引对应的value，但是并不会释放对应的jsonDocument空间，也不建议在循环中同时add和remove； 2.3.9 set —— 用另一个jsonArray代替当前jsonArray

函数说明：

/** *用另一个jsonArray代替当前jsonArray */ bool set(JsonArrayConst src) const; 1234 2.3.10 size —— 返回json数组元素的个数

函数说明：

/** * 返回json数组元素的个数 * @return size_t 个数 */ size_t size() const; 12345

例子说明：

JsonArray array = doc.to<JsonArray>(); array.add("hello"); array.add("world"); Serial.println(array.size()); // 2 1234

3.实验代码

3.1 编码Json字符串

实验材料：

Arduino板子，博主这里用Mega2560

例子代码：

/** * 编写Json字符串 * @author 单片机菜鸟 * @date 2019/06/02 */ #include <ArduinoJson.h> void setup() { Serial.begin(115200); while (!Serial) continue; // Json对象对象树的内存工具静态buffer // 200 是大小如果这个Json对象更加复杂，那么就需要根据需要去增加这个值. StaticJsonDocument<200> doc; // StaticJsonDocument 在栈区分配内存它也可以被 StaticJsonDocument（内存在堆区分配）代替 // DynamicJsonDocument doc(200); // Add values in the document // doc["sensor"] = "gps"; doc["time"] = 1351824120; // Add an array. // JsonArray data = doc.createNestedArray("data"); data.add(48.756080); data.add(2.302038); // Generate the minified JSON and send it to the Serial port. // serializeJson(doc, Serial); // The above line prints: // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]} // Start a new line Serial.println(); // The above line prints: // { // "sensor": "gps", // "time": 1351824120, // "data": [ // 48.756080, // 2.302038 // ] // } } void loop() { // not used in this example } 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647 3.2 解码Json字符串

实验材料：

Arduino板子，博主这里用Mega2560

例子代码

/** * 解析Json字符串 * @author 单片机菜鸟 * @date 2019/06/02 */ #include <ArduinoJson.h> void setup() { Serial.begin(115200); while (!Serial) continue; // Json对象对象树的内存工具静态buffer // 200 是大小如果这个Json对象更加复杂，那么就需要根据需要去增加这个值. StaticJsonDocument<200> doc; // StaticJsonDocument 在栈区分配内存它也可以被 StaticJsonDocument（内存在堆区分配）代替 // DynamicJsonDocument doc(200); char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}"; // Add an array. // // Deserialize the JSON document DeserializationError error = deserializeJson(doc, json); // Test if parsing succeeds. if (error) { Serial.print(F("deserializeJson() failed: ")); Serial.println(error.c_str()); return; } // Fetch values. // // Most of the time, you can rely on the implicit casts. // In other case, you can do doc["time"].as<long>(); const char* sensor = doc["sensor"]; long time = doc["time"]; double latitude = doc["data"][0]; double longitude = doc["data"][1]; // Print values. Serial.println(sensor); Serial.println(time); Serial.println(latitude, 6); Serial.println(longitude, 6); } void loop() { // not used in this example } 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748

注意：

解析失败通常有如下三个原因： Json字符串非法（格式不对）Json字符串产生对象JsonDocument太小