devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Qt Json详细介绍

作者：繁依Fanyi0 | 2024-08-22 13:12:41

赞

踩

qt json

一.概念介绍

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，常用于前后端数据传输和存储。它具有以下特点：

  1. 易读性：JSON 使用人类可读的文本格式表示数据，采用键值对的方式组织数据，易于阅读和编辑。

  2. 轻量级：JSON 数据格式较为简洁，不包含冗余信息，适合网络传输和存储。

  3. 自描述性：JSON 数据的结构清晰明了，键值对以及数组的嵌套结构能够清晰地表示复杂数据。

  4. 易于解析：JSON 数据可以方便地被解析成多种编程语言中的数据结构，如对象、数组等。

  5. 跨平台兼容：由于 JSON 是一种文本格式，不依赖特定的编程语言，能够被多种编程语言解析和生成。

JSON 数据通常由对象（Object）和数组（Array）组成：

  • 对象(Object)：由一组键值对构成，使用大括号 {} 表示。示例：{“name”: “Alice”, “age”: 30}
  • 数组(Array)：由一组值构成，使用中括号 [] 表示。数组中的元素可以是对象、数组或基本数据类型。示例：[“apple”, “banana”, “cherry”]

总之，JSON 是一种简单、轻量级、易读的数据交换格式，被广泛应用于 Web 开发、API 设计和数据交换等领域。通过了解 JSON 的基本概念和语法规则，可以更好地进行数据交互与处理。

二.重要的部分介绍

1. QJsonDocument:

  • QJsonDocument 类用于表示整个 JSON 文档，可以包含一个 JSON 对象或一个 JSON 数组。
  • 可以使用该类来创建、读取、写入和操作 JSON 数据。
  • 成员函数：toJson() 将 JSON 文档转换为字符串，fromJson() 从字符串中解析 JSON 数据。

示例代码如下：

#include <QCoreApplication>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 创建 JSON 对象
    QJsonObject personObject;
    personObject["name"] = "Alice";
    personObject["age"] = 30;
    personObject["isStudent"] = true;

    QJsonArray fruitsArray = {"apple", "banana", "cherry"};
    personObject["favoriteFruits"] = fruitsArray;

    QJsonObject addressObject;
    addressObject["city"] = "New York";
    addressObject["zipcode"] = "10001";
    personObject["address"] = addressObject;

    // 将 JSON 对象转换为 JSON 文档
    QJsonDocument jsonDocument(personObject);

    // 将 JSON 文档转换为 JSON 字符串
    QString jsonString = jsonDocument.toJson();

    qDebug() << "Generated JSON string:" << jsonString;

    // 解析 JSON 字符串为 JSON 文档
    QJsonDocument parsedDocument = QJsonDocument::fromJson(jsonString.toUtf8());

    if (!parsedDocument.isNull() && parsedDocument.isObject()) {
        QJsonObject parsedObject = parsedDocument.object();

        QString name = parsedObject["name"].toString();
        int age = parsedObject["age"].toInt();
        bool isStudent = parsedObject["isStudent"].toBool();

        qDebug() << "Parsed name:" << name;
        qDebug() << "Parsed age:" << age;
        qDebug() << "Parsed isStudent:" << isStudent;
    } else {
        qDebug() << "Failed to parse JSON";
    }

    return a.exec();
}

  • 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

2.QJsonObject（这和map很相似）

  • QJsonObject 类用于表示 JSON 对象，它是键值对的集合，其中键为字符串，值可以是字符串、整数、布尔值、对象或数组。
  • 可以通过下标操作符 [] 或 insert() 方法来添加键值对。
  • 成员函数：value() 可以获取指定键对应的值，contains() 用于检查是否包含指定键。

示例代码如下：

