JSON Editors

玩转ArduinoJson库 V6版本

1.前言

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

  • JSON协议
  • JsonBuffer
  • JsonObject
  • JsonArray

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

2.ArduinoJson V6版本

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

image

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

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

2.0 解析、构造相关

2.0.1 deserializeJson —— 解析json

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

  1. /**
  2.  * 解析json
  3.  * @param doc jsondocument对象
  4.  * @param input 输入内容
  5.  * @return DeserializationError 解析结果
  6.  */
  7. // writable input => zero-copy
  8. DeserializationError deserializeJson(JsonDocument& doc, char* input);
  9. DeserializationError deserializeJson(JsonDocument& doc, char* input, size_t inputSize);
  10.  
  11. // read-only input => duplication
  12. DeserializationError deserializeJson(JsonDocument& doc, const char* input);
  13. DeserializationError deserializeJson(JsonDocument& doc, const char* input, size_t inputSize);
  14. DeserializationError deserializeJson(JsonDocument& doc, const __FlashStringHelper* input);
  15. DeserializationError deserializeJson(JsonDocument& doc, const __FlashStringHelper* input, size_t inputSize);
  16. DeserializationError deserializeJson(JsonDocument& doc, const String& input);
  17. DeserializationError deserializeJson(JsonDocument& doc, const std::string& input);
  18. DeserializationError deserializeJson(JsonDocument& doc, Stream& input);
  19. DeserializationError deserializeJson(JsonDocument& doc, std::istream& input);

DeserializationError具体内容请参考 wiki

例子说明：

  1. //Read-only input
  2. const char* json = "{\"hello\":\"world\"}";
  3. StaticJsonDocument<200> doc;
  4. deserializeJson(doc, json);
  5. const char* world = doc["hello"];
  6.  
  7. //Zero-copy mode
  8. char json[] = "{\"hello\":\"world\"}";
  9. StaticJsonDocument<200> doc;
  10. deserializeJson(doc, json);
  11. const char* world = doc["hello"];
  12.  
  13. //Raise the nesting limit
  14. char json[] = "[[[[[[[[[[[[[[[42]]]]]]]]]]]]]]]";
  15. StaticJsonDocument<200> doc;
  16. deserializeJson(doc, json, DeserializationOption::NestingLimit(15));;
  17. int answer = doc[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0];
2.0.2 serializeJson —— 构造序列化json

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

  1. /**
  2.  * 构造序列化json
  3.  * @param doc jsondocument对象
  4.  * @param output 输出内容
  5.  */
  6. serializeJson(const JsonDocument& doc, char* output, size_t outputSize);
  7. serializeJson(const JsonDocument& doc, char output[size]);
  8. serializeJson(const JsonDocument& doc, Print& output);
  9. serializeJson(const JsonDocument& doc, String& output);
  10. serializeJson(const JsonDocument& doc, std::string& output);
  11. serializeJson(const JsonDocument& doc, std::ostream& output);

例子说明：

  1. StaticJsonDocument<200> doc;
  2. doc["hello"] = "world";
  3. serializeJson(doc, Serial);

打印结果：

{"hello":"world"}

注意：

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

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

  1. /**
  2.  * 构造序列化json，格式化输出
  3.  * @param doc jsondocument对象
  4.  * @param output 输出内容
  5.  */
  6. size_t serializeJsonPretty(const JsonDocument& doc, char* output, size_t outputSize);
  7. size_t serializeJsonPretty(const JsonDocument& doc, char output[size]);
  8. size_t serializeJsonPretty(const JsonDocument& doc, Print& output);
  9. size_t serializeJsonPretty(const JsonDocument& doc, String& output);
  10. size_t serializeJsonPretty(const JsonDocument& doc, std::string& output);

例子说明：

  1. StaticJsonDocument<200> doc;
  2. doc["hello"] = "world";
  3. serializeJsonPretty(doc, Serial);

打印结果：

  1. {
  2.   "hello": "world"
  3. }

注意：

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

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

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

