JSON数据格式及ArduinoJson-v5库

JSON学习

实例：

{
"site":[
{"name":"菜鸟教程","url":"www.runoob.com"},
{"name":"google","url":"www.google.com"},
{"name":"微博"，"url":"www.weibo.com"}
]
}

语法规则：

1. 数据在名称/值对中
2. 数据由逗号隔开、
3. 大括号保存对象
4. 中括号保存数组

由此可知实例中："site"是包含三个对象的数组，中括号中的每个数据都是由大括号括起来的对象

一、基本语法

1. 名称/值对：“name” : “菜鸟教程”，此处的值可以为数字(整数或者小数)、字符串、逻辑值、数组、对象或者为null

2. 对象：大括号{}包围的为对象，如{ “name”:“菜鸟教程” , “url”:“www.runoob.com” }

3. 数组：中括号包围的为数组，如：

   { "sites": [ { "name":"菜鸟教程" , "url":"www.runoob.com" },  { "name":"google" , "url":"www.google.com" },  { "name":"微博" , "url":"www.weibo.com" } ] }
   

   数组中又可以包含对象作为成员

4. 布尔值：true、false

5. null：空

6. 使用JavaScript语法：

   var sites = [   
   
    { "name":"runoob" , "url":"www.runoob.com" },    
   
    { "name":"google" , "url":"www.google.com" },    
   
    { "name":"微博" , "url":"www.weibo.com" } 
   
   ];
   

   此处创建了一个数组，数组的内容是三个对象，如何访问数据呢

   使用sites[0].name;会返回runoob，即访问第一个成员的name

   对它赋值修改：sites[0].name=“菜鸟教程”;

二、JSON对象

1. 对象语法

   实例：{ “name”:“runoob”, “alexa”:10000, “site”:null }

   • JSON 对象使用在大括号({})中书写。
   • 对象可以包含多个 **key/value（键/值）**对，也可以叫属性和属性值吧。
   • key 必须是字符串，value 可以是合法的 JSON 数据类型（字符串, 数字, 对象, 数组, 布尔值或 null）。
   • key 和 value 中使用冒号(:)分割。
   • 每个 key/value 对使用逗号(,)分割。

2. 访问对象值：使用 .(点号)或中括号 [] 访问对象的值，类似C语言语法

   实例：

   var myObj, x;
   
   myObj = { "name":"runoob", "alexa":10000, "site":null }; 
   
   x = myObj.name;
   

   使用 myObj.name或者myObj[“name”]均可以访问name的值

3. 循环对象：使用for-in循环对象的属性，类似python等语言的循环

   var myObj = {"name":"runoob","alexa":10000,"site":null};
   for (x in myObj){
       document.getElementById("demo").innerHTML += x + "
   ";
   }
   

   在 for-in 循环对象的属性时，使用中括号（[]）来访问属性的值：

   var myObj = { "name":"runoob", "alexa":10000, "site":null };
   for (x in myObj) {
       document.getElementById("demo").innerHTML += myObj[x] + "
   ";
   }
   

4. 嵌套json对象：即对象中包含对象

   myObj = {
       "name":"runoob",
       "alexa":10000,
       "sites": {
           "site1":"www.runoob.com",
           "site2":"m.runoob.com",
           "site3":"c.runoob.com"
       }
   }
   

   仍然使用前面的方法点号或者中括号访问嵌套对象的值

   x = myObj.sites.site1; // 或者 x = myObj.sites["site1"];
   

5. 修改对象值：访问后直接赋值即可

   myObj.sites.site1 = "www.google.com";
   //或者
   myObj.sites["site1"] = "www.google.com";
   

6. 删除对象属性：访问后使用关键字delete

   delete myObj.sites.site1;
   //或者
   delete myObj.sites["site1"]
   

三、JSON数组

