您的位置：360文档中心› WINDOW下QT如何解析JSON之JSONCPP完整讲解

WINDOW下QT如何解析JSON之JSONCPP完整讲解

合集下载

CC++Qt运用JSON解析库[解析篇]

CC++Qt运用JSON解析库[解析篇]

CC++Qt运⽤JSON解析库[解析篇]JSON是⼀种简单的轻量级数据交换格式，Qt库为JSON的相关操作提供了完整的类⽀持，使⽤JSON解析⽂件之前需要先通过TextStream流将⽂件读⼊到字符串变量内，然后再通过QJsonDocument等库对该JSON格式进⾏解析，以提取出我们所需字段。

⾸先创建⼀个解析⽂件,命名为config.json我们将通过代码依次解析这个JSON⽂件中的每⼀个参数,具体解析代码如下:{"blog": "https:///lyshark","enable": true,"status": 1024,"GetDict": {"address":"192.168.1.1","username":"root","password":"123456","update":"2020-09-26"},"GetList": [1,2,3,4,5,6,7,8,9,0],"ObjectInArrayJson":{"One": ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],"Two": ["Sunday","Monday","Tuesday"]},"ArrayJson": [["192.168.1.1","root","22"],["192.168.1.2","root","23"],["192.168.1.3","root","24"],["192.168.1.4","root","25"],["192.168.1.5","root","26"]],"ObjectJson": [{"address":"192.168.1.1","username":"admin"},{"address":"192.168.1.2","username":"root"},{"address":"192.168.1.3","username":"lyshark"}],"ObjectArrayJson": [{"uname":"root","ulist":[1,2,3,4,5]},{"uname":"lyshark","ulist":[11,22,33,44,55,66,77,88,99]}],"NestingObjectJson": [{"uuid": "1001","basic": {"lat": "12.657","lon": "55.789"}},{"uuid": "1002","basic": {"lat": "31.24","lon": "25.55"}}],"ArrayNestingArrayJson":[{"telephone": "1323344521","path": [[11.5,22.4,56.9],[19.4,34.6,44.7]]}]}⾸先实现读写⽂本⽂件,通过QT中封装的<QFile>库可实现对⽂本⽂件的读取操作,读取JSON⽂件可使⽤该⽅式.#include <QCoreApplication>#include <iostream>#include <QString>#include <QTextStream>#include <QFile>#include <QDir>#include <QFileInfo>#include <QJsonDocument>#include <QJsonParseError>#include <QJsonObject>#include <QJsonArray>#include <QJsonValue>#include <QJsonValueRef>// 传⼊⽂本路径,读取并输出// https:///lysharkint readonly_string_file(QString file_path){QFile this_file_ptr(file_path);// 判断⽂件是否存在if(false == this_file_ptr.exists()){std::cout << "⽂件不存在" << std::endl;return 0;}/** ⽂件打开属性包括如下* QIODevice::ReadOnly 只读⽅式打开* QIODevice::WriteOnly 写⼊⽅式打开* QIODevice::ReadWrite 读写⽅式打开* QIODevice::Append 追加⽅式打开* QIODevice::Truncate 截取⽅式打开* QIODevice::Text ⽂本⽅式打开*/if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text)){std::cout << "打开失败" << std::endl;return 0;}// 读取到⽂本中的字符串QString string_value = this_file_ptr.readAll();std::cout << "读⼊长度: " << this_file_ptr.size() << std::endl;std::cout << "字符串: " << string_value.toStdString() << std::endl;this_file_ptr.close();}// 逐⾏读取⽂本⽂件void read_line_file(){QFile this_file_ptr("d:/config.json");if(this_file_ptr.open((QIODevice::ReadOnly | QIODevice::Text))){QByteArray byte_array;while(false == this_file_ptr.atEnd()){byte_array += this_file_ptr.readLine();}std::cout << "完整⽂本: " << QString(byte_array).toStdString() << std::endl; this_file_ptr.close();}}// 传⼊⽂本路径与写⼊内容,写⼊到⽂件// https:///lysharkvoid write_string_file(QString file_path, QString string_value){QFile this_file_ptr(file_path);// 判断⽂件是否存在if(false == this_file_ptr.exists()){return;}// 打开失败if(false == this_file_ptr.open(QIODevice::ReadWrite | QIODevice::Text)){return;}//写⼊内容，注意需要转码，否则会报错QByteArray write_string = string_value.toUtf8();//写⼊QByteArray格式字符串this_file_ptr.write(write_string);this_file_ptr.close();}// 计算⽂件或⽬录⼤⼩unsigned int GetFileSize(QString path){QFileInfo info(path);unsigned int ret = 0;if(info.isFile()){ret = info.size();}else if(info.isDir()){QDir dir(path);QFileInfoList list = dir.entryInfoList();for(int i = 0; i < list.count(); i++){if((list[i].fileName() != ".") && (list[i].fileName() != "..")){ret += GetFileSize(list[i].absoluteFilePath());}}}return ret;}int main(int argc, char *argv[]){QCoreApplication a(argc, argv);// 读取⽂件readonly_string_file("d:/config.json");// 计算⽂件或⽬录⼤⼩unsigned int file_size = GetFileSize("d:/xunjian");std::cout << "获取⽂件或⽬录⼤⼩: " << file_size << std::endl;// 覆盖写⼊⽂件QString write_file_path = "d:/test.json";QString write_string = "hello lyshark";write_string_file(write_file_path,write_string);return a.exec();}实现解析根对象中的单⼀的键值对,例如解析配置⽂件中的blog,enable,status等这些独⽴的字段值. // 读取JSON⽂本// https:///lysharkQString readonly_string(QString file_path){QFile this_file_ptr(file_path);if(false == this_file_ptr.exists()){return "None";}if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text)){return "None";}QString string_value = this_file_ptr.readAll();this_file_ptr.close();return string_value;}int main(int argc, char *argv[]){QCoreApplication a(argc, argv);// 读取⽂件QString config = readonly_string("d:/config.json");if(config == "None"){return 0;}// 字符串格式化为JSONQJsonParseError err_rpt;QJsonDocument root_document = QJsonDocument::fromJson(config.toUtf8(), &err_rpt);if(err_rpt.error != QJsonParseError::NoError){std::cout << "JSON格式错误" << std::endl;return 0;}// 获取到Json字符串的根节点QJsonObject root_object = root_document.object();// 解析blog字段QString blog = root_object.find("blog").value().toString();std::cout << "字段对应的值 = > "<< blog.toStdString() << std::endl;// 解析enable字段bool enable = root_object.find("enable").value().toBool();std::cout << "是否开启状态: " << enable << std::endl;// 解析status字段int status = root_object.find("status").value().toInt();std::cout << "状态数值: " << status << std::endl;return a.exec();}实现解析简单的单对象与单数组结构,如上配置⽂件中的GetDict与GetList既是我们需要解析的内容.// 读取JSON⽂本QString readonly_string(QString file_path){QFile this_file_ptr(file_path);if(false == this_file_ptr.exists()){return "None";}if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text)){return "None";}QString string_value = this_file_ptr.readAll();this_file_ptr.close();return string_value;}// https:///lysharkint main(int argc, char *argv[]){QCoreApplication a(argc, argv);// 读取⽂件QString config = readonly_string("d:/config.json");if(config == "None"){return 0;}// 字符串格式化为JSONQJsonParseError err_rpt;QJsonDocument root_document = QJsonDocument::fromJson(config.toUtf8(), &err_rpt);if(err_rpt.error != QJsonParseError::NoError){std::cout << "JSON格式错误" << std::endl;return 0;}// 获取到Json字符串的根节点QJsonObject root_object = root_document.object();// 解析单⼀对象QJsonObject get_dict_ptr = root_object.find("GetDict").value().toObject();QVariantMap map = get_dict_ptr.toVariantMap();if(map.contains("address") && map.contains("username") && map.contains("password") && map.contains("update")) {QString address = map["address"].toString();QString username = map["username"].toString();QString password = map["password"].toString();QString update = map["update"].toString();std::cout<< " 地址: " << address.toStdString()<< " ⽤户名: " << username.toStdString()<< " 密码: " << password.toStdString()<< " 更新⽇期: " << update.toStdString()<< std::endl;// 解析单⼀数组QJsonArray get_list_ptr = root_object.find("GetList").value().toArray();for(int index=0; index < get_list_ptr.count(); index++){int ref_value = get_list_ptr.at(index).toInt();std::cout << "输出数组元素: " << ref_value << std::endl;}return a.exec();}实现解析对象嵌套对象且对象中嵌套数组结构,如上配置⽂件中的ObjectInArrayJson既是我们需要解析的内容. // 读取JSON⽂本// https:///lysharkQString readonly_string(QString file_path){QFile this_file_ptr(file_path);if(false == this_file_ptr.exists()){return "None";}if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text)){return "None";}QString string_value = this_file_ptr.readAll();this_file_ptr.close();return string_value;}int main(int argc, char *argv[]){QCoreApplication a(argc, argv);// 读取⽂件QString config = readonly_string("d:/config.json");if(config == "None"){return 0;}// 字符串格式化为JSONQJsonParseError err_rpt;QJsonDocument root_document = QJsonDocument::fromJson(config.toUtf8(), &err_rpt);if(err_rpt.error != QJsonParseError::NoError){std::cout << "JSON格式错误" << std::endl;return 0;}// 获取到Json字符串的根节点QJsonObject root_object = root_document.object();// 找到Object对象QJsonObject one_object_json = root_object.find("ObjectInArrayJson").value().toObject();// 转为MAP映射QVariantMap map = one_object_json.toVariantMap();// 寻找One键QJsonArray array_one = map["One"].toJsonArray();for(int index=0; index < array_one.count(); index++){QString value = array_one.at(index).toString();std::cout << "One => "<< value.toStdString() << std::endl;}// 寻找Two键QJsonArray array_two = map["Two"].toJsonArray();for(int index=0; index < array_two.count(); index++){QString value = array_two.at(index).toString();std::cout << "Two => "<< value.toStdString() << std::endl;}return a.exec();实现解析数组中的数组结构,如上配置⽂件中的ArrayJson既是我们需要解析的内容.// 读取JSON⽂本QString readonly_string(QString file_path){QFile this_file_ptr(file_path);if(false == this_file_ptr.exists()){return "None";}if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text)){return "None";}QString string_value = this_file_ptr.readAll();this_file_ptr.close();return string_value;}// https:///lysharkint main(int argc, char *argv[]){QCoreApplication a(argc, argv);// 读取⽂件QString config = readonly_string("d:/config.json");if(config == "None"){return 0;}// 字符串格式化为JSONQJsonParseError err_rpt;QJsonDocument root_document = QJsonDocument::fromJson(config.toUtf8(), &err_rpt);if(err_rpt.error != QJsonParseError::NoError){std::cout << "json 格式错误" << std::endl;return 0;}// 获取到Json字符串的根节点QJsonObject root_object = root_document.object();// 获取MyJson数组QJsonValue array_value = root_object.value("ArrayJson");// 验证节点是否为数组if(array_value.isArray()){// 得到数组个数int array_count = array_value.toArray().count();// 循环数组个数for(int index=0;index <= array_count;index++){QJsonValue parset = array_value.toArray().at((index));if(parset.isArray()){QString address = parset.toArray().at(0).toString();QString username = parset.toArray().at(1).toString();QString userport = parset.toArray().at(2).toString();std::cout<< "地址: " << address.toStdString()<< " ⽤户名: " << username.toStdString()<< " 端⼝号: " << userport.toStdString()<< std::endl;}}}return a.exec();}实现解析数组中的多对象结构,如上配置⽂件中的ObjectJson既是我们需要解析的内容. // 读取JSON⽂本// https:///lysharkQString readonly_string(QString file_path){QFile this_file_ptr(file_path);if(false == this_file_ptr.exists()){return "None";}if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text)){return "None";}QString string_value = this_file_ptr.readAll();this_file_ptr.close();return string_value;}int main(int argc, char *argv[]){QCoreApplication a(argc, argv);// 读取⽂件QString config = readonly_string("d:/config.json");if(config == "None"){return 0;}// 字符串格式化为JSONQJsonParseError err_rpt;QJsonDocument root_document = QJsonDocument::fromJson(config.toUtf8(), &err_rpt);if(err_rpt.error != QJsonParseError::NoError){std::cout << "json 格式错误" << std::endl;return 0;}// 获取到Json字符串的根节点QJsonObject root_object = root_document.object();// 获取MyJson数组QJsonValue object_value = root_object.value("ObjectJson");// 验证是否为数组if(object_value.isArray()){// 获取对象个数int object_count = object_value.toArray().count();// 循环个数for(int index=0;index <= object_count;index++){QJsonObject obj = object_value.toArray().at(index).toObject();// 验证数组不为空if(!obj.isEmpty()){QString address = obj.value("address").toString();QString username = obj.value("username").toString();std::cout << "地址: " << address.toStdString() << " ⽤户: " << username.toStdString() << std::endl; }}}return a.exec();}实现解析数组中对象中的嵌套数组结构,如上配置⽂件中的ObjectArrayJson既是我们需要解析的内容. // 读取JSON⽂本// https:///lysharkQString readonly_string(QString file_path){QFile this_file_ptr(file_path);if(false == this_file_ptr.exists()){return "None";}if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text)){return "None";}QString string_value = this_file_ptr.readAll();this_file_ptr.close();return string_value;}int main(int argc, char *argv[]){QCoreApplication a(argc, argv);// 读取⽂件QString config = readonly_string("d:/config.json");if(config == "None"){return 0;}// 字符串格式化为JSON// https:///lysharkQJsonParseError err_rpt;QJsonDocument root_document = QJsonDocument::fromJson(config.toUtf8(), &err_rpt);if(err_rpt.error != QJsonParseError::NoError){std::cout << "json 格式错误" << std::endl;return 0;}// 获取到Json字符串的根节点QJsonObject root_object = root_document.object();// 获取MyJson数组QJsonValue object_value = root_object.value("ObjectArrayJson");// 验证是否为数组if(object_value.isArray()){// 获取对象个数int object_count = object_value.toArray().count();// 循环个数for(int index=0;index <= object_count;index++){QJsonObject obj = object_value.toArray().at(index).toObject();// 验证数组不为空if(!obj.isEmpty()){QString uname = obj.value("uname").toString();std::cout << "⽤户名: " << uname.toStdString() << std::endl;// 解析该⽤户的数组int array_count = obj.value("ulist").toArray().count();std::cout << "数组个数: "<< array_count << std::endl;for(int index=0;index < array_count;index++){QJsonValue parset = obj.value("ulist").toArray().at(index);int val = parset.toInt();std::cout << "Value = > "<< val << std::endl;}}}}return a.exec();}实现解析数组嵌套匿名对象嵌套对象结构,如上配置⽂件中的NestingObjectJson既是我们需要解析的内容. // 读取JSON⽂本QString readonly_string(QString file_path){QFile this_file_ptr(file_path);if(false == this_file_ptr.exists()){return "None";}if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text)){return "None";}QString string_value = this_file_ptr.readAll();this_file_ptr.close();return string_value;}int main(int argc, char *argv[]){QCoreApplication a(argc, argv);// 读取⽂件// https:///lysharkQString config = readonly_string("d:/config.json");if(config == "None"){return 0;}// 字符串格式化为JSONQJsonParseError err_rpt;QJsonDocument root_document = QJsonDocument::fromJson(config.toUtf8(), &err_rpt);if(err_rpt.error != QJsonParseError::NoError){std::cout << "json 格式错误" << std::endl;return 0;}// 获取到Json字符串的根节点QJsonObject root_object = root_document.object();// 获取NestingObjectJson数组QJsonValue array_value = root_object.value("NestingObjectJson");// 验证节点是否为数组if(array_value.isArray()){// 得到内部对象个数int count = array_value.toArray().count();std::cout << "对象个数: " << count << std::endl;for(int index=0; index < count; index++){// 得到数组中的index下标中的对象QJsonObject array_object = array_value.toArray().at(index).toObject();// 开始解析basic中的数据QJsonObject basic = array_object.value("basic").toObject();QString lat = basic.value("lat").toString();QString lon = basic.value("lon").toString();std::cout << "解析basic中的lat字段: " << lat.toStdString() << std::endl;std::cout << "解析basic中的lon字段: " << lon.toStdString()<< std::endl;// 解析单独字段QString status = array_object.value("status").toString();std::cout << "解析字段状态: " << status.toStdString() << std::endl;}}return a.exec();}实现解析数组嵌套对象且对象内嵌套双层数组结构,如上配置⽂件中的ArrayNestingArrayJson既我们需要解析的内容. // 读取JSON⽂本QString readonly_string(QString file_path){QFile this_file_ptr(file_path);if(false == this_file_ptr.exists()){return "None";}if(false == this_file_ptr.open(QIODevice::ReadOnly | QIODevice::Text)){return "None";}QString string_value = this_file_ptr.readAll();this_file_ptr.close();return string_value;}int main(int argc, char *argv[]){QCoreApplication a(argc, argv);// 读取⽂件// https:///lysharkQString config = readonly_string("d:/config.json");if(config == "None"){return 0;}// 字符串格式化为JSONQJsonParseError err_rpt;QJsonDocument root_document = QJsonDocument::fromJson(config.toUtf8(), &err_rpt); if(err_rpt.error != QJsonParseError::NoError){std::cout << "json 格式错误" << std::endl;return 0;}// 获取到Json字符串的根节点QJsonObject root_object = root_document.object();// 获取NestingObjectJson数组QJsonValue array_value = root_object.value("ArrayNestingArrayJson");// 验证节点是否为数组if(array_value.isArray()){// 得到数组中的0号下标中的对象QJsonObject array_object = array_value.toArray().at(0).toObject();// 解析⼿机号字符串QString telephone = array_object.value("telephone").toString();std::cout << "⼿机号: " << telephone.toStdString() << std::endl;// 定位外层数组QJsonArray root_array = array_object.find("path").value().toArray();std::cout << "外层循环计数: " << root_array.count() << std::endl;for(int index=0; index < root_array.count(); index++){// 定位内层数组QJsonArray sub_array = root_array.at(index).toArray();std::cout << "内层循环计数: "<< sub_array.count() << std::endl;for(int sub_count=0; sub_count < sub_array.count(); sub_count++){// 每次取出最⾥层数组元素float var = sub_array.toVariantList().at(sub_count).toFloat();std::cout << "输出元素: " << var << std::endl;// std::cout << sub_array.toVariantList().at(0).toFloat() << std::endl;}}}return a.exec();}。