例子说明：

  1. // Send headers
  2. client.println("Content-Type: application/json");
  3. client.print("Content-Length: ");
  4. client.println(measureJson(doc));
  5.  
  6. // Terminate headers
  7. client.println();
  8.  
  9. // Send body
  10. serializeJson(doc, client);
2.0.5 measureJsonPretty —— 计算构造序列化格式化json的长度

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

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

例子说明：

  1. // Send headers
  2. client.println("Content-Type: application/json");
  3. client.print("Content-Length: ");
  4. client.println(measureJsonPretty(doc));
  5.  
  6. // Terminate headers
  7. client.println();
  8.  
  9. // Send body
  10. serializeJsonPretty(doc, client);

2.1 JsonDocument

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

  • DynamicJsonDocument，内存分配在heap区，无固定大小，可以自动增长所需空间，方法调用完自动回收，建议内存大小大于1KB使用；
StaticJsonDocument<256> doc;
  • StaticJsonDocument，内存分配在stack区，有固定大小，大小值由开发者定义，方法调用完自动回收，建议内存大小小于1KB使用；
DynamicJsonDocument doc(2048);

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

    以下会作为JsonObject使用：

  1. DynamicJsonDocument doc(1024);
  2. doc["answer"] = 42;
  3. // the doc contains {"answer":42}

    以下会作为JsonArray使用：

  1. DynamicJsonDocument doc(1024);
  2. doc.add(42);
  3. // the doc contains [42]

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

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

函数说明：

  1. /**
  2.  * 获取顶节点，并把它转成T类型
  3.  * @return JsonArray/JsonObject/JsonVariant
  4.  */
  5. JsonArray   as<JsonArray>();
  6. JsonObject  as<JsonObject>();
  7. JsonVariant as<JsonVariant>();

例子说明：

  1. DynamicJsonBuffer doc(1024);
  2. deserializeJson(doc, "{\"key\":\"value\")");
  3.  
  4. // get the JsonObject in the JsonDocument
  5. JsonObject root = doc.as<JsonObject>();
  6.  
  7. // get the value in the JsonObject
  8. const char* value = root["key"];

注意:

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

函数说明：

  1. /**
  2.  * 往jsondocument添加元素
  3.  * @param value 元素
  4.  */
  5. // add the specified value to the array
  6. bool add(bool value);
  7.  
  8. bool add(float value);
  9. bool add(double value);
  10.  
  11. bool add(signed char value);
  12. bool add(signed long value);
  13. bool add(signed int value);
  14. bool add(signed short value);
  15. bool add(unsigned char value);
  16. bool add(unsigned long value);
  17. bool add(unsigned int value);
  18. bool add(unsigned short value);
  19.  
  20. bool add(char *value); // see Remarks
  21. bool add(const char *value);
  22. bool add(const __FlashStringHelper *value); // see Remarks
  23.  
  24. bool add(const String &value); // see Remarks
  25. bool add(const std::string &value); // see Remarks
  26.  
  27. bool add(JsonArray array);
  28. bool add(JsonObject object);
  29. bool add(JsonVariant variant);

例子说明：

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

打印结果：

["hello",3.14156]

注意:

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

函数说明：

  1. /**
  2.  * 清除JsonDocument并释放内存空间
  3.  */
  4. void clear();

注意:

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

函数说明：

  1. /**
  2.  * 创建空json数组，并为它分配内存空间
  3.  * @param key key名称
  4.  * @return JsonArray 
  5.  */
  6. // similar to JsonArray::createNestedArray()
  7. JsonArray createNestedArray();
  8.  
  9. // similar to JsonObject::createNestedArray()
  10. JsonArray createNestedArray(char* key);
  11. JsonArray createNestedArray(const char* key);
  12. JsonArray createNestedArray(const __FlashStringHelper* key);
  13. JsonArray createNestedArray(const String& key);
  14. JsonArray createNestedArray(const std::string& key);

例子说明：

  1. DynamicJsonDocument doc(1024);
  2. JsonArray ports = doc.createNestedArray("ports");
  3. ports.add("80");
  4. ports.add("443");

