深入学习ArduinoJson库 V6版本

最新推荐文章于 2024-09-13 22:28:42 发布
最新推荐文章于 2024-09-13 22:28:42 发布
阅读量2.7w 收藏 137
点赞数 27
分类专栏： Arduino 第三方库教程 文章标签： 网络
本文为博主原创文章，未经允许，请勿转载
本文链接：https://blog.csdn.net/dpjcn1990/article/details/92831648
版权

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

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

👻最近更新：ESP32 MicroPython应用

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

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

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

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

文章目录

1.前言

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

  • JSON协议
  • JsonBuffer
  • JsonObject
  • JsonArray

    接下来，我们直接进入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);

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];
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);

例子说明：

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

打印结果：

{"hello":"world"}

注意：

  • 此方法属于精简压缩化输出；
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);

例子说明：

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

打印结果：

{
  "hello": "world"
}

注意：

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

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

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

例子说明：

// 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);
2.0.5 measureJsonPretty —— 计算构造序列化格式化json的长度

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

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

例子说明：

// 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);

2.1 JsonDocument

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

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

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

    以下会作为JsonObject使用：

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

    以下会作为JsonArray使用：

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

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

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

函数说明：

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

例子说明：

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"];

注意:

  • 此方法不会改变 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);

例子说明：

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

打印结果：

["hello",3.14156]

注意:

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

函数说明：

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

注意:

  • 这个方法和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);

例子说明：

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

打印结果：

{
    "ports": [
        80,
        443
    ]
}

注意:

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

JsonArray arr = doc.createNestedArray();
arr.add("hello world");

serializeJson(doc, Serial);

打印结果：

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

JsonArray array = doc.createNestedArray("hello");
array.add("world");

serializeJson(doc, Serial);

打印结果：

{"hello":["world"]}
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);

例子说明：

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

打印结果：

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

注意:

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

JsonObject obj = doc.createNestedObject();
obj["hello"] = "world";

serializeJson(doc, Serial);

打印结果：

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

JsonObject obj = doc.createNestedObject("nested");
obj["hello"] = "world";

serializeJson(doc, Serial);

打印结果：

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

函数说明：

/**
 * 获取index位置/key的元素
 * @param index 索引位置
 * @return JsonVariant 如果找不到匹配的返回null
 */
JsonVariant getElement(size_t index);
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);
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);

注意：

  • 如果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);

例子说明：

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

打印内容：

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

函数说明：

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

例子说明：

//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 "[]"
2.1.11 memoryUsage —— jsondocument已使用内存字节数

函数说明：

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

例子说明：

char json[] = "{\"hello\":\"world\"}";
StaticJsonDocument<200> doc;
deserializeJson(doc, json);

Serial.println(doc.memoryUage());
// prints 26 on AVR
2.1.12 to —— jsondocument转成T类型

函数说明：

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

例子说明：

// allocate the JsonDocument
StaticJsonDocument<200> doc;

// convert it to a JsonObject
JsonObject root = doc.to<JsonObject>();

// set values
root["hello"] = "world";

注意：

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

JsonObject root1 = doc.to<JsonObject>();

JsonObject root2 = doc.to<JsonObject>();

// Don't use root1 here, because it's dangling!

2.2 JsonObject

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

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

函数说明：

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

例子说明：

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*>());
}

打印结果：

first
hello
second
world
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;

例子说明：

StaticJsonDocument<256> doc;
JsonObject root = doc.to<JsonObject>();
root["city"] = "Paris";

bool hasCity = root.containsKey("city"); // true
bool hasCountry = root.containsKey("country"); // false
}

注意：

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

可以改成：

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

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

const char* error = root["error"];
if (error) {
  Serial.println(error);
  return;
}
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;

例子说明：

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);

打印结果：

{
  "status": "on",
  "levels": [
    10,
    20
  ]
}
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

例子说明：

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);

打印结果：

{
  "city": "Paris",
  "weather": {
    "temp": 14.20,
    "cond": "cloudy"
  }
}
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;