JSON数据的详细解析方法

JSON数据的详细解析方法

JSON数据的详细解析方法JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，常用于Web应用程序之间的数据传输。

它由键值对组成，可以包含对象、数组、数字、字符串、布尔值和null。

下面将详细解析JSON数据的方法。

1.JSON基本结构：2.解析JSON数据的方法：（1）使用各种编程语言的内置函数：大多数编程语言都提供了内置函数来解析JSON数据。

例如，在JavaScript中，可以使用JSON.parse(方法将JSON字符串转换为JavaScript对象。

在Python中，可以使用json模块中的json.loads(函数将JSON字符串转换为Python字典或列表。

（2）手动解析：如果没有内置函数可用或想要更深入了解JSON数据的结构，可以手动解析JSON数据。

- 首先，将JSON字符串转换为支持键值对结构的数据类型，如字典（Python）或对象（JavaScript）。

-然后，通过键名或属性访问特定的值，或者通过遍历数组访问元素。

3.对象的解析：JSON对象由键值对组成，可以通过键名访问对应的值。

例如，假设有以下JSON对象："age": 30,"city": "New York"可以通过以下方式解析该对象：（1）使用内置函数：通过JSON.parse(方法（JavaScript）或json.loads(函数（Python）将JSON字符串转换为对象，然后通过对象的属性访问值。

（2）手动解析：将JSON字符串转换为支持键值对的数据类型，如字典（Python）或对象（JavaScript），然后通过键名访问值。

4.数组的解析：例如，假设有以下JSON数组：[ "apple", "banana", "orange" ]可以通过以下方式解析该数组：（1）使用内置函数：通过JSON.parse(方法（JavaScript）或json.loads(函数（Python）将JSON字符串转换为数组，然后通过索引访问特定元素。

Qt--解析Json

Qt--解析Json

Qt--解析Json⼀、QT5 Json简介QT4中使⽤第三⽅库QJson解析JSON⽂件。

QT5新增加了处理JSON的类，类均以QJson开头，包含在QtCore模块中。

QT5新增加六个相关类：QJsonArray封装 JSON 数组QJsonDocument读写 JSON ⽂档QJsonObject封装 JSON 对象QJsonObject::iterator⽤于遍历QJsonObject的STL风格的⾮const遍历器QJsonParseError报告 JSON 处理过程中出现的错误QJsonValue封装 JSON 值⼆、QJsonDocument1、QJsonDocument简介QJsonDocument提供了读写Json⽂档的⽅法。

QJsonDocument是⼀个包含了完整JSON⽂档的类，⽀持以UTF-8编码的⽂本和QT⾃⾝的⼆进制格式来读写JSON⽂档。

JSON⽂档可以使⽤QJsonDocument::fromJson()将基于JSON⽂档的⽂本形式转换为QJsonDocument对象，toJSON()可以将QJsonDocument转换回⽂本形式。

解析⽂档的有效性可以使⽤!isNull()进⾏查询。

使⽤isArray()和isObject()可以分别查询⼀个⽂档是否包含了⼀个数组或⼀个object。

使⽤array()或object()可以将包含在⽂档中的数组或object提取出来。

使⽤fromBinaryData()或fromRawData()也可以从⼀个⼆进制形式创建⼀个QJsonDocument对象。

2、QJsonDocument成员函数[static] QJsonDocument QJsonDocument::fromBinaryData(const QByteArray &data, DataValidation validation = Validate)Validation决定数据是否在使⽤前检查数据有效性。

Qt工作笔记-发送端发送Json格式的数据包，接收端解析数据包

Qt工作笔记-发送端发送Json格式的数据包，接收端解析数据包

Qt⼯作笔记-发送端发送Json格式的数据包，接收端解析数据包原理以及运⾏原理是因为QJsonDocument提供了⼀个函数toJson可以直接把Json数据转成QByteArray，这样就可以直接发送数据包，然后再按照常规⽅法解析即可，本源码中含解析内容，详细的解析过程在如下的连接中！Qt⼯作笔记-Qt5 利⽤QJson从⽂件读取Json并解析发送了json数据，⽤串⼝调试⼯具运⾏截图如下：本例⼦运⾏动态图如下：源码发送端结构如下：发送端源码如下：widget.h#ifndef WIDGET_H#define WIDGET_H#include <QWidget>QT_BEGIN_NAMESPACEclass QUdpSocket;QT_END_NAMESPACEnamespace Ui {class Widget;}class Widget : public QWidget{Q_OBJECTpublic:explicit Widget(QWidget *parent = 0); ~Widget();protected slots:void sendMsgToLocal();private:Ui::Widget *ui;QUdpSocket *m_udpSocket;};#endif // WIDGET_Hmain.cpp#include "widget.h"#include <QApplication>int main(int argc, char *argv[]){QApplication a(argc, argv);Widget w;w.show();return a.exec();}widget.cpp#include "widget.h"#include "ui_widget.h"#include <QUdpSocket>#include <QMessageBox>#include <QHostAddress>#include <QDebug>#include <stdlib.h>#include <QJsonObject>#include <QJsonDocument>Widget::Widget(QWidget *parent) :QWidget(parent),ui(new Ui::Widget){ui->setupUi(this);this->setWindowTitle("Sender");m_udpSocket = new QUdpSocket(this);connect(ui->sendPushButton, SIGNAL(clicked(bool)), this, SLOT(sendMsgToLocal())); }Widget::~Widget(){delete ui;}void Widget::sendMsgToLocal(){//make a Json dataQJsonObject jsonObject;jsonObject.insert("Name", "xiaoming");jsonObject.insert("age", 18);QJsonDocument jsonDocument;jsonDocument.setObject(jsonObject);QByteArray dataArray = jsonDocument.toJson();if(m_udpSocket->writeDatagram(dataArray ,QHostAddress("127.0.0.1"), 7755) == -1){qDebug() << "send UDP data package failed!";}}接收端⽬录结构如下：接收端源码如下：widget.h#ifndef WIDGET_H#define WIDGET_H#include <QWidget>#include <QByteArray>QT_BEGIN_NAMESPACEclass QUdpSocket;QT_END_NAMESPACEnamespace Ui {class Widget;}class Widget : public QWidget{Q_OBJECTpublic:explicit Widget(QWidget *parent = 0);~Widget();protected:void analysisByteArray(QByteArray data);protected slots:void readPendingData();private:Ui::Widget *ui;QUdpSocket *m_udpSocket;};#endif // WIDGET_Hmain.cpp#include "widget.h"#include <QApplication>int main(int argc, char *argv[]){QApplication a(argc, argv);Widget w;w.show();return a.exec();}widget.cpp#include "widget.h"#include "ui_widget.h"#include <QUdpSocket>#include <QMessageBox>#include <QHostAddress>#include <QDebug>#include <stdlib.h>#include <QJsonObject>#include <QNetworkDatagram>#include <QJsonDocument>#include <QJsonParseError>#include <QJsonParseError>Widget::Widget(QWidget *parent) :QWidget(parent),ui(new Ui::Widget){ui->setupUi(this);this->setWindowTitle("Receiver");m_udpSocket = new QUdpSocket(this);if(!m_udpSocket->bind(7755)){QMessageBox::information(this, "tip", "bind port failed!");return;}connect(m_udpSocket, SIGNAL(readyRead()), this, SLOT(readPendingData()));}Widget::~Widget(){delete ui;}void Widget::analysisByteArray(QByteArray data){QJsonParseError json_error;QJsonDocument jsonDoc(QJsonDocument::fromJson(data, &json_error));if(json_error.error != QJsonParseError::NoError){qDebug() << "json error!";return;}QJsonObject rootObj = jsonDoc.object();QStringList keys = rootObj.keys();for(int i = 0; i < keys.size(); i++){if(i == 0)qDebug() << "key" << i << " is:" << keys.at(i) << rootObj.value(keys.at(i)).toString(); elseqDebug() << "key" << i << " is:" << keys.at(i) << rootObj.value(keys.at(i)).toInt();}}void Widget::readPendingData(){while(m_udpSocket->hasPendingDatagrams()){QNetworkDatagram datagram = m_udpSocket->receiveDatagram();analysisByteArray(datagram.data());}}。

qt5解析json

qt5解析json

qt5解析json1、将对应的字符串生成QJsonDocument对象。

2、判断QJsonDocument对象是QJsonObject还是QJsonArray类型。

3、如果是QJsonObject类型，获取一个QJsonObject对象，然后根据QJsonObject的api函数进行解析。

4、如果是QJsonArray类型，获取一个QJsonArray对象，然后根据QJsonArray的api函数进行解析。

5、从以上步骤获取对象后取得QJsonValue类型的数据。

6、迭代分解数据获取各个值。

例子：#include <QtCore/QCoreApplication>#include <QtDebug>#include <QString>#include <QJsonDocument>#include <QJsonArray>#include <QJsonValue>#include <QJsonParseError>#include <QJsonObject>#include <QStringList>int main(int argc, char *argv[]){QCoreApplication a(argc, argv);QString jsonStr = "{\"name\":\"mxq\",\"number\":1,\"array\":[23,\"asdf\",true]}";qDebug()<<"test json!";QJsonParseError jsonErr;QJsonDocument myjsonDoc1 = QJsonDocument::fromJson(jsonStr.toLatin1(),&jsonErr);if (jsonErr.error == QJsonParseError::NoError){if (myjsonDoc1.isEmpty()){qDebug()<<"the json is empty!";}if (myjsonDoc1.isObject()){qDebug()<<"json is object";QJsonObject jobj = myjsonDoc1.object();QStringList jsonkeylist = jobj.keys();qDebug()<<"jsonkeylist="<<jsonkeylist.count();for (int i=0;i<jsonkeylist.count();i++){qDebug()<<jsonkeylist.at(i)<<"\n";}QJsonObject::iterator it = jobj.begin();while(it != jobj.end()){switch (it.value().type()){case QJsonValue::String:qDebug()<<"type is String!";qDebug()<<it.key()<<"="<<it.value().toString();break;case QJsonValue::Array:{qDebug()<<"type is array!";qDebug()<<it.key()<<"="<<it.value().toArray();QJsonArray subarray = it.value().toArray();qDebug()<<"subarray count = "<<subarray.count();qDebug()<<"index 1 ="<<subarray.at(0).toDouble();qDebug()<<"index 2 ="<<subarray.at(1).toString();qDebug()<<"index 3 ="<<subarray.at(2).toBool();break;}case QJsonValue::Bool:qDebug()<<"type is bool!";qDebug()<<it.key()<<"="<<it.value().toBool(); break;case QJsonValue::Double:qDebug()<<"type is Double!";qDebug()<<it.key()<<"="<<it.value().toDouble(); break;case QJsonValue::Object:qDebug()<<"type is Object!";qDebug()<<it.key()<<"="<<it.value().toObject(); break;case QJsonValue::Null:qDebug()<<"type is null!";qDebug()<<it.key()<<"=null";break;case QJsonValue::Undefined:qDebug()<<"type is Undefined!";break;}it++;}}}return a.exec();}以上为本人的一个测试程序，main.c的内容。

jsonp语法-定义说明解析

jsonp语法-定义说明解析

jsonp语法-概述说明以及解释1. 引言1.1 概述JSONP（JSON with Padding）是一种用于在不同域之间进行数据传输的技术。

由于浏览器的同源策略限制，JavaScript不能直接访问不同域的数据。

JSONP通过动态创建<script>标签，将数据以函数参数的形式返回给客户端，从而绕过了浏览器的安全限制。

在Web开发中，数据的跨域传输是一个常见的问题。

传统的Ajax请求由于同源策略的限制而无法直接访问不同域的数据，这就给开发者带来了不便。

JSONP的出现很好地解决了这个问题。

JSONP的语法相对简单明了，只需要在请求的URL中添加一个回调函数的参数即可。

服务器接收到请求后，将请求的数据包装在回调函数中返回给客户端。

客户端收到响应后，会自动执行这个回调函数，并将数据作为参数传入。

JSONP在跨域数据传输方面具有一些优点。

首先，它兼容性较好，几乎所有的浏览器都支持JSONP。

其次，JSONP的实现相对简单，只需一行代码即可完成跨域请求。

此外，JSONP还可以通过缓存机制提高数据的传输效率。

尽管JSONP有着诸多优点，但也有一些限制和注意事项需要开发者注意。

首先，由于JSONP是通过动态创建<script>标签实现的，所以请求的数据必须是合法的JavaScript代码。

其次，JSONP只支持GET请求，无法发送POST请求。

最后，由于JSONP是将数据作为函数参数返回，所以仍有被恶意注入脚本的风险。

总的来说，JSONP是一种简单、有效的跨域传输数据的技术。

在合适的场景下，使用JSONP可以为我们解决跨域数据访问的问题，提高开发效率和用户体验。

然而，在使用JSONP时，我们也需要注意数据安全和合法性的问题，以免造成安全漏洞。

1.2 文章结构文章结构部分的内容可以包括以下几个方面：1. 文章主题和论点：在文章结构部分，可以简要介绍文章的主题和论点，即主要讨论的内容和观点。

Qt使用QJson生成解析json数据的方法

Qt使用QJson生成解析json数据的方法

Qt使⽤QJson⽣成解析json数据的⽅法 QT中使⽤json还是⽐较⽅便的，下⾯⽤例⼦直接说明之后根据这个格式进⾏json数据解析。

QT使⽤json需要包含的头⽂件1 #include<qjsondocument.h>2 #include<qjsonarray.h>3 #include<qjsonobject.h>4 #include<qjsonvalue.h>先看⼀段简单的⽣成QJSON数据的⽅法吧：1//简单的QTJson数据2 QJsonObject simp_ayjson;3 simp_ayjson.insert("name", "LLH");4 simp_ayjson.insert("age", 20);5 simp_ayjson.insert("myAccounts", QString::fromLocal8Bit("123你好"));6 QJsonDocument document;7 document.setObject(simp_ayjson);8 QByteArray simpbyte_array = document.toJson(QJsonDocument::Compact);9 QString simpjson_str(simpbyte_array);10 qDebug() << QString::fromLocal8Bit("简单的QTJson数据：") << simpjson_str;输出结果："简单的QTJson数据：""{\"age\":20,\"myAccounts\":\"123你好\",\"name\":\"LLH\"}"解析⽅法是：1//简单的QT解析JSON2 QJsonParseError simp_json_error;3 QString name, myAccount;4int age;5//QTJSON所有的元素6 QJsonDocument simp_parse_doucment = QJsonDocument::fromJson(simpjson_str.toUtf8(), &simp_json_error); 7//检查json是否有错误8if (simp_json_error.error == QJsonParseError::NoError)9 {10if (simp_parse_doucment.isObject())11 {12//开始解析json对象13 QJsonObject obj = simp_parse_doucment.object();14//如果包含name15if (obj.contains("name"))16 {17//的到name18 QJsonValue name_value = obj.take("name");19if (name_value.isString())20 {21//转换name22 name = name_value.toVariant().toString();23 }24 }25if (obj.contains("myAccounts"))26 {27 QJsonValue myAccount_value = obj.take("myAccounts");28if (myAccount_value.isString())29 {30 myAccount = myAccount_value.toString();31 }32 }33if (obj.contains("age"))34 {35 QJsonValue age_value = obj.take("age");36if (age_value.isDouble())37 {38 age = age_value.toVariant().toInt();39 }40 }41 }42 }43 qDebug() << QString::fromLocal8Bit("简单的QT解析出来的数据：") << name << "," << age << "," << myAccount;"简单的QT解析出来的数据：""LLH" , 20 , "123你好"其实这种json能满⾜⼀般的要求但是有些特殊数据要求json⾥⾯带有json数组就需要复杂⼀点的json了，来吧让我们继续。

Qt之JSON生成与解析

Qt之JSON生成与解析

Qt之JSON生成与解析简述Qt5 中包含了处理JSON 的类，均以QJson 开头（例如：QJsonDocument、QJsonArray、QJsonObject），在QtCore 模块中，不需要额外引入其它模块。

简述常用的JSON 库JSON 常用类简单的JSON 对象简单的JSON 数组复杂的JSON更多参考常用的JSON 库 中介绍了JSON 在各种语言中的应用，在C/C++ 中比较常用的JSON 库主要有以下几个：JsonCppJsonCpp 是一个C++ 用来处理JSON 数据的开发包。

网址：/cJSONcJSON 是一个超轻巧，携带方便，单文件，简单的可以作为ANSI-C 标准的JSON 解析器。

网址：/projects/cjson/QJsonQJson 是一个基于Qt 的开发包用来将JSON 数据解析成QVariant 对象，JSON 的数组将被映射为QVariantList 实例，而其他对象映射为QVariantMap 实例。

网址：/关于Qt 中对JSON 的生成与解析，Qt5 以前的版本，可以使用QJson 库，需要单独下载、编译，才能使用。

到了Qt5，提供了专门的QJsonDocument 及其相关类来读和写JSON 文档。

JSON 常用类QJsonDocumentQJsonDocument 类用于读和写JSON 文档。

一个JSON 文档可以使用QJsonDocument::fromJson() 从基于文本的表示转化为QJsonDocument，toJson() 则可以反向转化为文本。

解析器非常快且高效，并将JSON 转换为Qt 使用的二进制表示。

已解析文档的有效性，可以使用!isNull() 进行查询。

如果要查询一个JSON 文档是否包含一个数组或一个对象，使用isArray() 和isObject()。

包含在文档中的数组或对象可以使用array() 或object() 检索，然后读取或操作。

json解析流程

json解析流程

JSON（JavaScript Object Notation）是一种常用于数据交换的轻量级数据格式。

解析JSON数据通常涉及以下几个步骤：1. 读取数据：首先，你需要从数据源（如文件、网络请求等）读取JSON 数据。

这可以是一个包含JSON数据的文本文件、HTTP响应等。

2. 解析数据：解析是将JSON文本数据转换为编程语言内部的数据结构的过程。

在大多数编程语言中，都有内置的JSON解析库或模块，可以用来解析JSON数据。

3. 解析器：JSON解析库或模块会将JSON文本解析为对象、字典、数组或其他适合的数据结构，这样你就可以在编程语言中操作这些数据了。

4. 访问数据：解析后的JSON数据被表示为编程语言的数据结构，你可以通过对象属性、字典键值、数组索引等方式来访问和操作数据。

5. 错误处理：在解析JSON数据时，可能会出现错误，比如JSON格式不正确、缺失了某些键值等。

解析库通常提供了错误处理机制，你可以捕获并处理这些错误，以便在解析出错时进行适当的操作。

6. 释放资源：在解析完毕后，确保释放已分配的资源，如关闭文件句柄、释放内存等。

以下是一个简单的伪代码示例，展示了JSON解析的基本流程（以Python 为例）：import json# 读取JSON数据json_data = '{"name": "John", "age": 30, "city": "New York"}'# 解析JSON数据parsed_data = json.loads(json_data)# 访问数据name = parsed_data["name"]age = parsed_data["age"]city = parsed_data["city"]# 打印数据print("Name:", name)print("Age:", age)print("City:", city)```在实际开发中，根据所使用的编程语言和JSON解析库的不同，具体的解析流程可能会有细微的差异。

Qt简单的解析Json数据例子（一）

Qt简单的解析Json数据例子（一）

Qt简单的解析Json数据例⼦（⼀）要解析的json的格式为：{"rootpath": "001","usernum": 111,"childdep": [{"depid": "11","depnum": 20},{"depid": "15","depnum": 23}]}1234567891011121314std::map<std::wstring, int> part_depid_num;//这⾥是吧json的数据直接写成了字符串的形式来完成QByteArray data = QByteArray("{\"rootpath\":\"001\",\"usernum\":111,\"childdep\":[{\"depid\":\"11\",\"depnum\":20},{\"depid\":\"15\",\"depnum\":23}]}"); //判断字符串转化为QJsonDocument 是否出现了错误QJsonParseError jsonError;//Qt5新类QJsonDocument json = QJsonDocument::fromJson(data, &jsonError);//Qt5新类if (jsonError.error == QJsonParseError::NoError){if (json.isObject()){QJsonObject rootObj = json.object();QString rootpath;int rootusernum;//是否含有key rootpathif (rootObj.contains("rootpath")){//取出key为rootpath的值QJsonValue value = rootObj.value("rootpath");//判断是否是string类型if (value.isString()){rootpath = value.toString();}}if (rootObj.contains("usernum")){//取出key为usernum的值QJsonValue value = rootObj.value("usernum");//判断是否为double类型if (value.isDouble()){rootusernum = value.toDouble();}}part_depid_num[rootpath.toStdWString()] = rootusernum;if (rootObj.contains("childdep")){QJsonValue valueArray = rootObj.value("childdep");//判断类型是否为array，并且将array遍历出来if (valueArray.isArray()){QJsonArray jsonArray = valueArray.toArray();for (int i = 0; i < jsonArray.count();i++){QJsonValue childValue = jsonArray[i];if (childValue.isObject()){QString child_depid;QString child_usernum;int child_usern;QJsonObject childObject = childValue.toObject();if (childObject.contains("depid")){QJsonValue valueJson = childObject.value("depid");if (valueJson.isString()){child_depid = valueJson.toString();}}if (childObject.contains("depnum")){QJsonValue valueJson = childObject.value("depnum");if (valueJson.isDouble()){child_usern = valueJson.toDouble();}}if (child_usernum.isEmpty()){part_depid_num[child_depid.toStdWString()] = child_usern;}}}}}}}//printf(QString::fromStdWString(part_depid_num.begin()->first).toStdString().c_str()); std::map<std::wstring, int> ::iterator it;for (it = part_depid_num.begin(); it != part_depid_num.end();it++){cout << QString::fromStdWString(it->first).toStdString().c_str()<<endl;}。

Qt操作json文件

Qt操作json文件

Qt操作json⽂件json 数据在Qt中常见的数据传输格式为 xml 与 json 这个两种，其中 xml 在1996年提出是⼀种出现时间相对较久的⽂件格式，与2002年提出的json相⽐，他可以标注数据的⼀些属性，并且可以直接被html识别。

相⽐较来说json就是⽐较简洁，⼈的可读性更强。

更适合⽤来传输数据。

json格式：{"name" : "mil","age" : 15,"language": ["zh", "eng"],"course" : [{"name" : 'math","score": 66},{"name" : "eng","score": 99}]}在Qt中使⽤QJsonDocument读写json⽂件。

类类说明QJsonDocument读写json⽂档QJsonObject封装Json对象QJsonArry封装json数组QJosnValue封装json值，int,flot,double,{},[]QJsonObjectQJsonParseError所选json处理过程中出现的错误封装 jsonvoid Widget::pkjson(){QFile jsfile("../test_1.json");// ---> 封装/保存 jsonQJsonObject rootObj;QJsonObject professionalObj;professionalObj.insert("english", 4);QJsonArray languageArr;languageArr.append("c");languageArr.append("c++");rootObj.insert("name","milo");rootObj.insert("age",80);rootObj.insert("professional", professionalObj);rootObj.insert("phone","milo");rootObj.insert("language", languageArr);rootObj.insert("hard","milo");rootObj.insert("hot","milo");QJsonDocument jdoc(rootObj);// ---> 打开⽂件并向⽂件中添加内容if(jsfile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append)) {QTextStream js(&jsfile);js<< jdoc.toJson();jsfile.close();} else {cout << "打开失败";}}解析 jsonvoid Widget::exjson(){// ---> 解包jsonQFile jsfile("../test_1.json");if(jsfile.open(QIODevice::ReadOnly)){// ---> 设置解析报错QJsonParseError err;// ---> 解释json⽂件QJsonDocument jsdoc = QJsonDocument::fromJson(jsfile.readAll(), &err); if(err.error!=QJsonParseError::NoError){// ---> 如果有报错cout << "json 格式错误！";return;} else {// ---> 读取根⽬录QJsonObject rootObj = jsdoc.object();// ---> 读取 key = name 的值cout << rootObj.value("name").toString();QJsonArray lanArr = rootObj.value("language").toArray();cout << lanArr.at(0).toString() << lanArr.at(1).toString();// ---> 判断key的类型，是arry 还是 objif(rootObj.value("professional").type() == QJsonValue::Object){cout << "这个key的类型是 obj";}}jsfile.close();}}。

jsoncpp用法

jsoncpp用法

jsoncpp用法JSONCpp 是一个免费且开源的C++ JSON 解析库，它使用 MIT 许可证发布，旨在提供一种快速和行之有效的方式来解析和构建 JSON 语法格式的文档。

JSONCpp 对 C++ 和JavaScript 等语言均支持。

JSONCpp 包含一系列类，比如 Value 类、Reader 类和 Writer 类，可以用来定义和处理 JSON 语法格式的文档。

Value 类是最重要的核心类，它用于描述 JSON 文档中的元素，比如 null、Boolean、Array、Object、Number 和 String。

该类不仅能用来存储JSON 文本，也可以在 Value 对象中处理这些元素。

Reader 类用于从 JSON 文档中解析和读取信息，Writer 类用于构建 JSON 文档。

JSONCpp 的 API 设计很简单，能帮助开发者很快的掌握，解析 JSON 语法格式的文档也很方便。

1. 首先，引入需要的头文件：#include<jsoncpp/json/json.h>2. 然后，创建 Value 对象，用于存储 JSON 文档的元素：Json::Value root;3. 接着，使用 Reader 类读取文档：Json::Reader reader;4. 最后，调用 parse() 方法，解析 JSON 文档：if (reader.parse(strJson, root)){// parse success}另外，Writer 类可以用于构建 JSON 文档。

开发者可以用它来创建一段新的 JSON 文档，使用下面的步骤：2. 然后设置节点的值：root["Name"] = "John";root["Age"] = 20;4. 最后，调用 write() 方法，把文档写入到字符串中： writer.write(root, strJson);。

jsoncpp详解

jsoncpp详解

jsoncpp详解JSON详解一、what is jsonJSON(JavaScript Object Notation)跟xml一样也是一种数据交换格式，而Jsoncpp是个跨平台的开源库。

二、json的特性JSON 数据的书写格式是：名称/值对。

名称/值对包括字段名称（在双引号中），后面写一个冒号，然后是值："firstName":"John"。

JSON 值可以是：数字（整数或浮点数）、字符串（在双引号中）、逻辑值（true 或 false）、数组（在方括号中）、对象（在花括号中）、null。

对象在json中表示为“{}”括起来的内容，数据结构为{key：value,key：value,...}的键值对的结构。

数组在js中是中括号“[]”括起来的内容，数据结构为["java","javascript","vb",...]。

三、JsonCpp的基本语法使用JsonCpp前先来熟悉几个主要的类：Json::Value 可以表示里所有的类型，比如int,string,object,array 等，具体应用将会在后边示例中介绍。

Json::Reader 将json文件流或字符串解析到Json::Value, 主要函数有Parse。

Json::Writer 与Json::Reader相反，将Json::Value转化成字符串流，注意它的两个子类：Json::FastWriter和Json::StyleWriter，分别输出不带格式的json和带格式的json。

1、ValueJson::Value 是jsoncpp 中最基本、最重要的类，用于表示各种类型的对象，jsoncpp 支持的对象类型可见 Json::ValueType 枚举值。

可如下是用 Json::Value 类：Json::Value json_temp;json_temp["name"] = Json::Value("huchao");json_temp["age"] = Json::Value(26);Json::Value root;root["key_string"] = Json::Value("value_string");// 新建一个Key（名为：key_string），赋予字符串值："value_string"。

解析json的3种方法

解析json的3种方法

解析json的3种方法JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人们阅读和编写，同时也易于机器解析和生成。

在日常的软件开发中，我们经常会遇到需要解析JSON数据的情况。

本文将介绍解析JSON的三种方法，希望能够帮助大家更好地理解和应用JSON数据。

第一种方法是使用内置的JSON对象进行解析。

在JavaScript 中，可以使用JSON对象的parse方法将JSON字符串转换为JavaScript对象，或者使用stringify方法将JavaScript对象转换为JSON字符串。

这种方法简单易用，适用于简单的JSON数据解析和生成。

第二种方法是使用第三方库进行解析。

除了内置的JSON对象，还有许多第三方库可以用来解析JSON数据，例如在Node.js中常用的库有`jsonparse`、`json5`等。

这些库通常提供了更多的功能和更灵活的选项，可以满足各种复杂的JSON数据解析需求。

第三种方法是使用JSON Schema进行解析。

JSON Schema是一种用于描述JSON数据结构的语言，可以用来验证和解析JSON数据。

通过定义JSON Schema，可以规定JSON数据的结构和约束条件，然后使用相应的工具来解析和验证JSON数据。

这种方法适用于需要对JSON数据进行严格验证和规范的场景。

总的来说，解析JSON数据有多种方法可供选择，每种方法都有其适用的场景和特点。

在实际应用中，我们可以根据具体的需求和情况选择合适的方法来解析JSON数据，以便更好地处理和利用JSON数据。

希望本文介绍的三种方法能够对大家有所帮助，让大家在日常的软件开发中更加轻松地处理JSON数据。

qjsonobject解析

qjsonobject解析

qjsonobject解析QJsonObject是Qt框架中用于处理JSON格式数据的类，可以用来创建、读取和修改JSON对象。

在此文中，我们将探讨如何使用QJsonObject解析JSON格式的数据。

首先，我们需要了解JSON格式的基本规则。

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它使用键值对的方式表示数据。

一个JSON对象由一组键值对组成，每个键值对由一个属性名和一个属性值组成，使用冒号（:）分隔。

属性值可以是字符串、数字、布尔值、数组或者嵌套的JSON对象。

QJsonObject的创建非常简单。

我们可以通过添加键值对的方式一步步地创建一个JSON对象：```QJsonObject obj;obj.insert('name', 'Tom');obj.insert('age', 20);obj.insert('isStudent', true);```在这个例子中，我们创建了一个包含三个键值对的JSON对象，分别表示一个人的姓名、年龄和是否为学生。

添加键值对的方式是使用insert()函数，第一个参数是属性名，第二个参数是属性值。

QJsonObject也可以从字符串中解析出JSON对象：```QString jsonStr = '{'name':'Tom', 'age':20,'isStudent':true}';QJsonDocument jsonDoc =QJsonDocument::fromJson(jsonStr.toUtf8());QJsonObject obj = jsonDoc.object();```在这个例子中，我们将JSON字符串解析为QJsonDocument对象，然后使用object()函数获取QJsonObject对象。

Window下Qt如何解析Json之jsoncpp完整讲解

Window下Qt如何解析Json之jsoncpp完整讲解

Window下Qt如何解析Json之jsoncpp完整讲解下载地址是:/projects/jsoncpp/解压之后得到jsoncpp文件夹，我们只需要jsoncpp的头文件和cpp文件，其中jsonscpp的头文件位于jsoncpp\include\json,jsoncpp的cpp文件位于jsoncpp\src\lib_json。

如果下载太难，也可以联系我QQ773155801，与大家共同交流这里我列出我们的工作目录:jsoncpp/ //工作目录|-- include //头文件根目录| |-- json //json头文件，对应jsoncpp-src-0.5.0\include\json|-- src //cpp源码文件根目录|-- json //jsoncpp源码文件，对应jsoncpp-src-0.5.0\src\lib_json|-- main.cpp //我们的主函数，调用jsoncpp的示例代码|-- makefile //makefile，不用我们多说了吧，不懂请看我博客的makefile最佳实践如果你下载到的文件是上面的文件，那恭喜你，你基本上就可以使用此库文件里，啊？你要问不是还有编译吗？告诉你一个好消息，不用了，也没必要。

废话中。

自己在这方面走过很多的弯路，一、是下载这个类库不是很容易，虽然的网址，不知道为什么，是不是他们商量好的，网址一会可以打开一会打不开，可能访问的人太多，也可能自己的网速差。

二、是看过很多资料，说是要编译过才可以使用，到处找QJson和Jsoncpp 两种库的编译方法，看差他们说的挺简单的，但是自己就是不能生成，难道我太笨了？不信，于是乎，我相信绝对有一种方法在等着我去寻找。

三、知道不用编译也可以使用Json这个类库，那我真是太高兴了，再于是乎，我找啊找找啊，你知道不我浪费了多少时间，就像你在发现我这篇文章之前，你说你浪费了多少时间，看到我的这个报告，算你幸运。

解析json的3种方法

解析json的3种方法

解析json的3种方法解析JSON数据有三种常见的方法：手动解析、使用第三方库和利用语言内置的解析器。

下面将详细介绍这三种方法。

1. 手动解析手动解析是最基本的JSON解析方法之一。

它适用于简单的JSON结构和较小的JSON文件。

手动解析的主要步骤包括以下几个方面：1.1 读取JSON数据首先，需要将JSON数据读取到内存中。

可以使用文件读写操作或网络请求等方式获取JSON数据，然后将数据存储在字符串变量中。

1.2 解析JSON数据接下来，需要逐个解析JSON数据的各个字段。

JSON数据由键值对组成，每个键对应一个值。

可以使用字符串处理操作（例如截取子字符串）和正则表达式等方式逐步解析JSON数据。

手动解析需要注意处理JSON数据中可能出现的异常情况，例如缺失的字段或字段值为null等。

1.3 获取JSON字段值完成解析后，可以通过键来获取对应的值。

根据JSON数据的结构，可以使用字符串处理操作和类型转换等方式将获取到的值转换为所需的数据类型，例如字符串、整数、浮点数等。

手动解析的优点是灵活性高，适用于简单的JSON结构和小型JSON文件。

缺点是需要编写较多的代码来处理JSON数据，且容易出错。

2. 使用第三方库第二种方法是使用第三方库来解析JSON数据。

大多数编程语言都提供了丰富的JSON解析库，例如Python中的json库、Java中的Gson和Jackson库，以及JavaScript中的JSON.parse()等。

使用第三方库的主要步骤如下：2.1 导入第三方库首先，需要导入所需的JSON解析库。

可以使用包管理工具或手动将库文件添加到项目中。

2.2 加载JSON数据接下来，需要将JSON数据加载到程序中。

可以使用文件读写操作或网络请求等方式获取JSON数据，并将其存储在合适的数据结构中（例如字符串、字典或列表）。

2.3 解析JSON数据使用第三方库提供的API，可以方便地解析JSON数据。

json解析流程

json解析流程

json解析流程一、什么是JSONJSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于阅读和编写，同时也易于解析和生成。

它基于JavaScript 编程语言的一个子集，常用于将数据从服务器传输到Web页面。

JSON使用键值对的方式来表示数据，其中键是字符串，值可以是字符串、数字、布尔值、数组、对象或null。

二、JSON解析流程JSON解析是将JSON数据转换为程序可以操作的数据结构的过程。

在不同编程语言中，JSON解析的流程可能存在细微的差异，但总体上可以分为以下几个步骤。

1. 读取JSON数据程序需要读取JSON数据。

这可以通过从文件、网络请求或其他数据源中读取JSON字符串来实现。

在读取JSON数据之前，程序需要确保数据的可用性和正确性。

2. 解析JSON数据读取JSON数据后，程序需要将其解析为内存中的数据结构，以便后续操作。

解析JSON数据的方式多种多样，可以使用现有的JSON解析库或手动解析。

3. 验证JSON数据解析JSON数据后，程序需要对数据进行验证，以确保其符合预期的格式和结构。

这包括验证JSON对象的键值对、数组的元素、字符串的格式等。

如果数据验证失败，程序应该及时处理错误，避免后续操作出现问题。

4. 提取所需数据一旦JSON数据被解析和验证，程序就可以根据需要提取所需的数据。

这可以通过访问JSON对象的特定键值对、遍历JSON数组的元素或执行其他操作来实现。

5. 进行数据操作提取所需数据后，程序可以根据业务逻辑进行进一步的数据操作。

这包括对数据进行计算、筛选、排序等操作，以满足具体的需求。

6. 输出处理结果程序可以将处理结果输出为JSON格式的字符串、其他数据格式或以其他方式展示给用户。

输出结果应符合预期的格式和结构，以便其他系统或程序能够正确解析和使用。

三、JSON解析的注意事项在进行JSON解析时，需要注意以下几点，以确保解析过程的正确性和高效性。

json的解析方式

json的解析方式

json的解析方式JSON的解析方式随着互联网的快速发展，数据的交换和传输变得越来越重要。

而JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，广泛应用于各个领域。

在使用JSON数据的过程中，解析是一个至关重要的步骤，本文将介绍几种常见的JSON解析方式。

一、JSON解析方式概述JSON数据由键值对组成，使用大括号{}包围，键值对之间使用逗号分隔。

在解析JSON数据时，主要有两个方向：将JSON数据解析为对象或将JSON数据解析为字符串。

下面将分别介绍这两种方式的解析方法。

二、将JSON数据解析为对象1. 使用编程语言提供的内置函数大多数编程语言都提供了内置的JSON解析函数，例如Python中的json.loads()函数、JavaScript中的JSON.parse()函数等。

这些函数可以将JSON数据解析为对象，并方便地操作和访问其中的数据。

2. 使用第三方库除了内置函数，还可以使用第三方库来解析JSON数据。

一些流行的JSON解析库包括Jackson、Gson、Fastjson等。

这些库通常提供了更丰富的功能和更高的性能，可以满足各种复杂的解析需求。

三、将JSON数据解析为字符串1. 使用编程语言提供的内置函数与将JSON数据解析为对象相反，将JSON数据解析为字符串是将对象转化为JSON数据的逆过程。

编程语言通常提供了内置的函数来实现这一功能，例如Python中的json.dumps()函数、JavaScript中的JSON.stringify()函数等。

2. 使用第三方库与解析为对象类似，也可以使用第三方库来将JSON数据解析为字符串。

这些库通常提供了更多的选项和定制化功能，可以满足不同场景下的需求。

四、解析方式的选择和注意事项在选择JSON解析方式时，需要考虑以下几个因素：1. 编程语言的支持：不同的编程语言可能提供不同的解析方式，需要根据具体情况进行选择。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
root["name"] = "json"; root["array"] = arrayObj;
root.toStyledString(); std::string out = root.toStyledString(); std::cout << out << std::endl; }
顺便提一下，就是关于这个 jsoncpp 解析中文乱码的事情 好多人，开始就觉得 jsoncpp 这个东西解析中文乱码不完善，网上也出现两种方法可以改变 jsoncpp 解析中文乱码的问题。 这都是我遇到的问题，这里我要告诉你的是，jsoncpp 代码很完美。 最后我在 jsoncpp 中的代码一句也没有改，可以成功了。。。。 因为之前在 main()方法里，我做了下面的声明
反序列化 Json 对象
假设有一个 json 对象如下:
{ "name": "json″, "array": [ { "cpp": "jsoncpp" }, { "java": "jsoninjava" }, { "php": "support" } ]
}
我们要实现这个 json 的反序列号代码如下:
结果如下
Json 里的文件自动分类 头文件，源文件，其它文件
现在就添加好了 那现在，我再告诉你，原来这个库文件需要编译的。。。你会怎么想？ 呵呵，不怕，因为咱有办法办了它 就像平时执行工程一样，运行一个自己的工程 运行好后，你再去 debug 文件夹看一看，你会发现，原来就在这里生成了一 个 qjson.dll 文件 现在是不是觉得很神奇呢 原来编译是如何的简单。。。 想一个以前是如何如何编译 mysql 插件的现在想一想，这个方法倒是可以帮 我们解决一些问题。。。 这个你也会编译了，那我们开始学习一个怎么用这个 你在学习怎么这个的时间，肯定因为需要它来解析 json 数据了，json 的数据 格式我就不说的，一般简单一点的如下：
由于想下 utf-8 与 gb2312 不兼容。。所以改成了，这样，就好了。。 QTextCodec::setCodecForLocale(QTextCodec::codecForName("utf-8"));
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("utf-8")); QTextCodec::setCodecForTr(QTextCodec::codecForName("utf-8"))果。 从上面代码中你可以得到至少这样两个重要信息 1、取值 value["姓名"].asString(); 2、取值 value["姓名"].asString(); 你没有看错，就是一样的，因为这是重点。。把值取出来
面用于你的自己的工程的时，你会发现，一个严重的问题：它们的数据类型不一 样，如何赋值呢。字符串在 c++中是 std::string，而在 Qt 中是 QString,现在告诉 你，它们两个可以互相转化，在这之前你可能没有用过 QString str; std::string out; out = str.toStdString(); str = out.c_str(); 知道他们之间如何转化，那你一定想知道如何利用它们，下面我把网上常见的几 个例子借用一上，供大家分享 注意：下面的例子很精典，认真琢磨，一定有很大收获。。
序列化 Json 对象
void writeJson() { using namespace std;
Json::Value root; Json::Value arrayObj; Json::Value item;
item["cpp"] = "jsoncpp"; item["java"] = "jsoninjava"; item["php"] = "support"; arrayObj.append(item);
if (!arrayObj[i].isMember("cpp")) continue;
out = arrayObj[i]["cpp"].asString(); std::cout << out; if (i != (arrayObj.size() - 1))
std::cout << std::endl; } } }
自己在这方面走过很多的弯路， 一、是下载这个类库不是很容易，虽然的网址，不知道为什么，是不是他们 商量好的，网址一会可以打开一会打不开，可能访问的人太多，也可能自己的网 速差。 二、是看过很多资料，说是要编译过才可以使用，到处找 QJson 和 Jsoncpp 两种库的编译方法，看差他们说的挺简单的，但是自己就是不能生成，难道我太 笨了？不信，于是乎，我相信绝对有一种方法在等着我去寻找。 三、知道不用编译也可以使用 Json 这个类库，那我真是太高兴了，再于是乎， 我找啊找找啊，你知道不我浪费了多少时间，就像你在发现我这篇文章之前，你 说你浪费了多少时间，看到我的这个报告，算你幸运。 问我为什么要写这个报告？那是因为我不想太多人像我这样走那么多弯路， 所以把心路历程同大家分享，同时也可以练习一下写文档。 ——————————————————————————————废话结束）
|-- main.cpp //我们的主函数，调用 jsoncpp 的示例代码
|-- makefile
//makefile，不用我们多说了吧，不懂请看我博客的 makefile 最佳实践
如果你下载到的文件是上面的文件，那恭喜你，你基本上就可以使用此库文 件里，
啊？你要问不是还有编译吗？告诉你一个好消息，不用了，也没必要。 废话中。。。
void readJson() { using namespace std; std::string strValue =
"{\"name\":\"json\",\"array\":[{\"cpp\":\"jsoncpp\"},{\"java\":\"jsoninjava\ "},{\"php\":\"support\"}]}";
Window 下 Qt 如何解析 Json 之 jsoncpp 完整讲解
下载地址是:/projects/jsoncpp/
解压之后得到 jsoncpp 文件夹，我们只需要 jsoncpp 的头文件和 cpp 文件，其 中 jsonscpp 的头文件位于 jsoncpp\include\json,jsoncpp 的 cpp 文件位于 jsoncpp\src\lib_json。 如果下载太难，也可以联系我 QQ773155801，与大家共同交流 这里我列出我们的工作目录:
Json::Reader reader; Json::Value value;
if (reader.parse(strValue, value)) {
std::string out = value["name"].asString(); std::cout << out << std::endl; const Json::Value arrayObj = value["array"]; for (unsigned int i = 0; i < arrayObj.size(); i++) {
下面整合 json 文件包
如图所示，把两个 include 和 src 文件夹中 json 文件夹中的文件合起来，包 括.h/.cpp/.inl/script，总之两个 json 文件夹中所有文件合在一起便是
把合起文件放在一个文件夹里，最好文件夹名为 json，之所以为这个名字， 相信编程到现在的你应该知道原因。把此文件夹拷贝到你的工程目录下，然后添 加现有文件
QTextCodec::setCodecForLocale(QTextCodec::codecForName("gb2312"));
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("gb2312")); QTextCodec::setCodecForTr(QTextCodec::codecForName("gb2312"));
out = value["姓名"].asString(); std::cout << out << std::endl;
out = value["性别"].asString(); std::cout << out << std::endl; }
你发现了没有，你自己定义的 Json::Reader 好像不存在，嗯，很重要，因为你没 有回头文件 #include <json/reader.h>
jsoncpp/
//工作目录
|-- include
//头文件根目录
| |-- json
//json 头文件，对应 jsoncpp-src-0.5.0\include\json
|-- src
//cpp 源码文件根目录
|-- json
//jsoncpp 源码文件，对应 jsoncpp-src-0.5.0\src\lib_json
{\"学号\":\"20120207001\",\"姓名\":\"张无忌\",\"性别\":\"男\"}
相关文档
最新文档