打印结果：

  1. {
  2.     "ports": [
  3.         80,
  4.         443
  5.     ]
  6. }

注意:

  • 对于无参数的createNestedArray()方法，会创建一个Json数组并把它追加到顶节点的数组中。如果document的顶节点不是数组，这个方法无效；如果document是空的，这个方法会初始化一个数组顶节点，参考以下代码：
  1. StaticJsonDocument<200> doc;
  2.  
  3. JsonArray arr = doc.createNestedArray();
  4. arr.add("hello world");
  5.  
  6. serializeJson(doc, Serial);

打印结果：

[["hello world"]]
  • 对于有参数的createNestedArray()方法，会创建一个json数组并把它指向这个特定的key。如果document的顶节点不是对象，这个方法无效；如果document是空的，这个方法会初始化一个对象顶节点，参考以下代码：
  1. StaticJsonDocument<200> doc;
  2.  
  3. JsonArray array = doc.createNestedArray("hello");
  4. array.add("world");
  5.  
  6. serializeJson(doc, Serial);

打印结果：

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

函数说明：

  1. /**
  2.  * 创建空json对象，并为它分配内存空间
  3.  * @param key key名称
  4.  * @return JsonObject 
  5.  */
  6. // similar to JsonArray::createNestedArray()
  7. // similar to JsonArray::createNestedObject()
  8. JsonObject createNestedObject();
  9.  
  10. // similar to JsonObject::createNestedObject()
  11. JsonObject createNestedObject(char* key);
  12. JsonObject createNestedObject(const char* key);
  13. JsonObject createNestedObject(const __FlashStringHelper* key);
  14. JsonObject createNestedObject(const String& key);
  15. JsonObject createNestedObject(const std::string& key);

例子说明：

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

打印结果：

  1. {
  2.     "wifi": {
  3.         "SSID": "TheBatCave"
  4.     }
  5. }

注意:

  • 对于无参数的createNestedObject()方法，会创建一个Json对象并把它追加到顶节点的数组中。如果document的顶节点不是数组，这个方法无效；如果document是空的，这个方法会初始化一个数组顶节点，参考以下代码：
  1. StaticJsonDocument<200> doc;
  2.  
  3. JsonObject obj = doc.createNestedObject();
  4. obj["hello"] = "world";
  5.  
  6. serializeJson(doc, Serial);

打印结果：

[{"hello":"world"}]
  • 对于有参数的createNestedObject()方法，会创建一个json数组并把它指向这个特定的key。如果document的顶节点不是对象，这个方法无效；如果document是空的，这个方法会初始化一个对象顶节点，参考以下代码：
  1. StaticJsonDocument<200> doc;
  2.  
  3. JsonObject obj = doc.createNestedObject("nested");
  4. obj["hello"] = "world";
  5.  
  6. serializeJson(doc, Serial);

打印结果：

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

函数说明：

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

函数说明：

  1. /**
  2.  * 获取key对应的value
  3.  * @param key 对应的key
  4.  * @param JsonVariant key对应的value，如果不匹配返回null
  5.  */
  6. JsonVariant getMember(const char* key);
  7. JsonVariant getMember(String key);
  8. JsonVariant getMember(std::string key);
  9. JsonVariant getMember(const __FlashStringHelper* key);
2.1.8 getOrCreateMember —— 获取或者创建key对应的value

函数说明：

  1. /**
  2.  * 获取或者创建key对应的value
  3.  * @param key 对应的key
  4.  * @param JsonVariant key对应的value，如果不匹配返回null
  5.  */
  6. JsonVariant getOrCreateMember(const char* key);
  7. JsonVariant getOrCreateMember(String key);
  8. JsonVariant getOrCreateMember(std::string key);
  9. JsonVariant getOrCreateMember(const __FlashStringHelper* key);

注意：

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

