Json以及Json在Qt中的使用_qt json

1、简介

JSON:一种轻量级的数据交换格式
一般.json后缀
高效简单

2、使用

组织数据:用于数据的网络传输
组织数据:用于磁盘文件实现数据的持久化存储

用在登录 记录用户名密码等，下次打开软件，自动填充。

3、Json数组

Json数组使用[]表示，[]里面是元素，元素间使用 , 分隔，最后一个元素后面，没有 ,
一个Json数组，支持多种不同的数据类型，包括:整形，浮点型，字符串，json数组，json对象，空值-null(null)
Json数组中嵌套Json数组，父子关系
Json数组嵌套Json对象，Json对象可以嵌套Json数组

3.1、数组内元素类型一致

[1, 2, 3]
["哈哈","hehe","yiyi"]
1
2

3.2、数组内元素类型不一致

[1, 2, 3, true, false, "haha",null]
1

3.3、Json数组嵌套Json数组

[
    ["cat", "狗狗", "河马", 1]//元素类型可以不一致
    [1, 3, 5, true]
]
1
2
3
4

3.4、Json数组和Json对象嵌套

[//外层是Json数组
    {//内层是Json对象
        "小明":{//属于键值对
                       "age":19,
                        "father":"大华",
                         "sister":"小妹"
                   }
         }
]
1
2
3
4
5
6
7
8
9

4、Json对象

Json对象使用{}来描述，每个Json对象可以存储若干个元素，每个元素对应一个键值对（key:value），元素和元素之间使用 , 间隔，最后一个元素后面没有 ,
注意:
1.键值key，必须是字符串，位于同一层级的键值，不能重复(通过键值取出数据value)
2.value值的类型是可选的，整形，浮点型，字符串，json数组，json对象，空值-null(null)

Json描述一个人的信息:
{
        "NAME":"ACE",
        "Sex":"man",
        "Age":20,
        "Family":{
            "Father":"yiyi",
            "brother":["aa","bb","cc"]
        },
        "IsLive":"true"
}
1
2
3
4
5
6
7
8
9
10
11

5、注意事项

, 不能乱加，解析会出错
键值不唯一，不能搜到到正确的value

一个Json.json文件中:
1、只能有一个Json数组
2、只能有一个Json对象
3、1,2只能有一个存在：根节点只能有一个
错误案例：

6、qt5.0版本 使用

将Json字符串转解析出来 原始数据

Json类 介绍

QJsonDocument(桥梁，转换器的作用)
它封装了一个完整的Json文档，并且可以从UTF-8编码的基于文本的表示以及Qt自己的读取和写入该文档

QJsonArray(Json数组)
Json数组是一个值列表。可以通过从数组中插入和删除QJsonValue来操作该列表

QJsonObject(Json对象)
Json对象是键值对的列表，其中键值是唯一的字符串，值由QJsonValue表示

QJsonValue
该类封装了Json支持的数据类型

6.1、QJsonValue

封装的数据类型6:
1.bool QJsonValue::Bool
2.double QJsonValue::Double
3.string QJsonVale::String
4.array QJsonValue.:Array
5.object QJsonValue:Object .
6.null QJsonValue::Null
通过构造函数，将6种不同的类型统一，类似，6种类型，放到一个箱子里面

6.2、QJsonObject

封装了Json中的对象，在里边可以存储多个键值对，为了方便操作，键值为字符串类型，值为QJsonValue类型，关于这个类的使用类似，C++中STL类
QJsonObject内数据使用insert插入，根据key值，自动排序，底层红黑树，升序

6.2.1、创建空的Json对象
QJsonObject::QJsonObject()   //构造空对象
6.2.2、将键值对添加到Json对象中
iterator QJsonObject::insert(const QString &key, const QJsonValue &value);//key  value
6.2.3、获取对象中，键值对个数
int QJsonObject::count() const;
int QJsonObject::size() const;
int QJsonObject::length() const;
6.2.4、通过key取出value
传入key:得到QJsonObject对象:看看是什么，在使用to方法，得到原始数据
    1、QJsonValue QJsonObject:: value(const QString &key) const;  //utf-8
    2、QJsonValue QJsonObject:: value(QLatin1QString key) const;  //字符串不支持中文
    3、QJsonValue QJsonObject:: operator[](const QString &key) const;  //使用的时候["key值"]
    4、QJsonValue QJsonObject:: operator[](QLatin1QString key) const;
6.2.5、删除键值对
void QJsonObject::remove(const QString &key);
QJsonValue QJsonObject::take(const QString &key); //删除键值对后，返回value值
6.2.6、通过key进行查找
iterator QJsonObject::find(const QString &key);        //返回的是迭代器，解引用，可以得到数据
bool QJsonObject::contains(const QString &key) const;  //查看QJsonObject对象中，是否 存在这个key键值对
6.2.7、遍历方式3种
1.使用迭代器函数
2.使用[]，遍历，类似遍历数组，[]中是key
3.先得到对象中所有的键值，在遍历键值列表，通过key得到value
    QStringList QJsonObject::keys() const;//得到当前Json对象中所有的key值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