1. 数组作为 JSON 对象：[ "Google", "Runoob", "Taobao" ]

   • JSON 数组在中括号中书写
   • JSON 中数组值必须是合法的 JSON 数据类型（字符串, 数字, 对象, 数组, 布尔值或 null）
   • JavaScript 中，数组值可以是以上的 JSON 数据类型，也可以是 JavaScript 的表达式，包括函数，日期及undefined

2. 对象中的数组：属性的值可以是数组

   {
   "name":"网站",
   "num":3,
   "sites":[ "Google", "Runoob", "Taobao" ]
   }
   

   使用索引值访问：x = myObj.sites[0];//访问sites属性的第一个值

3. 循环数组：使用for-in访问或者for循环访问

   for (i in myObj.sites) {
       x += myObj.sites[i] + "
   ";
   }
   

   for (i = 0; i < myObj.sites.length; i++) {
       x += myObj.sites[i] + "
   ";
   }
   

4. 嵌套对象中的数组

   JSON 对象中数组可以包含另外一个数组，或者另外一个 JSON 对象：

   myObj = {
       "name":"网站",
       "num":3,
       "sites": [
           { "name":"Google", "info":[ "Android", "Google 搜索", "Google 翻译" ] },
           { "name":"Runoob", "info":[ "菜鸟教程", "菜鸟工具", "菜鸟微信" ] },
           { "name":"Taobao", "info":[ "淘宝", "网购" ] }
       ]
   }
   

   我们可以使用 for-in 来循环访问每个数组：

   for (i in myObj.sites) {
       x += "
   " + myObj.sites[i].name + "
   ";
       for (j in myObj.sites[i].info) {
           x += myObj.sites[i].info[j] + "
   ";
      }
   }
   

5. 数组值修改：直接访问赋值

   myObj.sites[1] = "Github";

6. 删除数组元素(成员)：delete关键字

   delete myObj.site1[1]

四、JSON.parse()

parse翻译过来是解析、分析，音译帕斯、怕死。。

使用它的用途：

• JSON 通常用于与服务端交换数据。

• 在接收服务器数据时一般是字符串。

• 我们可以使用 JSON.parse() 方法将数据转换为 JavaScript 对象。

基本语法：JSON.parse(text[, reviver])

参数：

• **text:**必需， 一个有效的 JSON 字符串。
• reviver: 可选，一个转换结果的函数， 将为对象的每个成员调用此函数。

解析实例：

接收的数据：{ "name":"runoob", "alexa":10000, "site":"www.runoob.com" }

使用parse方法转换为JavaScript对象：

var obj = JSON.parse('{ "name":"runoob", "alexa":10000, "site":"www.runoob.com" }');

五、ArduinoJson 版本v5

包含三个方法：JsonBuffer、JsonObject、JsonArray

1. JsonBuffer：

   ArduinoJson库的入口，负责处理整个json数据内存管理和解析等工作，包含两个类：

   • DynamicJsonBuffer，内存分配在heap(堆)区，无固定大小，可以自动增长所需空间，方法调用完自动回收；
   • StaticJsonBuffer，内存分配在stack(栈)区，有固定大小，大小值由开发者定义，方法调用完自动回收；

   常用方法:

   • clear:

     重置内存指针，复用内存空间，慎用。一旦你调用 JsonBuffer::clear()，所有之前分配的jsonobject或者jsonbuffer都会变成无效；

   • createArray:

     创建空的json数组并且分配空间

   • createObject :

     创建空json对象，并为它分配内存空间

   • parse :

     解析json（数组或者对象）字符串

   • parseArray:

     解析json数组字符串

   • parseArray:

     解析json数组字符串

   • parseObject:

     解析json对象字符串

   • size:

     JsonBuffer当前已用大小