函数说明：

  1. /**
  2.  * 快捷操作符
  3.  * @param key 对象中对应的key
  4.  * @param index 数组中对应的索引
  5.  */
  6. // mimics a JsonArray
  7. ElementProxy operator[](size_t index);
  8.  
  9. // mimics a JsonObject
  10. MemberProxy operator[](const char* key);
  11. MemberProxy operator[](char* key);
  12. MemberProxy operator[](const String& key);
  13. MemberProxy operator[](const std::string& key);
  14. MemberProxy operator[](const __FlashStringHelper* key);

例子说明：

  1. StaticJsonDocument<256> doc;
  2. doc["wifi"]["SSID"] = "TheBatCave";

打印内容：

  1. {
  2.     "wifi": {
  3.         "SSID": "TheBatCave"
  4.     }
  5. }
2.1.10 isNull —— 判断jsondocument是否为空

函数说明：

  1. /**
  2.  * 判断jsondocument是否为空
  3.  */
  4. bool isNull() const;

例子说明：

  1. //Result is true
  2. DynamicJsonDocument doc(1024);
  3. doc.isNull(); // true
  4. serializeJson(doc, Serial); // prints "null"
  5.  
  6. //Result is false
  7. DynamicJsonDocument doc(1024);
  8. doc.to<JsonArray>();
  9. doc.isNull(); // false
  10. serializeJson(doc, Serial); // prints "[]"
2.1.11 memoryUsage —— jsondocument已使用内存字节数

函数说明：

  1. /**
  2.  * jsondocument已使用内存字节数
  3.  */
  4. size_t memoryUsage() const;

例子说明：

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

函数说明：

  1. /**
  2.  * jsondocument转成T类型,T为JsonArray、JsonObject、JsonVariant
  3.  */
  4. JsonArray   to<JsonArray>();
  5. JsonObject  to<JsonObject>();
  6. JsonVariant to<JsonVariant>();

例子说明：

  1. // allocate the JsonDocument
  2. StaticJsonDocument<200> doc;
  3.  
  4. // convert it to a JsonObject
  5. JsonObject root = doc.to<JsonObject>();
  6.  
  7. // set values
  8. root["hello"] = "world";

注意：

  • 此方法是释放jsondocument的内存空间，也就是说之前已经分配的引用无效，参考代码：
  1. DynamicJsonBuffer doc(1024);
  2.  
  3. JsonObject root1 = doc.to<JsonObject>();
  4.  
  5. JsonObject root2 = doc.to<JsonObject>();
  6.  
  7. // Don't use root1 here, because it's dangling!

2.2 JsonObject

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

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

函数说明：

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

例子说明：

  1. char json[] = "{\"first\":\"hello\",\"second\":\"world\"}";
  2. DynamicJsonDocument doc(1024);
  3. deserializeJson(doc, json);
  4. JsonObject root = doc.as<JsonObject>();
  5.  
  6. // using C++11 syntax (preferred):
  7. for (JsonPair kv : root) {
  8.     Serial.println(kv.key().c_str());
  9.     Serial.println(kv.value().as<char*>());
  10. }
  11.  
  12. // using C++98 syntax (for older compilers):
  13. for (JsonObject::iterator it=root.begin(); it!=root.end(); ++it) {
  14.     Serial.println(it->key().c_str());
  15.     Serial.println(it->value().as<char*>());
  16. }

打印结果：

  1. first
  2. hello
  3. second
  4. world
2.2.2 containsKey —— 判断对象是否包含某一个key

函数说明：

  1. /**
  2.  * 判断对象是否包含某一个key
  3.  * @param key key名字
  4.  * @return bool
  5.  */
  6. bool containsKey(const char* key) const;
  7. bool containsKey(const String& key) const;
  8. bool containsKey(const std::string& key) const;
  9. bool containsKey(const __FlashStringHelper& key) const;

例子说明：

  1. StaticJsonDocument<256> doc;
  2. JsonObject root = doc.to<JsonObject>();
  3. root["city"] = "Paris";
  4.  
  5. bool hasCity = root.containsKey("city"); // true
  6. bool hasCountry = root.containsKey("country"); // false
  7. }