#include <QCoreApplication>
#include <QJsonObject>
#include <QJsonArray>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 创建一个空的 JSON 对象
    QJsonObject personObject;

    // 添加键值对到 JSON 对象
    personObject["name"] = "Alice";
    personObject["age"] = 30;
    personObject["isStudent"] = true;

    // 创建包含一组值的 JSON 数组
    QJsonArray fruitsArray = {"apple", "banana", "cherry"};
    personObject["favoriteFruits"] = fruitsArray;

    // 创建一个嵌套的 JSON 对象
    QJsonObject addressObject;
    addressObject["city"] = "New York";
    addressObject["zipcode"] = "10001";
    personObject["address"] = addressObject;

    // 访问和输出 JSON 对象中的值
    qDebug() << "Name:" << personObject["name"].toString();
    qDebug() << "Age:" << personObject["age"].toInt();
    qDebug() << "Is Student:" << personObject["isStudent"].toBool();

    // 访问嵌套的 JSON 对象中的值
    QJsonObject nestedAddress = personObject["address"].toObject();
    qDebug() << "City:" << nestedAddress["city"].toString();
    qDebug() << "Zipcode:" << nestedAddress["zipcode"].toString();

    // 修改 JSON 对象中的值
    personObject["age"] = 35;

    // 移除 JSON 对象中的某个键值对
    personObject.remove("isStudent");

    // 转换 JSON 对象为字符串
    QJsonDocument jsonDocument(personObject);
    QString jsonString = jsonDocument.toJson();

    qDebug() << "Updated JSON object:" << jsonString;

    return a.exec();
}

  • 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

3. QJsonArray

  • QJsonArray 类用于表示 JSON 数组，它是值的有序集合，值可以是字符串、整数、布尔值、对象或数组。
  • 可以使用 append()、insert()、at() 等方法操作数组元素。
  • 成员函数：size() 返回数组中元素的数量，at() 根据索引获取指定位置的元素。
#include <QCoreApplication>
#include <QJsonObject>
#include <QJsonArray>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 创建一个空的 JSON 数组
    QJsonArray fruitsArray;

    // 向 JSON 数组添加元素
    fruitsArray.append("apple");
    fruitsArray.append("banana");
    fruitsArray.append("cherry");

    // 创建一个包含多个不同类型元素的 JSON 数组
    QJsonArray mixedArray;
    mixedArray.append(10);
    mixedArray.append(true);
    mixedArray.append("hello");

    // 输出数组元素
    qDebug() << "Fruits in the array:";
    for(const QJsonValue &value : fruitsArray) {
        qDebug() << value.toString();
    }

    qDebug() << "Elements in mixed array:";
    for(const QJsonValue &value : mixedArray) {
        if(value.isBool()) {
            qDebug() << value.toBool();
        } else if(value.isDouble()) {
            qDebug() << value.toDouble();
        } else if(value.isString()) {
            qDebug() << value.toString();
        }
    }

    // 访问数组元素
    qDebug() << "First fruit:" << fruitsArray.at(0).toString();
    qDebug() << "Last fruit:" << fruitsArray.last().toString();

    // 修改数组元素
    fruitsArray.replace(1, "pear");

    // 移除数组元素
    fruitsArray.removeAt(2);

    // 转换 JSON 数组为字符串
    QJsonDocument jsonDocument(fruitsArray);
    QString jsonString = jsonDocument.toJson();

    qDebug() << "Updated JSON array:" << jsonString;

    return a.exec();
}

  • 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
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58

4.JSON 数据的解析

  • 使用 QJsonDocument::fromJson() 将 JSON 字符串解析为 QJsonDocument 对象。
  • 判断解析后的对象类型（是对象还是数组），然后获取各个属性的值。

5. QString与QByteArray

在 Qt 中，QString 和 QByteArray 是两种用于处理字符串数据的类，它们在存储和操作字符串上有一些不同之处。下面是关于 QString 和 QByteArray 的详细介绍：

QString

  • QString 是 Qt 中用于表示 Unicode 字符串的类，它支持多种字符编码，包括 UTF-8、UTF-16 等。

  • 特点：

  1. 支持 Unicode 字符，可以表示任意国家地区的字符。
  2. 自动转码：QString 会自动处理不同字符编码之间的转换。例如，可以使用 toUtf8() 方法将 QString 转换为 QByteArray。
  3. 提供了丰富的字符串操作方法，如拼接、查找、替换、大小写转换等。