2. JsonObject

   在JsonBuffer构造出来的内存空间中，是Json对象的入口

   常用方法:

   • begin / end：

     返回一个迭代器,可用于对象中的所有键值对

   • containsKey：

     判断对象是否包含某一个key

   • createNestedArray:

     在当前对象中添加子key，子value为json数组

     实例：

     StaticJsonBuffer<256> jsonBuffer;
     JsonObject& root = jsonBuffer.createObject();
     root["city"] = "Paris";
     JsonObject& weather = root.createNestedObject("weather");
     weather["temp"] = 14.2;
     weather["cond"] = "cloudy";
     root.prettyPrintTo(Serial);
     
     

     输出结果:

     {
       "city": "Paris",
       "weather": {
         "temp": 14.20,
         "cond": "cloudy"
       }
     }
     

   • createNestedObject :

   在当前对象中添加子key，子value为json对象

   StaticJsonBuffer<256> jsonBuffer;
   JsonObject& root = jsonBuffer.createObject();
   root["city"] = "Paris";
   JsonObject& weather = root.createNestedObject("weather");
   weather["temp"] = 14.2;
   weather["cond"] = "cloudy";
   root.prettyPrintTo(Serial);
   
   

   {
     "city": "Paris",
     "weather": {
       "temp": 14.20,
       "cond": "cloudy"
     }
   }
   
   

   • get :

     获取某一个key的值，T表示值类型

     char json[] = "{\"pi\":3.14}";
     StaticJsonBuffer<256> jsonBuffer;
     JsonObject& object = jsonBuffer.parseObject(json);
     float pi = object.get<float>("pi"); // template version of get()
     const char* value2 = object.get<const char*>("toto"); // returns NULL
     
     

   • is:

     判断某一个key的值是否是T类型

     char json[] = "{\"name\":\"toto\",\"pi\":3.14}";
     StaticJsonBuffer<256> jsonBuffer;
     JsonObject& obj = jsonBuffer.parseObject(json);
     
     bool nameIsString = obj.is<char*>("name"); // <- true
     bool piIsFloat = obj.is<float>("pi"); // <- true
     
     // but we could also use JsonVariant.is(), like that:
     nameIsString = obj["name"].is<char*>(); // <- true
     piIsFloat = obj["pi"].is<float>(); // <- true
     
     

   • measureLength:

     计算当前对象通过printTo打印出来的长度

   • measurePrettyLength :

     计算当前对象通过prettyPrintTo打印出来的长度

   • prettyPrintTo:

     格式化输出json字符串

     /**
      * 格式化输出json字符串
      * @param buffer 内容输出到内存区
      * @param size 内存区的大小
      * @param Print 打印流 比如 Serial
      * @param String 打印到字符串
      * @return 返回已写大小
      */
     size_t prettyPrintTo(char* buffer, size_t size) const;
     size_t prettyPrintTo(char buffer[size]) const;
     size_t prettyPrintTo(Print &) const;
     size_t prettyPrintTo(String &) const;
     size_t prettyPrintTo(std::string &) const;
     
     

     StaticJsonBuffer<200> jsonBuffer;
     JsonObject& object = jsonBuffer.createObject();
     object["hello"] = "world";
     object.prettyPrintTo(Serial);
     
     /*输出的结果
     {
       "hello": "world"
     }
     */
     

   • printTo ：

     压缩式输出json字符串，该方法属于压缩式输出，可以节省空间；

     StaticJsonBuffer<200> jsonBuffer;
     JsonObject& object = jsonBuffer.createObject();
     object["hello"] = "world";
     object.printTo(Serial);
     //输出结果
     {"hello":"world"}
     

   • remove —— 移除特定key和value

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

     JsonObject& object = jsonBuffer.createObject();
     object["A"] = 1;
     object["B"] = 2;
     object["C"] = 3;
     object.remove("B");
     object.printTo(Serial);
     //结果输出:{"A":1,"C":3}
     

     该方法只会移除key-value，但是并不会释放key-value对应的jsonbuffer空间，不建议在循环中同时add和remove key-value；

   • set —— 设置特定key的值

   StaticJsonBuffer<200> jsonBuffer;
   JsonObject& object = jsonBuffer.createObject();
   object.set("hello","world");
   object.printTo(Serial);
   //结果:
   {"hello":"world"}
   

   • size —— 返回对象键值对的个数

     JsonObject& object = jsonBuffer.createObject();
     object["hello"] = "world";
     Serial.println(object.size()); // 1
     

   • operator[] —— get/set的快捷方式???即使用[]操作符

   /**函数说明
    * get/set的快捷方式
    */
   JsonVariant& operator[](const char* key);
   JsonVariant& operator[](char* key); // see Remarks
   JsonVariant& operator[](const String& key); // see Remarks
   JsonVariant& operator[](const std::string& key); // see Remarks
   JsonVariant& operator[](const __FlashStringHelper* key); // see Remarks
   
   const JsonVariant& operator[](const char* key) const;
   const JsonVariant& operator[](const String& key) const;
   const JsonVariant& operator[](const std::string& key) const;
   const JsonVariant& operator[](const __FlashStringHelper* key) const;
   
   

   JsonObject& object = jsonBuffer.createObject();
   object["hello"] = "world";
   const char* world = object["hello"];
   

   • success —— 判断对象解析是否是有效

     //Example 1: parsing success:
     StaticJsonBuffer<200> jsonBuffer;
     JsonObject& object = jsonBuffer.parseObject("{\"hello\":\"world\"}");
     Serial.println(object.success()); // true
     
     //Example 2: parsing failure:
     StaticJsonBuffer<200> jsonBuffer;
     JsonObject& object = jsonBuffer.parseObject("[\"hello\",\"world\"]");//中括号为数组
     Serial.println(object.success()); // false
     
     //Example 3: allocation success:
     StaticJsonBuffer<200> jsonBuffer;
     JsonObject& object = jsonBuffer.createObject();
     Serial.println(object.success()); // true
     
     //Example 4: allocation failure:
     StaticJsonBuffer<1> jsonBuffer;
     JsonObject& object = jsonBuffer.createObject();
     Serial.println(object.success()); // false
     