注意：

  • json库的开发者不建议使用该方法，因为就算没有值也会返回一个空值。库开发者给了例子建议：
  1. if (root.containsKey("error")) {
  2.   const char* error = root["error"]
  3.   Serial.println(error);
  4.   return;
  5. }

可以改成：

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

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

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

函数说明：

  1. /**
  2.  * 在当前对象中添加子key，子value为json数组
  3.  * @param key key名字
  4.  * @return JsonArray
  5.  */
  6. JsonArray createNestedArray(char* key) const;
  7. JsonArray createNestedArray(const char* key) const;
  8. JsonArray createNestedArray(const __FlashStringHelper* key) const;
  9.  
  10. JsonArray createNestedArray(const String& key) const;
  11. JsonArray createNestedArray(const std::string& key) const;

例子说明：

  1. StaticJsonDocument<256> doc;
  2. JsonObject root = doc.to<JsonObject>();
  3. root["status"] = "on";
  4. JsonArray levels = root.createNestedArray("levels");
  5. levels.add(10);
  6. levels.add(30);
  7. serializeJsonPretty(root, Serial);

打印结果：

  1. {
  2.   "status": "on",
  3.   "levels": [
  4.     10,
  5.     20
  6.   ]
  7. }
2.2.4 createNestedObject —— 在当前对象中添加子key，子value为json对象

函数说明：

  1. /**
  2.  * 在当前对象中添加子key，子value为json对象
  3.  * @param key key名字
  4.  * @return JsonObject对象
  5.  */
  6. JsonObject createNestedObject(char* key) const;
  7. JsonObject createNestedObject(const char* key) const;
  8. JsonObject createNestedObject(const __FlashStringHelper* key) const;
  9.  
  10. JsonObject createNestedObject(const String& key) const; // see Remarks
  11. JsonObject createNestedObject(const std::string& key) const; // see Remarks

例子说明：

  1. StaticJsonDocument<256> doc;
  2. JsonObject root = doc.to<JsonObject>();
  3. root["city"] = "Paris";
  4. JsonObject weather = root.createNestedObject("weather");
  5. weather["temp"] = 14.2;
  6. weather["cond"] = "cloudy";
  7. serializeJsonPretty(root, Serial);

打印结果：

  1. {
  2.   "city": "Paris",
  3.   "weather": {
  4.     "temp": 14.20,
  5.     "cond": "cloudy"
  6.   }
  7. }
2.2.5 getMember —— 获取对象中给到key的value

函数说明：

  1. /**
  2.  * 获取对象中给到key的value
  3.  * @param key key名字
  4.  * @return JsonVariant对象
  5.  */
  6. JsonVariant getMember(const char* key) const;
  7. JsonVariant getMember(const __FlashStringHelper* key) const;
  8.  
  9. JsonVariant getMember(const String& key) const;
  10. JsonVariant getMember(const std::string& key) const;

例子说明：
例子1：

  1. //The key is not found
  2. char json[] = "{\"username\":\"the_duke\"}";
  3.  
  4. StaticJsonDocument<256> doc;
  5. deserializeJson(doc, json);
  6.  
  7. JsonObject object = doc.as<JsonObject>();
  8.  
  9. JsonVariant password = object.getMember("password");
  10. if (password.isNull()) {
  11.   Serial.println(F("Error: password is missing"));
  12. }

打印结果：

Error: password is missing

例子2：

  1. //The key is found
  2. char json[] = "{\"username\":\"the_duke\"}";
  3.  
  4. StaticJsonDocument<256> doc;
  5. deserializeJson(doc, json);
  6.  
  7. JsonObject object = doc.as<JsonObject>();
  8.  
  9. JsonVariant username = object.getMember("username");
  10. Serial.println(F("Your name is: "));
  11. Serial.println(username.as<const char*>());

打印结果：

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