例子说明：
例子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"));
}

打印结果：

Error: password is missing

例子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*>());

打印结果：

Your name is: the_duke
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;
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;

例子说明：

//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
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;

例子说明：

//以下两行代码效果等同
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"];
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;

例子说明：

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

打印结果：

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

注意：

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

函数说明：

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

函数说明：

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

例子说明：

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

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;

例子说明：

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

打印结果：

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

函数说明：

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

例子说明：

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*>());
}

打印结果：

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

函数说明：

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

例子说明：

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

打印结果：

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

函数说明：

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

例子说明：

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

打印结果：

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

函数说明：

/**
 * 获取对应index的值
 */
JsonVariant getElement(size_t index) const;;
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;

例子说明：

//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
2.3.7 operator[] —— set/get快捷方式

函数说明：

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

例子说明：

//以下两句代码含义一样
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;
2.3.8 remove —— 移除某一个index位置的元素

函数说明：

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

例子说明：

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

打印结果：

["A","C"]

注意：

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

函数说明：

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

函数说明：

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

例子说明：

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

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
}

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
}

注意：

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

4. ArduinoJson V6版本编译配置

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

5.总结

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

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

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

共同学习成长QQ群 622368884，不喜勿加，里面有一大群志同道合的探路人
在这里插入图片描述