3. JsonArray

   JsonArray是Json数组的入口

   常用方法:

   • add —— 往数组中加入value

   /**
    * 往数组中加入value
    * @param value 值
    * @return bool 是否添加成功，如果返回false一般都是jsonbuffer没有足够的空间
    */
   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(const char *value);
   bool add(char *value); // see Remarks
   bool add(const String &value); // see Remarks
   bool add(const std::string &value); // see Remarks
   bool add(const __FlashStringHelper *value); // see Remarks
   bool add(JsonArray &array);
   bool add(JsonObject &object);
   bool add(const JsonVariant &variant);
   
   

   StaticJsonBuffer<200> jsonBuffer;
   JsonArray& array = jsonBuffer.createArray();
   array.add("hello");
   array.add(3.14156);
   array.printTo(Serial);
   //打印结果：["hello",3.14156]
   

   • begin/end —— 返回一个迭代器,可用于数组中的所有对象

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

   char json[] = "[\"one\",\"two\",\"three\"]";
   DynamicJsonBuffer jsonBuffer;
   JsonArray& arr = jsonBuffer.parseArray(json);
   
   // using C++11 syntax (preferred):
   for (auto 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
   

   • copyFrom —— 把c数组转成json数组

     int values[] = {1, 2, 3};
     
     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.createArray();
     array.copyFrom(values);
     array.printTo(Serial);
     //打印结果
     [1,2,3]
     

   • copyTo —— 把json数组转成c数组

     int values[3];
     
     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.parseArray("[1,2,3]");
     array.copyTo(values);//现在values变成1,2,3
     

   • createNestedArray —— 添加json数组(数组之中添加数组)

     nested为嵌套的意思

     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.createArray();
     array.add("hello");
     JsonArray& nested = array.createNestedArray();
     nested.add("world");
     array.printTo(Serial);
     //打印结果：["hello",["world"]]
     

   • createNestedObject —— 在数组中添加json对象

     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.createArray();
     JsonObject& nested = array.createNestedObject();
     nested["hello"] = "world";
     array.printTo(Serial);
     //打印结果：[{"hello":"world"}]
     

   • get —— 获取具体index的值

     • integer默认值是0
     • double默认值是0.0
     • char* 默认是是NULL

     char json[] = "[1,3.14]";
     StaticJsonBuffer<256> jsonBuffer;
     JsonArray& array = jsonBuffer.parseArray(json);
     int value0 = array.get(0); // implicit cast of the JsonVariant
     float value1 = array.get<float>(1); // template version of get()
     const char* value2 = array.get(2); // returns NULL
     

   • is —— 判断具体index的值是否为T类型

     char json[] = "[\"pi\",3.14]";
     StaticJsonBuffer<256> jsonBuffer;
     JsonArray& array = jsonBuffer.parseArray(json);
     
     bool firstIsString = array.is<char*>(0); // <- true  判断第1个key的value是否为char*类型
     bool secondIsFloat = array.is<float>(1); // <- true
     
     // but we could also use JsonVariant.is(), like that://使用中括号访问
     firstIsString = array[0].is<char*>(); // <- true
     secondIsFloat = array[1].is<float>(); // <- true
     

   • measureLength —— 计算当前json数组通过printTo打印出来的长度

   • measurePrettyLength —— 计算当前json数组通过prettyPrintTo打印出来的长度

   • prettyPrintTo —— 格式化输出json数组字符串

     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.createArray();
     array.add("hello");
     array.add("world");
     array.prettyPrintTo(Serial);
     //打印结果：
     [
       "hello",
       "world"
     ]
     

   • printTo —— 压缩式输出json数组字符串

     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.createArray();
     array.add("hello");
     array.add("world");
     array.printTo(Serial);//["hello","world"]
     

   • remove —— 移除某一个index位置的元素

     该方法只会移除索引对应的value，但是并不会释放对应的jsonbuffer空间，也不建议在循环中同时add和remove；

     JsonArray& array = jsonBuffer.createArray();
     array.add("A");
     array.add("B");
     array.add("C");
     array.remove(1);
     array.printTo(Serial);//["A","C"]
     

   • set —— 设置某一个index位置的值

     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.createArray();
     
     // increase the size of the array
     array.add(666);
     array.add(666);
     
     // replace the values
     array.set(0, "hello");
     array.add(1, 3.14156);//使用add可以覆盖掉之前的值
     
     // serialize
     array.printTo(Serial);//["hello",3.14156]
     

   • size —— 返回json数组元素的个数

     JsonArray& array = jsonBuffer.createArray();
     array.add("hello");
     array.add("world");
     Serial.println(array.size()); // 2
     

   • operator[] —— get/set 快捷快捷方式

     JsonArray& array = jsonBuffer.createArray();
     array.add(42);
     int value = array[0];
     array[0] = 666;
     

   • success —— 判断json数组是否成功分配内存或者解析

     //Example 1: parsing success:
     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.parseArray("[1,2]");
     Serial.println(array.success()); // true
     
     //Example 2: parsing failure:
     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.parseArray("{1,2}");//parseArray无法解析对象
     Serial.println(array.success()); // false
     
     //Example 3: allocation success:
     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.createArray();
     Serial.println(array.success()); // true
     
     //Example 4: allocation failure:
     StaticJsonBuffer<1> jsonBuffer;
     JsonArray& array = jsonBuffer.createArray();
     Serial.println(array.success()); // false
     

     //Example 1: parsing success:
     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.parseArray("[1,2]");
     Serial.println(array.success()); // true
     
     //Example 2: parsing failure:
     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.parseArray("{1,2}");//parseArray无法解析对象
     Serial.println(array.success()); // false
     
     //Example 3: allocation success:
     StaticJsonBuffer<200> jsonBuffer;
     JsonArray& array = jsonBuffer.createArray();
     Serial.println(array.success()); // true
     
     //Example 4: allocation failure:
     StaticJsonBuffer<1> jsonBuffer;
     JsonArray& array = jsonBuffer.createArray();
     Serial.println(array.success()); // false