函数说明：

  1. /**
  2.  * 获取对象中给到key的value,如果没有就创建
  3.  * @param key key名字
  4.  * @return JsonVariant对象
  5.  */
  6. JsonVariant getOrCreateMember(char* key) const;
  7. JsonVariant getOrCreateMember(const char* key) const;
  8. JsonVariant getOrCreateMember(const __FlashStringHelper* key) const;
  9.  
  10. JsonVariant getOrCreateMember(const String& key) const;
  11. JsonVariant getOrCreateMember(const std::string& key) const;
2.2.7 isNull —— 判断对象是否为空

函数说明：

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

例子说明：

  1. //Example 1: parsing success:
  2. StaticJsonDocument<200> doc;
  3. deserializeJson(doc, "{\"hello\":\"world\"}");
  4. JsonObject object = doc.as<JsonObject>();
  5. Serial.println(object.isNull()); // false
  6.  
  7. //Example 2: parsing failure:
  8. StaticJsonDocument<200> doc;
  9. deserializeJson(doc, "[\"hello\",\"world\"]");
  10. JsonObject object = doc.as<JsonObject>();
  11. Serial.println(object.isNull()); // true
  12.  
  13. //Example 3: allocation success:
  14. StaticJsonDocument<200> doc;
  15. JsonObject object = doc.to<JsonObject>();
  16. Serial.println(object.isNull()); // false
  17.  
  18. //Example 4: allocation failure:
  19. StaticJsonDocument<1> doc;
  20. JsonObject object = doc.to<JsonObject>();
  21. Serial.println(object.isNull()); // true
2.2.8 operator[] —— get/set快捷方式

函数说明：

  1. /**
  2.  * get/set快捷方式
  3.  */
  4. MemberProxy operator[](char* key) const;
  5. MemberProxy operator[](const char* key) const;
  6. MemberProxy operator[](const __FlashStringHelper* key) const;
  7.  
  8. MemberProxy operator[](const String& key) const;
  9. MemberProxy operator[](const std::string& key) const;

例子说明：

  1. //以下两行代码效果等同
  2. JsonVariant value = object["key"];
  3. JsonVariant value = object.getMember("key");
  4.  
  5. //以下两行代码效果等同
  6. object["key"] = "value";
  7. object.getOrCreateMember("key").set("value");
  8.  
  9. StaticJsonDocument<256> doc;
  10. JsonObject object = doc.to<JsonObject>();
  11. object["hello"] = "world";
  12. const char* world = object["hello"];
2.2.9 remove —— 移除特定key和value

函数说明：

  1. /**
  2.  * 移除特定key和value
  3.  * @param key key名
  4.  */
  5. void remove(const char* key) const;
  6. void remove(const __FlashStringHelper* key) const;
  7.  
  8. void remove(const String& key) const;
  9. void remove(const std::string& key) const;

例子说明：

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

打印结果：

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

注意：

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

函数说明：

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

函数说明：

  1. /**
  2.  * 返回对象键值对的个数
  3.  * @return size_t 个数
  4.  */
  5. size_t size() const;

例子说明：

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

2.3 JsonArray

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

2.3.1 add —— 往数组中加入value

函数说明：

  1. /**
  2.  * 往数组中加入value
  3.  * @param value 值
  4.  * @return bool 是否添加成功，如果返回false一般都是jsonbuffer没有足够的空间
  5.  */
  6. bool add(bool value) const;
  7.  
  8. bool add(float value) const;
  9. bool add(double value) const;
  10.  
  11. bool add(signed char value) const;
  12. bool add(signed long value) const;
  13. bool add(signed int value) const;
  14. bool add(signed short value) const;
  15. bool add(unsigned char value) const;
  16. bool add(unsigned long value) const;
  17. bool add(unsigned int value) const;
  18. bool add(unsigned short value) const;
  19.  
  20. bool add(const char *value) const;
  21. bool add(char *value) const;
  22. bool add(const __FlashStringHelper *value) const;
  23.  
  24. bool add(const String &value) const;
  25. bool add(const std::string &value) const;
  26.  
  27. bool add(JsonArray array) const;
  28. bool add(JsonObject object) const;
  29. bool add(JsonVariant variant) const;

