一、准备工作

VS编译器创建项目时，勾选Core项

QT编译器需要在.pro文件中 QT += Core

操作Json文件所需要用到的类：

类	类说明
QJsonDocument	读写JSON文档
QJsonObject	封装JSON对象 { }
QJsonArray	封装JSON数组 [ ]
QJsonValue	封装JSON值 int，float，double，bool，{ }，[ ]等
QJsonParseError	报告JSON处理过程中出现的错误

操作Json文件所需要用到的头文件：
#include < QJsonObject > // { }
#include < QJsonArray > // [ ]
#include < QJsonDocument > // 解析Json
#include < QJsonValue > // int float double bool null { } [ ]
#include < QJsonParseError >

下图是这篇博客所操作的JSON文件：

二、封装Json

{ }

"interest": {
	"basketball": "篮球",
	"badminton": "羽毛球"

代码实现上述效果：

// 定义 { } 对象
QJsonObject interestObj;
// 插入元素，对应键值对
interestObj.insert("basketball", "篮球");
interestObj.insert("badminton", "羽毛球");

[ ]

"color": [ "black", "white"],

代码实现上述效果：

// 定义 [ ] 对象
QJsonArray colorArray;
// 往数组中添加元素
colorArray.append("black");
colorArray.append("white");

[ { } { } ]

"like": [
	{ "game": "三国杀", "price": 58.5 },
	{ "game": "海岛奇兵", "price": 66.65 }

代码实现上述效果：

// 定义 { } 对象
QJsonObject likeObject1;
likeObject1.insert("game", "三国杀");
likeObject1.insert("price", 58.5);
QJsonObject likeObject2;
likeObject2.insert("game", "海岛奇兵");
likeObject2.insert("price", 66.65);
// 定义 [ ] 对象
QJsonArray likeArray;
likeArray.append(likeObject1);
likeArray.append(likeObject2);

{ { } { } }

"languages": {
	"serialOne": { "language": "汉语", "grade": 10 },
	"serialTwo": { "language": "英语", "grade": 6 }

代码实现上述效果：

// 定义 { } 对象
QJsonObject language1;
language1.insert("language", "汉语");
language1.insert("grade", 10);
QJsonObject language2;
language2.insert("language", "英语");
language2.insert("grade", 6);
QJsonObject languages;
// 将{ } 插入 { } 中
languages.insert("serialOne", language1);
languages.insert("serialTwo", language2);

定义根节点也即是最外层 { }

// 定义根节点	也即是最外层 { }
QJsonObject rootObject;

将上面定义的{ } 与 [ ] 都插入到跟节点{ }中

// 插入元素
rootObject.insert("name", "老王");
rootObject.insert("age", 26);
rootObject.insert("interest", interestObj);
rootObject.insert("color", colorArray);
rootObject.insert("like", likeArray);
rootObject.insert("languages", languages);
rootObject.insert("vip", true);
rootObject.insert("address", QJsonValue::Null);

实例化QJsonDocument对象

// 将json对象里的数据转换为字符串
QJsonDocument doc;
// 将object设置为本文档的主要对象
doc.setObject(rootObject);

Json字符串保存到json文件里

QFile file("../Json/js.json");
if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
	qDebug() << "can't open error!";
	return;
QTextStream stream(&file);
stream.setCodec("UTF-8");		// 设置写入编码是UTF8
// 写入文件
stream << doc.toJson();
file.close();

这里需要注意的是，我们写入文件时，指定的编码是UTF8，所以在读取出来时也需要使用UTF8编码进行读取！

这是补充的内容：[ [ ], [ ] ]
这是2021年11月11日补充的内容。偶然间在csdn问答模块看到有人问这种 数组包含数组 的Json方式该如何实现，于是我点开自己这一篇博客一看，发现没有记录这种做法，于是乎今天将这种用法补充一下！

在这里创建好的json，下面也有对应的解析讲解！

那么，这种数组包含数组的效果该如何实现呢？

"color": [
    [ "black", "white" ],
    [ "red", "greed" ]

代码实现上述效果：

// 定义 [ ] 对象
QJsonArray colorArray;
// 定义 [ ] 对象
QJsonArray colorArray1;
// 往数组中添加元素
colorArray1.append("black");
colorArray1.append("white");
// 定义 [ ] 对象
QJsonArray colorArray2;
// 往数组中添加元素
colorArray2.append("red");
colorArray2.append("greed");
colorArray.append(colorArray1);
colorArray.append(colorArray2);
把代码写好后，编译运行，会在自己的项目路径中创建一个JSON文件，并写入内容，文件内容如下：
 
 顺序可能有点乱，但是不妨碍我们阅读与下面解析！ 
三、解析Json
 
解析根据上图进行！ 
在使用JSON对象或者JSON数组对象得到对应的value之后，该value值并不是最总的数据类型，而是一个QJsonValue类型的属性，我们必须通过该对象判断该类型的实际类型，然后在将其转换为对应的数据类型。
 可以使用下面表格的方法，也可以使用代码中的方法进行判断，
 类型判断相关成员方法： 
方法 解释
bool isArray() const 是否为json数组
bool isBool() const 是否为布尔类型
bool isDouble() const 是否为浮点类型
bool isNull() const 是否为空
bool isObject() const 是否为json对象
bool isString() const 是否为字符串类型
 打开文件，读取全部内容
 QFile file("../Json/js.json");
if (!file.open(QFile::ReadOnly | QFile::Text)) {
	qDebug() << "can't open error!";
	return;
// 读取文件的全部内容
QTextStream stream(&file);
stream.setCodec("UTF-8");		// 设置读取编码是UTF8
QString str = stream.readAll();
file.close();
 注意编码啊！
 
 将字符串解析成QJsonDocument对象
 // QJsonParseError类用于在JSON解析期间报告错误。
QJsonParseError jsonError;
// 将json解析为UTF-8编码的json文档，并从中创建一个QJsonDocument。
// 如果解析成功，返回QJsonDocument对象，否则返回null
QJsonDocument doc = QJsonDocument::fromJson(str.toUtf8(), &jsonError);
// 判断是否解析失败
if (jsonError.error != QJsonParseError::NoError && !doc.isNull()) {
	qDebug() << "Json格式错误！" << jsonError.error;
	return;
 
 获取根 { }
 QJsonObject rootObj = doc.object();
 
 根据键获取值
 // 根据键获取值
QJsonValue nameValue = rootObj.value("name");
qDebug() << "name = " << nameValue.toString();
QJsonValue ageValue = rootObj.value("age");
qDebug() << "age = " << ageValue.toInt();
// 解析 bool类型
QJsonValue vipValue = rootObj.value("vip");
qDebug() << "vip = " << vipValue.toBool();
// 解析 null类型
QJsonValue addressValue = rootObj.value("address");
if (addressValue.type() == QJsonValue::Null) {
	qDebug() << "address = " << "null";
 
 解析对象 { }
 也就是解析下图内容：
 
 解析代码：
 QJsonValue interestValue = rootObj.value("interest");
// 判断是否是object类型
if (interestValue.type() == QJsonValue::Object) {
	// 转换为QJsonObject类型
	QJsonObject interestObj = interestValue.toObject();
	QJsonValue basketballValue = interestObj.value("basketball");
	qDebug() << "basketball = " << basketballValue.toString();
	QJsonValue badmintonValue = interestObj.value("badminton");
	qDebug() << "badminton = " << badmintonValue.toString();
 通过value函数根据键获取到一个QJsonValue 类型数据，然后进行判断是否是对应类型，然后转换成对应类型，就可以使用value函数进行获取QJsonValue值，再转换类型就可以拿到数据了。
 
 解析数组 [ ]
 也就是解析下图内容：
 
 解析代码：
 QJsonValue colorValue = rootObj.value("color");
// 判断是否是Array类型
if (colorValue.type() == QJsonValue::Array) {
	// 转换为QJsonArray类型
	QJsonArray colorArray = colorValue.toArray();
	for (int i = 0; i < colorArray.size(); i++) {
		QJsonValue color = colorArray.at(i);
		qDebug() << "color = " << color.toString();
 
 解析数组中的对象 [ { } ]
 也就是解析下图内容：
 
 解析代码：
 // 根键获取值
QJsonValue likeValue = rootObj.value("like");
// 判断类型是否是数组类型
if (likeValue.type() == QJsonValue::Array) {
	// 转换成数组类型
	QJsonArray likeArray = likeValue.toArray();
	// 遍历数组




    

	for (int i = 0; i < likeArray.count(); i++) {
		// 获取数组的第一个元素，类型是QJsonValue 
		QJsonValue likeValueChild = likeArray.at(i);
		// 判断是不是对象类型
		if (likeValueChild.type() == QJsonValue::Object) {
			// 转换成对象类型
			QJsonObject likeObj = likeValueChild.toObject();
			// 最后通过value函数就可以获取到值了，解析成功！
			QJsonValue gameLikeValue = likeObj.value("game");
			qDebug() << "game = " << gameLikeValue.toString();
			QJsonValue priceLikeValue = likeObj.value("price");
			qDebug() << "price = " << priceLikeValue.toDouble();
  解析 对象 中 对象 { { } }
 也就是解析下图内容：
 
 解析代码：
 // 根据建获取值
QJsonValue languagesValue = rootObj.value("languages");
// 判断是不是对象类型
if (languagesValue.type() == QJsonValue::Object) {
	// 转换成对象类型
	QJsonObject languagesObj = languagesValue.toObject();
	// 根据建获取值
	QJsonValue serialOneValue = languagesObj.value("serialOne");
	// 判断是不是对象类型
	if (serialOneValue.type() == QJsonValue::Object) {
		// 转换成对象类型
		QJsonObject serialOneObj = serialOneValue.toObject();
		// 根据建获取值
		QJsonValue languageValue = serialOneObj.value("language");
		// 最后转换成对应类型就解析出来了！
		qDebug() << "language = " << languageValue.toString();
		QJsonValue gradeValue = serialOneObj.value("grade");
		qDebug() << "grade = " << gradeValue.toInt();
	QJsonValue serialTwoValue = languagesObj.value("serialTwo");
	if (serialTwoValue.type() == QJsonValue::Object) {
		QJsonObject serialTwoObj = serialTwoValue.toObject();
		QJsonValue languageValue = serialTwoObj.value("language");
		qDebug() << "language = " << languageValue.toString();
		QJsonValue gradeValue = serialTwoObj.value("grade");
		qDebug() << "grade = " << gradeValue.toInt();
解析运行结果如下：
  
 解析 数组 中 数组 [ [ ] [ ] ]
 对应上面补充内容的解析操作！
 也就是解析下图内容：
 
 解析代码：
 // 根键获取值
QJsonValue colorValue = rootObject.value("color");
// 判断类型是否是数组类型
if (colorValue.type() == QJsonValue::Array) {
	// 转换成数组类型
	QJsonArray colorArray = colorValue.toArray();
	// 遍历数组
	for (int i = 0; i < colorArray.count(); i++) {
		// 获取数组的第一个元素，类型是QJsonValue 
		QJsonValue colorValueChild = colorArray.at(i);
		// 判断是不是数组类型
		if (colorValueChild.type() == QJsonValue::Array) {
			// 转换成数组类型
			QJsonArray colorArr = colorValueChild.toArray();
			for (int i = 0; i < colorArr.size(); i++) {
				QJsonValue color = colorArr.at(i);
				qDebug() << "color = " << color.toString();
四、修改Json
 
修改的过程就是：将数据从文件中读取出来，解析成QJsonDocument对象后，在获取跟对象{ }，通过跟对象在获取其他的对象{}或者数组[]，修改后，再赋值给跟对象{}，达到替换效果，也就是修改了，最后再写入文件即可！ 
 读取数据解析成QJsonDocument代码省略，跟上面一样
 
 获取根节点对象
 // 获取根 { }
QJsonObject rootObj = doc.object();
 
 修改属性
 // 修改name属性
rootObj["name"] = "老李";
rootObj["vip"] = false;
 修改前：
 
 修改后：
 
 
 修改数组 [ ] 中的元素
 QJsonValue colorValue = rootObj.value("color");
if (colorValue.type() == QJsonValue::Array) {
	QJsonArray colorArray = colorValue.toArray();
	// 修改数组中的值
	colorArray.replace(0, "blue");
	colorArray.replace(1, "green");
	// 赋值覆盖原有数组属性
	rootObj[




    
"color"] = colorArray;
 修改前：
 
 修改后：
 
 
 修改 { } 中的值
 QJsonValue interestValue = rootObj.value("interest");
if (interestValue.type() == QJsonValue::Object) {
	QJsonObject interestObject = interestValue.toObject();
	interestObject["badminton"] = "乒乓球";
	interestObject["basketball"] = "足球";
	rootObj["interest"] = interestObject;
 修改前：
 
 修改后：
 
 
 修改 { { } } 中的值
 QJsonValue languagesValue = rootObj.value("languages");
if (languagesValue.type() == QJsonValue::Object) {
	QJsonObject languagesObj = languagesValue.toObject();
	// 找到内部第一个 { }
	QJsonValue serialOneValue = languagesObj.value("serialOne");
	if (serialOneValue.type() == QJsonValue::Object) {
		QJsonObject serialOneObj = serialOneValue.toObject();
		serialOneObj["grade"] = "20";
		languagesObj["serialOne"] = serialOneObj;
	// 找到内部第二个 { }
	QJsonValue serialTwoValue = languagesObj.value("serialTwo");
	if (serialTwoValue.type() == QJsonValue::Object) {
		QJsonObject serialTwoObj = serialTwoValue.toObject();
		serialTwoObj["grade"] = "10";
		serialTwoObj["language"] = "粤语";
		languagesObj["serialTwo"] = serialTwoObj;
	rootObj["languages"] = languagesObj;
 修改前：
 
 修改后：
 
 
 修改 [ { } ]
 QJsonValue likeValue = rootObj.value("like");
if (likeValue.type() == QJsonValue::Array) {
	QJsonArray likeArray = likeValue.toArray();
	// 根据索引获得对应{ }
	QJsonObject obj1 = likeArray[0].toObject();
	obj1["game"] = "欢乐斗地主";
	obj1["price"] = 88.8;
	QJsonObject obj2 = likeArray[1].toObject();
	obj2["game"] = "欢乐斗牛";
	obj2["price"] = 77.7;
	// 替换覆盖
	likeArray.replace(0, obj1);
	likeArray.replace(1, obj2);
	rootObj["like"] = likeArray;
 修改前：
 
 修改后：
 
  写入文件
 最后，再将跟节点对象{ }重新设置给QJsonDocument对象，在重新写入文件即可！
 // 将object设置为本文档的主要对象
doc.setObject(rootObj);
// 重写打开文件，覆盖原有文件，达到删除文件全部内容的效果
QFile writeFile("../Json/js.json");
if (!writeFile.open(QFile::WriteOnly | QFile::Truncate)) {
	qDebug() << "can't open error!";
	return;
// 将修改后的内容写入文件
QTextStream wirteStream(&writeFile);
wirteStream.setCodec("UTF-8");		// 设置读取编码是UTF8
wirteStream << doc.toJson();		// 写入文件
writeFile.close();					// 关闭文件
五、删除Json
 
删除跟修改类似的，使用跟节点对象找到对象{}或者数组[]后，使用remove函数指定键参数进行删除！ 
 读取数据解析成QJsonDocument代码省略，跟上面一样
 
 获取根节点对象
 // 获取根 { }
QJsonObject rootObj = doc.object();
 
 删除属性
 // 删除age
rootObj.remove("age");
 
 删除数组[]中的元素
 QJsonValue colorValue = rootObj.value("color");
if (colorValue.type() == QJsonValue::Array) {
	QJsonArray colorArray = colorValue.toArray();
	// 删除数组中索引为1的值
	colorArray.removeAt(1);
	// 赋值覆盖原有数组属性
	rootObj["color"] = colorArray;
 删除前：
 
 删除后：
 
 
 删除 { } 中的值
 QJsonValue interestValue = rootObj.value("interest");
if (interestValue.type()




    
 == QJsonValue::Object) {
	QJsonObject interestObject = interestValue.toObject();
	// 删除键为basketball的属性元素
	interestObject.remove("basketball");
	rootObj["interest"] = interestObject;
 删除前：
 
 删除后：
 
 
 删除 { { } } 中的值
 QJsonValue languagesValue = rootObj.value("languages");
if (languagesValue.type() == QJsonValue::Object) {
	QJsonObject languagesObj = languagesValue.toObject();
	// 删除键为serialTwo的对象 { }
	languagesObj.remove("serialTwo");
	rootObj["languages"] = languagesObj;
 删除前：
 
 删除后：
 
 
 删除 [ ] 中的 { }
 QJsonValue likeValue = rootObj.value("like");
if (likeValue.type() == QJsonValue::Array) {
	QJsonArray likeArray = likeValue.toArray();
	// 删除索引为1数组中的值
	likeArray.removeAt(1);
	rootObj["like"] = likeArray;
 删除前：
 
 删除后：
 
 
 删除 对象 { } 与 删除 数组 [ ]
 // 删除 [ ]
rootObj.remove("color");
// 删除 { }
rootObj.remove("interest");
 删除后就没有啦！
 
 写入文件
 最后，再将跟节点对象{ }重新设置给QJsonDocument对象，在重新写入文件即可！
 与上同，这里就不写下代码了！
  
六、全部代码
 
我这代码使用VS2017新建一个QT空项目写出来的！ 
指定编码
 #pragma execution_character_set(“utf-8”) // qt支持显示中文 
#include <QCoreApplication>
#include <QJsonObject>			// { }
#include <QJsonArray>			// [ ]
#include <QJsonDocument>		// 解析Json
#include <QJsonValue>			// int float double bool null { } [ ]
#include <QJsonParseError>
#include <QDebug>
#include <QFile>
#include <QTextStream>
#pragma execution_character_set("utf-8") // qt支持显示中文
// 封装Json
void createJson() {
	 *		"interest": {
	 *			"basketball": "篮球",
	 *			"badminton": "羽毛球"
	 *		 },
	// 定义 { } 对象
	QJsonObject interestObj;
	// 插入元素，对应键值对
	interestObj.insert("basketball", "篮球");
	interestObj.insert("badminton", "羽毛球");
	 *		"color": [ "black", "white"],
	// 定义 [ ] 数组
	QJsonArray colorArray;
	// 往数组中添加元素
	colorArray.append("black");
	colorArray.append("white");
	 *		"like": [
	 *			{ "game": "三国杀", "price": 58.5 },
	 *			{ "game": "海岛奇兵", "price": 66.65 }
	 *		],
	// 定义 { } 对象
	QJsonObject likeObject1;
	likeObject1.insert("game", "三国杀");
	likeObject1.insert("price", 58.5);
	QJsonObject likeObject2;
	likeObject2.insert("game", "海岛奇兵");
	likeObject2.insert("price", 66.65);
	// 定义 [ ] 对象
	QJsonArray likeArray;
	likeArray.append(likeObject1);
	likeArray.append(likeObject2);
	 *		"languages": {
	 *			"serialOne": { "language": "汉语", "grade": 10 },
	 *			"serialTwo": { "language": "英语", "grade": 6 }
	 *		},
	// 定义 { } 对象
	QJsonObject language1;
	language1.insert("language", "汉语");
	language1.insert("grade", 10);
	QJsonObject language2;
	language2.insert("language", "英语");
	language2.insert("grade", 6);
	QJsonObject languages;
	// 将{ } 插入 { } 中
	languages.insert("serialOne", language1);
	languages.insert("serialTwo", language2);
	// 定义根节点	也即是最外层 { }
	QJsonObject rootObject;
	// 插入元素
	rootObject.insert("name", "老王");
	rootObject.insert("age", 26);
	rootObject.insert("interest", interestObj);
	rootObject.insert("color", colorArray);
	rootObject.insert("like", likeArray);
	rootObject.insert("languages", languages);
	rootObject.insert("vip", true);
	rootObject.insert("address", QJsonValue::Null);
	// 将json对象里的数据转换为字符串
	QJsonDocument doc;
	// 将object设置为本文档的主要对象
	doc.setObject(rootObject);
	// Json字符串保存到json文件里
	QFile file("../Json/js.json");




    

	if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
		qDebug() << "can't open error!";
		return;
	QTextStream stream(&file);
	stream.setCodec("UTF-8");		// 设置写入编码是UTF8
	// 写入文件
	stream << doc.toJson();
	file.close();
// 解析Json
void analysisJson() {
	QFile file("../Json/js.json");
	if (!file.open(QFile::ReadOnly | QFile::Text)) {
		qDebug() << "can't open error!";
		return;
	// 读取文件的全部内容
	QTextStream stream(&file);
	stream.setCodec("UTF-8");		// 设置读取编码是UTF8
	QString str = stream.readAll();
	file.close();
	/* 解析Json */
	// QJsonParseError类用于在JSON解析期间报告错误。
	QJsonParseError jsonError;
	// 将json解析为UTF-8编码的json文档，并从中创建一个QJsonDocument。
	// 如果解析成功，返回QJsonDocument对象，否则返回null
	QJsonDocument doc = QJsonDocument::fromJson(str.toUtf8(), &jsonError);
	// 判断是否解析失败
	if (jsonError.error != QJsonParseError::NoError && !doc.isNull()) {
		qDebug() << "Json格式错误！" << jsonError.error;
		return;
	// 获取根 { }
	QJsonObject rootObj = doc.object();
	// 根据键获取值
	QJsonValue nameValue = rootObj.value("name");
	qDebug() << "name = " << nameValue.toString();
	QJsonValue ageValue = rootObj.value("age");
	qDebug() << "age = " << ageValue.toInt();
	// 解析对象 { }
	QJsonValue interestValue = rootObj.value("interest");
	// 判断是否是object类型
	if (interestValue.type() == QJsonValue::Object) {
		// 转换为QJsonObject类型
		QJsonObject interestObj = interestValue.toObject();
		QJsonValue basketballValue = interestObj.value("basketball");
		qDebug() << "basketball = " << basketballValue.toString();
		QJsonValue badmintonValue = interestObj.value("badminton");
		qDebug() << "badminton = " << badmintonValue.toString();
	// 解析数组 [ ]
	QJsonValue colorValue = rootObj.value("color");
	// 判断是否是Array类型
	if (colorValue.type() == QJsonValue::Array) {
		// 转换为QJsonArray类型
		QJsonArray colorArray = colorValue.toArray();
		for (int i = 0; i < colorArray.size(); i++) {
			QJsonValue color = colorArray.at(i);
			qDebug() << "color = " << color.toString();
	// 解析数组中的对象 [ { } ]
	QJsonValue likeValue = rootObj.value("like");
	if (likeValue.type() == QJsonValue::Array) {
		QJsonArray likeArray = likeValue.toArray();
		for (int i = 0; i < likeArray.count(); i++) {
			QJsonValue likeValueChild = likeArray.at(i);
			if (likeValueChild.type() == QJsonValue::Object) {
				QJsonObject likeObj = likeValueChild.toObject();
				QJsonValue gameLikeValue = likeObj.value("game");
				qDebug() << "game = " << gameLikeValue.toString();
				QJsonValue priceLikeValue = likeObj.value("price");
				qDebug() << "price = " << priceLikeValue.toDouble();
	// 解析 对象 中 对象 { { } }
	QJsonValue languagesValue = rootObj.value("languages");
	if (languagesValue.type() == QJsonValue::Object) {
		QJsonObject languagesObj = languagesValue.toObject();




    

		QJsonValue serialOneValue = languagesObj.value("serialOne");
		if (serialOneValue.type() == QJsonValue::Object) {
			QJsonObject serialOneObj = serialOneValue.toObject();
			QJsonValue languageValue = serialOneObj.value("language");
			qDebug() << "language = " << languageValue.toString();
			QJsonValue gradeValue = serialOneObj.value("grade");
			qDebug() << "grade = " << gradeValue.toInt();
		QJsonValue serialTwoValue = languagesObj.value("serialTwo");
		if (serialTwoValue.type() == QJsonValue::Object) {
			QJsonObject serialTwoObj = serialTwoValue.toObject();
			QJsonValue languageValue = serialTwoObj.value("language");
			qDebug() << "language = " << languageValue.toString();
			QJsonValue gradeValue = serialTwoObj.value("grade");
			qDebug() << "grade = " << gradeValue.toInt();
	// 解析 bool类型
	QJsonValue vipValue = rootObj.value("vip");
	qDebug() << "vip = " << vipValue.toBool();
	// 解析 null类型
	QJsonValue addressValue = rootObj.value("address");
	if (addressValue.type() == QJsonValue::Null) {
		qDebug() << "address = " << "null";
// 修改Json数据
void alterJson() {
	/* 修改也就再重写写一遍覆盖掉就行 */
	QFile readFile("../Json/js.json");
	if (!readFile.open(QFile::ReadOnly | QFile::Truncate)) {
		qDebug() << "can't open error!";
		return;
	// 读取文件的全部内容
	QTextStream readStream(&readFile);
	readStream.setCodec("UTF-8");		// 设置读取编码是UTF8
	QString str = readStream.readAll();
	readFile.close();
	/* 修改Json */
	// QJsonParseError类用于在JSON解析期间报告错误。
	QJsonParseError jsonError;
	// 将json解析为UTF-8编码的json文档，并从中创建一个QJsonDocument。
	// 如果解析成功，返回QJsonDocument对象，否则返回null
	QJsonDocument doc = QJsonDocument::fromJson(str.toUtf8(), &jsonError);
	if (jsonError.error != QJsonParseError::NoError && !doc.isNull()) {
		qDebug() << "Json格式错误！" << jsonError.error;
		return;
	// 获取根 { }
	QJsonObject rootObj = doc.object();
	// 修改name属性
	rootObj["name"] = "老李";
	rootObj["vip"] = false;
	// 修改数组[]中的元素
	QJsonValue colorValue = rootObj.value("color");
	if (colorValue.type() == QJsonValue::Array) {
		QJsonArray colorArray = colorValue.toArray();
		// 修改数组中的值
		colorArray.replace(0, "blue");
		colorArray.replace(1, "green");
		// 赋值覆盖原有数组属性
		rootObj["color"] = colorArray;
	// 修改 { } 中的值
	QJsonValue interestValue = rootObj.value("interest");
	if (interestValue.type() == QJsonValue::Object) {
		QJsonObject interestObject = interestValue.toObject();
		interestObject["badminton"] = "乒乓球";
		interestObject["basketball"] = "足球";
		rootObj["interest"] = interestObject;
	// 修改 { { } } 中的值
	QJsonValue languagesValue = rootObj.value("languages");
	if (languagesValue.type() == QJsonValue::Object) {
		QJsonObject languagesObj = languagesValue.toObject();
		// 找到内部第一个 { }
		QJsonValue serialOneValue = languagesObj.value("serialOne");
		if (serialOneValue.type() == QJsonValue::Object) {
			QJsonObject serialOneObj = serialOneValue.toObject();
			serialOneObj["grade"] = "20";
			languagesObj[




    
"serialOne"] = serialOneObj;
		// 找到内部第二个 { }
		QJsonValue serialTwoValue = languagesObj.value("serialTwo");
		if (serialTwoValue.type() == QJsonValue::Object) {
			QJsonObject serialTwoObj = serialTwoValue.toObject();
			serialTwoObj["grade"] = "10";
			serialTwoObj["language"] = "粤语";
			languagesObj["serialTwo"] = serialTwoObj;
		rootObj["languages"] = languagesObj;
	// 修改 [ { } ] 
	QJsonValue likeValue = rootObj.value("like");
	if (likeValue.type() == QJsonValue::Array) {
		QJsonArray likeArray = likeValue.toArray();
		// 根据索引获得对应{ }
		QJsonObject obj1 = likeArray[0].toObject();
		obj1["game"] = "欢乐斗地主";
		obj1["price"] = 88.8;
		QJsonObject obj2 = likeArray[1].toObject();
		obj2["game"] = "欢乐斗牛";
		obj2["price"] = 77.7;
		// 替换覆盖
		likeArray.replace(0, obj1);
		likeArray.replace(1, obj2);
		rootObj["like"] = likeArray;
	// 将object设置为本文档的主要对象
	doc.setObject(rootObj);
	// 重写打开文件，覆盖原有文件，达到删除文件全部内容的效果
	QFile writeFile("../Json/js.json");
	if (!writeFile.open(QFile::WriteOnly | QFile::Truncate)) {
		qDebug() << "can't open error!";
		return;
	// 将修改后的内容写入文件
	QTextStream wirteStream(&writeFile);
	wirteStream.setCodec("UTF-8");		// 设置读取编码是UTF8
	wirteStream << doc.toJson();		// 写入文件
	writeFile.close();					// 关闭文件
// 删除Json
void delJson() {
	QFile readFile("../Json/js.json");
	if (!readFile.open(QFile::ReadOnly | QFile::Truncate)) {
		qDebug() << "can't open error!";
		return;
	// 读取文件的全部内容
	QTextStream readStream(&readFile);
	readStream.setCodec("UTF-8");		// 设置读取编码是UTF8
	QString str = readStream.readAll();
	readFile.close();
	/* 修改Json */
	// QJsonParseError类用于在JSON解析期间报告错误。
	QJsonParseError jsonError;
	// 将json解析为UTF-8编码的json文档，并从中创建一个QJsonDocument。
	// 如果解析成功，返回QJsonDocument对象，否则返回null
	QJsonDocument doc = QJsonDocument::fromJson(str.toUtf8(), &jsonError);
	if (jsonError.error != QJsonParseError::NoError && !doc.isNull()) {
		qDebug() << "Json格式错误！" << jsonError.error;
		return;
	// 获取根 { }
	QJsonObject rootObj = doc.object();
	// 删除age
	rootObj.remove("age");
	// 删除数组[]中的元素
	QJsonValue colorValue = rootObj.value("color");
	if (colorValue.type() == QJsonValue::Array) {
		QJsonArray colorArray = colorValue.toArray();
		// 删除数组中索引为1的值
		colorArray.removeAt(1);
		// 赋值覆盖原有数组属性
		rootObj["color"] = colorArray;
	// 删除 { } 中的值
	QJsonValue interestValue = rootObj.value("interest");
	if (interestValue.type() == QJsonValue::Object) {
		QJsonObject interestObject = interestValue.toObject();
		// 删除键为basketball的属性元素
		interestObject.remove("basketball");
		rootObj["interest"] = interestObject;
	// 删除 { { } } 中的值
	QJsonValue languagesValue = rootObj.value("languages");
	if (languagesValue.type() == QJsonValue::Object) {
		QJsonObject languagesObj = languagesValue.toObject();
		// 删除键为serialTwo的对象 { }
		languagesObj.remove("serialTwo");
		rootObj["languages"] = languagesObj;
	// 删除 [ ] 中的 { }
	QJsonValue likeValue = rootObj.value("like");
	if (likeValue.type() == QJsonValue::Array) {
		QJsonArray likeArray = likeValue.toArray();
		// 删除索引为1数组中的值
		likeArray.removeAt(1);
		rootObj["like"] = likeArray;
	// 删除 [ ]
	rootObj.remove("color");
	// 删除 { }
	rootObj.remove("interest");
	// 将object设置为本文档的主要对象
	doc.setObject(rootObj);
	// 重写打开文件，覆盖原有文件，达到删除文件全部内容的效果
	QFile writeFile("../Json/js.json");
	if (!writeFile.open(QFile::WriteOnly | QFile::Truncate)) {
		qDebug() << "can't open error!";
		return;
	// 将修改后的内容写入文件
	QTextStream wirteStream(&writeFile);
	wirteStream.setCodec("UTF-8");		// 设置读取编码是UTF8
	wirteStream << doc.toJson();		// 写入文件
	writeFile.close();					// 关闭文件
int main(int argc, char *argv[]) {
	QCoreApplication a(argc, argv);
	createJson();
	analysisJson();
	alterJson();
	delJson();
	return a.exec();
可能讲的不是很清楚，很多细节没有详细的描述。但是该有的操作都已经用代码操作出来了，可以根据自己的项目需求进行截取观看理解，不懂的在评论区留言，我再帮你解答吧，我尽力了！ 
另外，真的，真的，真的需要注意编码统一的问题，我在写解析时，就是没有考虑到编码问题，导致我找中文乱码问题找了两天，最后还是请教网上的大佬才解决，太郁闷了！（记得写入文件是什么格式，读取出来就得是什么格式，还有，由于我在代码开头就指定了编码是UTF-8，所以我写入文件和读取文件，都是指定了UTF-8格式，这样才不会出现中文乱码的情况！）
3、Json数组
Json数组使用[]表示，[]里面是元素，元素间使用 , 分隔，最后一个元素后面，没有 ,
一个Json数组，支持多种不同的数据类型，包括:整形，浮点型，字符串，json数组，json对象，空值-null(null)
Json数组中嵌套Json数组，父子关系
Json数组嵌套Js
    QFile file("pin.json");
	if (!file.open(QIODevice::WriteOnly)) {
		qCritical() << "jsonFile open error";
	// 使用QJsonObject对象插入键值对。
	QJsonObject jsonObject;
	jsonObject.insert("AdminPin", "123456");
	jsonObject.insert("Us
    // 打开 JSON 文件
    QFile file("example.json");
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        qDebug() << "无法打开文件";
        return -1;
    // 读取 JSON 数据
    QByteArray data = file.readAll();
    QJsonDocument doc = QJsonDocument::fromJson(data);
    if (doc.isNull()) {
        qDebug() << "无法解析 JSON 数据";
        return -1;
    // 获取 JSON 对象
    QJsonObject obj = doc.object();
    // 输出 JSON 数据
    qDebug() << "name:" << obj["name"].toString();
    qDebug() << "age:" << obj["age"].toInt();
    return a.exec();
以上代码会读取名为 `example.json` 的 JSON 文件，并输出其中的 `name` 和 `age` 字段。如果 JSON 文件格式不正确，或者字段不存在，程序会输出相应的错误信息。
		QJsonDoucument
			它封装了一个完整的 JSON 文档，并且可以从 UTF-8 编码的基于文本的表示以及 Qt 自己的二进制格式读取和写入该文档。
		QJsonArray
			JSON 数组是一个值列表。可以通过从数组中插入和删除 QJsonValue 来操作该列表。
		QJsonObject
			JSON 对象是键值对的列表，其中键是唯一的字符串，值由 QJs
				文章目录一、概述二、Qt中的JSON类2.1、构建JSON2.1.1、构建JSON字符串2.1.2、构建JSON对象2.1.3、构建JSON数组2.1.4 构建复杂的JSON串2.2、解析JSON2.2.1、解析JSON对象2.2.2、解析JSON数组2.2.3、解析复杂的JSON串
从Qt5开始，官方就已经支持JSON格式的数据了，有关JSON的信息可以参考官网
JSON用于存储结构化的数据，存储的值有6种格式：
				1、Json是一种独立于语言的数据格式，通过对数据的序列化操作，可用于不同语言之间数据的交换，也可以通过写*.json格式的文件，用于数据的存储。
2、Json中主要有Json数组和Json对象两种数据类型，格式举例如下：
（1）Json数组：
// 整形
[1,2,3,4,5]
// 相同类型字符串
["zhangsan", "lisi", "wangwu", "zhoaliu", "huangqi"]
//不同类型字符串
[3.1415926, 88, true, false, "NiHao,J
				Qt框架中的JSON操作1 QJson库简介2 JSON 常用类3 简单的 JSON 对象
https://blog.csdn.net/penghejuan2012/article/details/82895492
https://blog.csdn.net/neochan1108/article/details/79590163
1 QJson库简介
在Qt库中，为JSON的相关操作提供了完整的类支持，包括QJsonValue，QJsonObject，QJsonArray，QJsonDocument和QJ
				Qt之JSON生成与解析
Qt5中包含了处理JSON的类，均以QJson开头（例如：QJsonDocument、QJsonArray、QJsonObject），在QtCore模块中，不需要额外引入其它模块。
常用的 JSON 库
json.org 中介绍了 JSON 在各种语言中的应用，在 C/C++ 中比较常用的JSON 库主要有以下几个：
JsonCpp
JsonCpp 是一个 C++ 用来处理 JSON 数据的开发包。
网址：http://jsoncpp.sourceforge.net/
				Qt支持处理JSON数据。JSON是一种对源自Javascript的对象数据进行编码的格式，但现在被广泛用作互联网上的数据交换格式。Qt中的JSON支持提供了一个易于使用的C++API来解析、修改和保存JSON数据。它还支持以二进制格式保存数据，这种格式可以直接“mmap”，并且访问速度非常快。JSON数据格式的更多详细信息可以在JSON中找到。
https://www.json.org/json-en.html和RFC-4627
中https://www.rfc-editor.org/rfc/rfc462

方法	解释
bool isArray() const	是否为json数组
bool isBool() const	是否为布尔类型
bool isDouble() const	是否为浮点类型
bool isNull() const	是否为空
bool isObject() const	是否为json对象
bool isString() const	是否为字符串类型