使用场景：

  • 存储用户界面文本、表示用户输入。
  • 作为跨平台的字符串处理工具，便于处理各种字符编码和国际化需求。

QByteArray

  • QByteArray 是 Qt 中用于表示字节数据的类，通常用于存储二进制数据或者不包含特定字符编码的文本数据。

特点：

  1. 与 QString 不同，QByteArray 主要是字节级别的操作，适用于处理二进制数据。
  2. 通常用于读写文件、网络数据、加密解密等场景。
  3. 字节数据一般不涉及字符编码的转换，更适合存储不特定编码的数据。

使用场景：

  • 存储二进制数据，如图片、音频、视频等。
  • 读写文件内容，处理网络数据传输。
  • 加密解密操作等需要处理字节数据的场景。

总结

  • 如果需要处理文本数据，并且涉及到字符串操作、多语言支持或者用户界面相关的文本处理，通常使用 QString。

  • 如果处理的数据为字节数据、二进制数据或者不需要特定字符编码的数据，可以使用 QByteArray。

三.JSON读写文件实战

  • Json格式如下：
{
    "Name":"Ace",
    "Sex":"man",
    "Age":20,
    "Family":{
        "Father":"Gol·D·Roger",
        "Mother":"Portgas·D·Rouge",
        "Brother":["Sabo", "Monkey D. Luffy"]
    },
    "IsAlive":false,
    "Comment":"yyds"
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 写文件
void MainWindow::writeJson()
{
    //创建一个Json对象
    QJsonObject obj;//对象可以说是和map一模一样

    //"Ace"发生了隐式类型转换
    obj.insert("name","Ace");
    obj.insert("sex","man");
    obj.insert("age",20);

    //创建子对象
    QJsonObject subObj;
    subObj.insert("father","Gol·D·Roger");
    subObj.insert("Mother","Portgas·D·Rouge");


    //构建一个Json数组的对象
    QJsonArray array;
    array.append("Sabo");
    array.append("Monkey D. Luffy");
    subObj.insert("Brother",array);

    obj.insert("Family",subObj);

    obj.insert("IsAlive",false);

    obj.insert("Comment","yyds");


    //将json的对象转换成文档类型
    QJsonDocument doc(obj);

    //将其转换成字符串类型,QByteArray在qt中就是表示字符串
    QByteArray json = doc.toJson();

    //写入磁盘文件中
    QFile file("G:\\qtcodetest\\QJsonTest\\mytest.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
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 读文件
void MainWindow::readJson()
{
    //读文件
    QFile file("G:\\qtcodetest\\QJsonTest\\mytest.json");

    file.open(QFile::ReadOnly);

    QByteArray all = file.readAll();

    file.close();

    //读出的文件进行转换
    QJsonDocument doc = QJsonDocument::fromJson(all);

    if(doc.isObject())
    {
         QJsonObject obj = doc.object();
         QStringList keys = obj.keys();
         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();
             }
             if(value.isString())
             {
                 qDebug() << key << ":" << value.toString();
             }
             if(value.isDouble())
             {
                 qDebug() << key << ":" << value.toInt();
             }
             if(value.isObject())
             {
                 qDebug()<< key << ":";
                  // 直接处理内部键值对, 不再进行类型判断的演示
                 QJsonObject subObj = value.toObject();
                 QStringList ls = subObj.keys();
                 for(int i=0; i<ls.size(); ++i)
                 {
                     QJsonValue subVal = subObj.value(ls.at(i));
                     if(subVal.isString())
                     {
                          qDebug() << "   " << ls.at(i) << ":" << subVal.toString();
                      }
                     if(subVal.isArray())
                     {
                         QJsonArray array = subVal.toArray();
                         qDebug() << "   " << ls.at(i) << ":";
                         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
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/1016466
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号