例子说明：

  1. StaticJsonDocument<200> doc;
  2. JsonArray array = doc.to<JsonArray>();
  3. array.add("hello");
  4. array.add(3.14156);
  5. serializeJson(doc, Serial);

打印结果：

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

函数说明：

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

例子说明：

  1. char json[] = "[\"one\",\"two\",\"three\"]";
  2. DynamicJsonDocument doc(1024);
  3. deserializeJson(doc, json);
  4. JsonArray arr = doc.as<JsonArray>();
  5.  
  6. // using C++11 syntax (preferred):
  7. for (JsonVariant value : arr) {
  8.     Serial.println(value.as<char*>());
  9. }
  10.  
  11. // using C++98 syntax (for older compilers):
  12. for (JsonArray::iterator it=arr.begin(); it!=arr.end(); ++it) {
  13.     Serial.println(it->as<char*>());
  14. }

打印结果：

  1. one
  2. two
  3. three
2.3.3 createNestedArray —— 添加json数组

函数说明：

  1. /**
  2.  * 添加json数组
  3.  * @return  JsonArray json数组
  4.  */
  5. JsonArray createNestedArray() const;

例子说明：

  1. StaticJsonDocument<200> doc;
  2. JsonArray array = doc.to<JsonArray>();
  3. array.add("hello");
  4. JsonArray nested = array.createNestedArray();
  5. nested.add("world");
  6. serializeJson(array, Serial);

打印结果：

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

函数说明：

  1. /**
  2.  * 添加json对象
  3.  * @return  JsonObject json对象
  4.  */
  5. JsonObject createNestedObject() const;

例子说明：

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

打印结果：

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

函数说明：

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

函数说明：

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

例子说明：

  1. //Example 1: parsing success:
  2. StaticJsonDocument<200> doc;
  3. deserializeJson(doc, "[1,2]");
  4. JsonArray array = doc.as<JsonArray>();
  5. Serial.println(array.isNull()); // false
  6.  
  7. //Example 2: parsing failure:
  8. StaticJsonDocument<200> doc;
  9. deserializeJson(doc, "{1,2}");
  10. JsonArray array = doc.as<JsonArray>();
  11. Serial.println(array.isNull()); // true
  12.  
  13. //Example 3: allocation success:
  14. StaticJsonDocument<200> doc;
  15. JsonArray array = doc.to<JsonArray>();
  16. Serial.println(array.isNull()); // false
  17.  
  18. //Example 4: allocation failure:
  19. StaticJsonDocument<1> doc;
  20. JsonArray array = doc.to<JsonArray>();
  21. Serial.println(array.isNull()); // true
2.3.7 operator[] —— set/get快捷方式

函数说明：

  1. /**
  2.  * set/get快捷方式
  3.  */
  4. ElementProxy operator[](size_t index) const;

例子说明：

  1. //以下两句代码含义一样
  2. JsonVariant value = array[0];
  3. JsonVariant value = array.getElement(0);
  4.  
  5. //以下两句代码含义一样
  6. array[0] = "value";
  7. array.getElement(0).set("value");
  8.  
  9. JsonArray array = doc.to<JsonArray>();
  10. array.add(42);
  11. int value = array[0];
  12. array[0] = 666;
2.3.8 remove —— 移除某一个index位置的元素

函数说明：

  1. /**
  2.  * 移除某一个index位置的元素
  3.  * @param index 索引
  4.  */
  5. void remove(size_t index) const;

例子说明：

  1. JsonArray array = doc.to<JsonArray>();
  2. array.add("A");
  3. array.add("B");
  4. array.add("C");
  5. array.remove(1);
  6. serializeJson(array, Serial);

打印结果：

["A","C"]

注意：

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

函数说明：

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

函数说明：

  1. /**
  2.  * 返回json数组元素的个数
  3.  * @return size_t 个数
  4.  */
  5. size_t size() const;

例子说明：

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

3.实验代码

3.1 编码Json字符串

实验材料：

  • Arduino板子，博主这里用Mega2560