6.3、QJsonArray

QJsonArray里面封装了Json数组，里面存储多个元素，为了方便操作，所有元素类型统一为QJsonValue类型
注意:QJsonArray内元素是无序的，完全按照添加顺序存储。
先添加，放在前面，后添加放在后面。插入，就放在插入的位置。

6.3.1、创建空的Json数组
QJsonArray::QJsonArray() //得到空的Json数组，通过size()方法，返回值为0
6.3.2、添加数据
void QJsonArray::append(const QJsonValue &value);        //在尾部追加
void QJsonArray::insert(int i, const QJsonValue &value); //插入到i的位置之前
iterator QJsonArray::insert(iterator before, const QJsonValue &value);     //在迭代器当前位置的前面，插入
void QJsonArray::prepend(const QJsonValue &value);       //添加到数组头部
void QJsonArray::push_back(const QJsonValue &value);     //添加到尾部
void QJsonArray::push_front(const QJsonValue &value);    //添加到头部
6.3.3、计算数组内元素的个数
int QJsonArray::count() const;
int QJsonArray::size() const;
6.3.4、从数组中取出某一个元素的值
QJsonValue QJsonArray::at(int i) const;   //参数i:为在数组中元素对应的下标       拷贝,不能修改数组内元素的值
QJsonValue QJsonArray::first() const;     //头部元素                           拷贝
QJsonValue QJsonArray::last() const;      //尾部元素                           拷贝
QJsonValueRef QJsonArray::operator[](int i);//这里返回的值是引用，可以修改 数组内的值
6.3.5、从数组中删除某一个元素的值
iterator QJsonArray::erase(iterator it);    //基于迭代器的删除
void QJsonArray::pop_back();                //删除尾部
void QJsonArray::pop_front();               //删除头部
void QJsonArray::removeAt(int i);           //删除i位置元素
void QJsonArray::removeFirst();             //删除头部
void QJsonArray::removeLast();              //删除尾部
QJsonValue QJsonArray::takeAt(int i);       //删除i位置的原始，并返回删除元素的值
6.3.6、遍历
1、使用迭代器遍历(和使用迭代器遍历STL容器一样)
2、使用数组方式遍历
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

6.4、QJsonDocument

它封住了一个完整的Json文档，并且可以从UTF-8编码的基于文本的表示以及Qt自己的二进制格式读取和写入该文档。
QJsonObject和QJsonArray这两个对象中的数据是不能直接转换为字符串类型的，
如果要进行数据传输或者数据的持久化，操作的都是字符串类型，不是QJsonArray或者QjsonObject类型，
需要使用Json文档进行二者之间的转换。
6.4.1、QJsonArray和QJsonObject->字符串

6.4.2、字符串->QJsonArray和QJsonObject

7、实际应用-写入-读取

//写入
QJsonObject obj;
QString str2 = "man";
obj.insert("name",QString("Ace"));
obj.insert("sex",str2);

QJsonObject subobj;
subobj.insert("Father",QString("father"));
subobj.insert("Mother",QString("mother"));

QJsonArray array;
array.append(QString("1"));
array.push_back(QString("2"));
subobj.insert("Brother",array);

obj.insert("Family",subobj);

obj.insert("IsAlive",QString("false"));
obj.insert("Comment",QString("yyds"));

QJsonDocument doc(obj); //将Json对象，转换成Json文档

//显示用
QByteArray json = doc.toJson();
ui.textEdit->setText(json);

/写入文件
QFile file("../my.json");
file.open(QFile::WriteOnly);
file.write(json);
file.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

//读取文件
QFile file("../my.json");
file.open(QFile::ReadOnly);
QByteArray all = file.readAll();
file.close();

QJsonDocument doc = QJsonDocument::fromJson(all);//转换成文档对象
if (doc.isObject())//可以不做格式判断，因为，解析的时候已经知道是什么数据了
{
    QJsonObject obj = doc.object(); //得到Json对象
    QStringList keys = obj.keys(); //得到所有key
    for (int i = 0; i < keys.size(); i++)
    {
        QString key = keys.at(i);
        QJsonValue value = obj.value(key);
        if (value.isBool())
        {
            qDebug() << key << ":" << value.toBool();
        }
        else if (value.isString())
        {
            qDebug() << key << ":" << value.toString();
        }
        else if (value.isDouble())
        {
            qDebug() << key << ":" << value.toVariant().toInt();
        }
        else if (value.isObject())
        {
            qDebug() << key << ":";
            QJsonObject subObj = value.toObject();
            QStringList subKeys = subObj.keys();
            for(int k = 0; k < subKeys.size(); ++k)
            {
            QJsonValue subValue = subObj.value(subKeys.at(k));
            if (subValue.isString())
            {
                qDebug() << " " << subKeys.at(k) << ":" << subValue.toString();
            }
            else if (subValue.isArray())
            {
                qDebug() << " " << subKeys.at(k);
                QJsonArray array = subValue.toArray();
            for (int j = 0; j < array.size(); j++)
            {
                qDebug() << " " << array[j].toString();
            }
        }
    }
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52