单片机菜鸟哥
关注
专栏目录
ESP8266 + ArduinoJSON库(V6版本)数据获取和解析介绍
perseverance51博客
02-15 1426
ESP8266 + ArduinoJSON库(V6版本)数据获取和解析介绍
ArduinoJson解析JSON字符串-物联网开发必备
无线智能模块 可视DIY智能专家
05-10 2952
在Arduino中如何解析json字符串 第一步引入： #include <ArduinoJson.h> //v5.13.5 //注意有2个版本，v5和v6方法不一样 //官方文档https://arduinojson.org/v5/doc/ //翻译文档https://blog.csdn.net/dpjcn1990/article/details/92831612 主要解析代码（本文仅介绍如何解析符合的json） void time_control() { char myj
arduino aJson.h 库文件
11-01
aJson.zip
arduino JSON数据格式库
11-16
arduino Json 数据库 aJson-master--JSON数据格式库
ArduinoJson安装与配置完全指南
最新发布
gitblog_07343的博客
09-13 442
ArduinoJson安装与配置完全指南 ArduinoJson ???? JSON library for Arduino and embedded C++. Simple and efficient. 项目地址: https://g...
esp8266--arduinoJson在线解析V6版本的使用
weixin_57000913的博客
03-27 4893
在线解析官网https://arduinojson.org/ 点击Assistant 可以选择V6版本以及V5版本，这里我们选择V6版本 配置 输入你要反序列化的函数，点击Next Size 点击 NextProgram 最后就生成你所需要的反序列化代码，反序列化到这里还是没有完全的成功，还需要添加一段参数的代码，根据你的原JION文件去修改，所以推荐使用序列化的方式，序列化的优点在与方便后期的改动。 String jsonCode = "{\"info\": ...
玩转ArduinoJson库 V6版本
weixin_30546933的博客
06-18 3315
1.前言     前面，博主已经讲解了ArduinoJson库的V5版本。为了节省时间以及不讨论重复内容，博主建议读者先去阅读一下 玩转ArduinoJson库 V5版本 。重点了解几个东西： JSON协议 JsonBuffer JsonObject JsonArray     接下来，我们直接进入V6版本的学习，尽量和V5版本类比。 2.ArduinoJson V6版本     假设读者下载...
Arduino处理JSON数据
热门推荐
屁屁岚
06-20 1万+
1.资料JSON 维基百科，很详细 https://zh.wikipedia.org/wiki/JSON JSON中文官网介绍 http://www.json.org/json-zh.html 在线JSON格式化工具 http://www.jsoneditoronline.org http://tool.oschina.net/codeformat/json2.JSON总结JSON的结
玩转 ESP32 + Arduino (十五) ArduinoJSON库(V6版本)
finedayforu的博客
09-11 8096
书接上篇, 我们获取了JSON数据怎么解析, 如果将来我们想发送JSON字符串怎么操作? 原来我们可以使用arduinoJson库完成这些工作 以我们上一篇收到的JSON为例 { "results": [ { "location": { "id": "WW7MBNP039PE", "name": "泰安", "c...
ArduinoJson-6.x.zip
02-09
ArduinoJson 是一个专门为 Arduino 平台设计的 JSON 解析库，其6.x版本代表了该库的一个重要更新。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，广泛应用于 IoT（物联网）设备和微控制器之间的...
arduinojson v5升级为v6
03-16
ArduinoJson v5升级为v6的主要变化包括： 1. 支持C++11标准，提高了代码的可读性和可维护性。 2. 优化了内存管理，减少...总之，ArduinoJson v6是一个更加强大、更加稳定、更加易用的JSON库，值得开发者们升级使用。
ArduinoJson-5.x_arduinojson.h下载_ArduinoJson5_arduino库_
10-01
Arduinojson-5.x library file for the use of Arduino
Arduino处理json较大数据流以及GZIP数据流方法
perseverance51博客
05-06 1387
Arduino处理json较大数据流以及GZIP数据流方法
12. ESP32-JSON(Arduino)
m0_60134435的博客
06-07 1779
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人们阅读和编写，同时也易于机器解析和生成。JSON 是基于 JavaScript 的一个子集，虽然 JSON 是基于 JavaScript 的，但可以在许多编程语言中使用。现代的大多数编程语言都内置了 JSON 库，或者可以使用第三方库来方便地解析和生成 JSON 数据。。在Arduino框架下，使用ESP32处理JSON数据是物联网开发中一个普遍的需求。
深入学习Arduino_JSON库
单片机菜鸟哥的博客
07-26 1026
本篇主要是另外介绍一个虽然用得少但是一些经典案例会经常用的JSON库 —— Arduino_JSON库（名字看起来挺像的）。
Arduino应用开发——JSON的构建与解析
ShenZhen_zixian的博客
04-17 1万+
JSON 全称“JavaScript Object Notation”，译为“JavaScript对象简谱”或“JavaScript对象表示法”，是一种轻量级的、基于文本的、开放的数据交换格式。JSON 在Web开发领域有着举足轻重的地位，如果您想在Web开发领域大展身手的话，就必须了解JSON。
Arduino关于JsonArray中不同元素的解析
qq_40960731的博客
01-14 854
项目目的 解析 [ 1 , [ {} , {} ,{} ] ]格式的JsonArray 项目代码 //newPayload 的json格式就是 [ 1 , [ {} , {} , {} ] ] //在这里，第一个数组中每个元素格式不一样，这也是一个坑，所以建议一样 DeserializationError error = deserializeJson(doc, newPayload);//解析json if (error) { Serial.print(F("
在arduino IDE上搭建ESP32环境(解决JSON下载失败和下载速度慢的问题)
Byte Madman
09-16 9093
但是，当IDE在下载"附加开发管理器网址"中设置的网址下载对应的JSON文件时，由于这个文件来源大多是github的服务器，下载大多数情况下会失败，就算该文件下载成功，在后续下载包的过程也大多是缓慢或失败。就算用下载工具去直接下载安装包，再用离线的方式安装，但是如果因为版本更新，有可以造成下载的包不一定是最新或错误的包。三、但是下载到这个文件，并不代表就能正常下载包文件了，因为JSON文件的内容是保存了所有包的地址，里面的地址并非为镜像地址。正常来说原地址和镜像地址的主域名会有区别，后面的路径是一样的。
arduino 下载 https://downloads.arduino.cc/packages/package_index.json error
淮南草的博客
04-12 6434
成功后打开开发板管理器就会自动下载
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

单片机菜鸟哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值