例子代码：

  1. /**
  2.  * 编写Json字符串
  3.  * @author 单片机菜鸟
  4.  * @date 2019/06/02
  5.  */
  6. #include <ArduinoJson.h>
  7.  
  8. void setup() {
  9.   Serial.begin(115200);
  10.   while (!Serial) continue;
  11.   // Json对象对象树的内存工具 静态buffer 
  12.   // 200 是大小 如果这个Json对象更加复杂，那么就需要根据需要去增加这个值.
  13.   StaticJsonDocument<200> doc;
  14.   // StaticJsonDocument 在栈区分配内存   它也可以被 StaticJsonDocument（内存在堆区分配） 代替
  15.   // DynamicJsonDocument  doc(200);
  16.   // Add values in the document
  17.   //
  18.   doc["sensor"] = "gps";
  19.   doc["time"] = 1351824120;
  20.  
  21.   // Add an array.
  22.   //
  23.   JsonArray data = doc.createNestedArray("data");
  24.   data.add(48.756080);
  25.   data.add(2.302038);
  26.  
  27.   // Generate the minified JSON and send it to the Serial port.
  28.   //
  29.   serializeJson(doc, Serial);
  30.   // The above line prints:
  31.   // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
  32.   // Start a new line
  33.   Serial.println();
  34.   // The above line prints:
  35.   // {
  36.   //   "sensor": "gps",
  37.   //   "time": 1351824120,
  38.   //   "data": [
  39.   //     48.756080,
  40.   //     2.302038
  41.   //   ]
  42.   // }
  43. }
  44.  
  45. void loop() {
  46.   // not used in this example
  47. }

3.2 解码Json字符串

实验材料：

  • Arduino板子，博主这里用Mega2560

例子代码

  1. /**
  2.  * 解析Json字符串
  3.  * @author 单片机菜鸟
  4.  * @date 2019/06/02
  5.  */
  6. #include <ArduinoJson.h>
  7.  
  8. void setup() {
  9.   Serial.begin(115200);
  10.   while (!Serial) continue;
  11.   // Json对象对象树的内存工具 静态buffer 
  12.   // 200 是大小 如果这个Json对象更加复杂，那么就需要根据需要去增加这个值.
  13.   StaticJsonDocument<200> doc;
  14.   // StaticJsonDocument 在栈区分配内存   它也可以被 StaticJsonDocument（内存在堆区分配） 代替
  15.   // DynamicJsonDocument  doc(200);
  16.   char json[] =
  17.       "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
  18.  
  19.   // Add an array.
  20.   //
  21.   // Deserialize the JSON document
  22.   DeserializationError error = deserializeJson(doc, json);
  23.  
  24.   // Test if parsing succeeds.
  25.   if (error) {
  26.     Serial.print(F("deserializeJson() failed: "));
  27.     Serial.println(error.c_str());
  28.     return;
  29.   }
  30.   // Fetch values.
  31.   //
  32.   // Most of the time, you can rely on the implicit casts.
  33.   // In other case, you can do doc["time"].as<long>();
  34.   const char* sensor = doc["sensor"];
  35.   long time = doc["time"];
  36.   double latitude = doc["data"][0];
  37.   double longitude = doc["data"][1];
  38.  
  39.   // Print values.
  40.   Serial.println(sensor);
  41.   Serial.println(time);
  42.   Serial.println(latitude, 6);
  43.   Serial.println(longitude, 6);
  44. }
  45.  
  46. void loop() {
  47.   // not used in this example
  48. }

注意：

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

4. ArduinoJson V6版本编译配置

请参考V5版本说明，非常类似。

5.总结

自此，V5和V6版本已经讲解完毕，往读者深入体会一下，其实也是非常简单的用法。

转载于:https://www.cnblogs.com/danpianjicainiao/p/11048688.html

相关工具

JSON格式化

在线JSON格式化工具，支持压缩和美化

JSON验证

验证JSON格式是否正确

JSON转换

JSON转XML、CSV等格式

JSON美化

美化JSON数据，提高可读性