整合营销服务商

电脑端+手机端+微信端=数据同步管理

免费咨询热线:

JS中Json数据的处理和解析JSON数据的方法详解

JS中Json数据的处理和解析JSON数据的方法详解

习目标:

节数知识点要求第一节 数组去重数组去重了解第二节 数组排序数组排序了解第三节 json概述json概述掌握第四节 json方法json方法掌握第五节 json解析json解析掌握

一、数组去重

数组去重是指:从数组中找到相同的元素,并将相同的元素删除。

保证数组中的每个元素都是独一无二的操作。

1.1.indexOf去重

基本思想是:利用数组的indexOf方法,目的是寻找存入参数在数组中第一次出现的位置。

缺点:实现这个方法的时候会遍历数组直到找到目标为止,消耗掉很多时间。

var arr=[1,2,1,3,1,4**,2,3];
var arr2=[];
for(var i=0;i

最初arr2中没有元素。

循环判断,

只要arr中的元素不在arr2中

就把arr中的这个元素存入arr2中

那么最后arr2中的元素就是arr中所有不重复的元素

hash表去重

基本思想是:将已经出现过的元素当做属性名,存入一个object****内,下标的引用要比用indexOf搜索数组快的多

缺点:内存占用很多,以牺牲空间来换取时间。

var arr=[1,2,1,3,1,4];
var result=[]
var hash={};
for (var i=0; arr[i] !=undefined; i++) {
if (!hash[arr[i]]) {
result.push(arr[i]);

hash[arr[i]]=true;

}
}

最初result中没有元素

hash对象中没有属性
一直循环,直到数组元素是null为止

判断如果:

【hash对象】中,没有名为

【当前arr元素】的属性

为新数组result中添加这个元素

并为hash对象添加这个属性

二、数组排序

2.1冒泡排序

冒泡排序法:

数组当中两两相邻的元素比较,如果前一个比后一个大,那么两个数组元素就交换(就是把小的放前面),最终会找到一个最大的元素,放到最后面,然后再一次的循环比较。

$arr=[100,90,98,70,85,60,87]

第1次冒泡:90,98,70,85,60,87,100

第2次冒泡:90,70,85,60,87,98,100

第3次冒泡:70,85,60,87,90,98,100

第4次冒泡:70,60,85,87,90,98,100

第5次冒泡:60,70,85,87,90,98,100

第6次冒泡:60,70,85,87,90,98,100

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TGSauQSx-1608259559098)(020803JS算法和json解析.assets/clip_image006.png)]

2.2.快速排序

快速排序“的思想很简单,整个排序过程只需要三步:

(1)在数据集之中,选择一个元素作为“基准”(pivot)。

(2)所有小于“基准”的元素,都移到“基准”的左边;所有大于“基准”的元素,都移到“基准”的右边。

(3)对"基准"左边和右边的两个子集,不断重复第一步和第二步,直到所有子集只剩下一个元素为止。

2.3 递归函数

能够自己调用自己的函数称为递归函数。

可以说递归是编程思想当中最让人头疼的一种算法也不为过。

下面我们来看一个递归中最经典的例子

? var func=function (x) {

? if (x===1) {

? return 1;

? } else {

? return x*func(x-1);

? }

? };

? 这是递归中最经典的一个例子,叫做N!。

2.4 二分查找

二分查找的前提:有序数组,自然顺序(从小到大顺序)

找到中间的数,这个中间的数和你输入的数进行比较,如果你输入的数比中间的数大,就到后一半数据查找,否则就到前一半数据查找。

重复以上过程,直到找到满足条件的记录

var arr=[2, 4, 5, 9, 31, 60, 79, 80, 90];
使用原型来做。如果有这个数来输出true,没有输出false.

三、JSON概述

JSON****英文全称JavaScript Object Notation,是一种轻量级的数据交换格式。它可以存储数据和传输数据。

? JSON是一门独立的语言,用于存储和传输数据的格式,通常用于服务端向网页传递数据 。

? JSON语言采用了JavaScript的语法,这意味着在 JavaScript 中处理 JSON数据不须要任何特殊的 API 或工具包,但是还是需要说明的一点就是:

? JSON和Javascript是两门不同的语言。

JSON****的格式仅仅是一个文本,而文本是可以被任何编程语言读取及作为数据格式传递的。

3.1 json的语法

· 数据在名称/值对中

· 数据由逗号分隔

· 大括号保存对象

· 中括号保存数组

JSON 对象在大括号({})中书写:

Var obj={

“name”:”peter”,

**“sex”:”**男”,

“age”:25

}

对象可以包含多个名称/值对:

JSON 数据的书写格式是:名称/值对。

名称/值对包括字段名称(在双引号中),后面写一个冒号,然后是值

{ “name”:“halon”, “sex”:“woman”, “from”:“希腊” }

3.2 JSON 与 JS 对象的区别与对比

区别JSONJavascript含义仅仅是一种数据格式表示类的实例传输可以跨平台数据传输,速度快不能传输表现1.键值对方式,键名必须加双引号 2.值不能是方法函数,不能是undefined/NaN1.键值对方式,键名不加引号 2.值可以是函数、对象、字符串、数字、boolean 等

四、JSON提供的方法

个人理解,JSON就是

(1)将【前台的数据(对象、数组等)】转换成【字符串发送给后台】。

(2)将【后台回传的数据(字符串)】转换为【普通的数据(对象、数组等)】。

4.1 parse()方法

JSON.parse(后台传输过来的数据)

反序列化(有时候也被称作JSON数据解析,简称为JSON解析),

能够把JSON字符串转换成JS的数据类型。

转换的时候,如果字符串中存在不符合JSON要求的格式,会直接报错。

JSON解析就是通过某种手段,将【后台回传的字符串数据】转换成【可以直接被使用的数据】的过程。

通常情况下JS中的JSON解析会直接采用JSON中提供的JSON.parse方法来直接转换。

var info='{
 "name":"halon",
 "sex":"woman",
 "from":"希腊" 
}'

console.log(JSON.parse(info));

4.2 stringify()方法

JSON.stringify(要往后台传输的数据)

序列化(有时候也被称作JSON数据封装或数据加密)

能够把JS的数据类型转换成JSON字符串。

转换的时候,如果数据中存在不符合JSON要求的格式,会做对应的处理

么是 JSON?

  • JSON 英文全称 JavaScript Object Notation
  • JSON 是一种轻量级的数据交换格式。
  • JSON是独立的语言 *
  • JSON 易于理解。
  • json对象使用js语法,但是json字符串仅仅是一个文本。
  • 文本可以被任何一种编程语言读取及作为数据格式传递。

JSON 格式化后为 JavaScript 对象

JSON 格式在语法上与创建 JavaScript 对象代码是相同的。

由于它们很相似,所以 JavaScript 程序可以很容易的将 JSON 数据转换为 JavaScript 对象。

  • JSON 语法规则
  • 数据为 键/值 对。
  • 数据由逗号分隔。
  • 大括号保存对象
  • 方括号保存数组

JSON 数据 - 一个名称对应一个值

JSON 数据格式为 键/值 对,就像 JavaScript 对象属性。

键/值对包括字段名称(在双引号中),后面一个冒号,然后是值:

"name":"Runoob"

JSON 对象

JSON 对象保存在大括号内。

就像在 JavaScript 中, 对象可以保存多个 键/值 对:

{"name":"Runoob", "url":"www.runoob.com"}


谓递归算法,是将问题转化为规模缩小的同类问题的子问题,每一个子问题都用一个同样的算法去解决。一般来说,一个递归算法就是函数调用自身去解决它的子问题。

使用递归算法实现:大题的分数值等于其下各小题的分数值之和。

本文讲解所用到的数据集合(已是树形结构)。

一、节点数据集合

  1. var nodes=[{
  2. "id": "EQ06-9006C8BBE68A475BAC04858F60E0249D",
  3. "name": "题目1",
  4. "type": "解答题",
  5. "children": [{
  6. "id": "EQ06-CC80CFD8702F47E4A42AF63B0BA10569",
  7. "name": "题目1.1",
  8. "type": "解答题",
  9. "score": 5
  10. }, {
  11. "id": "EQ06-06F7EBA807D445EB937B920ED2250016",
  12. "name": "题目1.2",
  13. "type": "解答题",
  14. "score": 6
  15. }],
  16. "score": 10
  17. }, {
  18. "id": "EQ06-0F0A8DA4B5834D1BB96504546EA47DA9",
  19. "name": "题目2",
  20. "type": "解答题",
  21. "children": [{
  22. "id": "EQ06-660D9E79B5054EA296D15EFA6D1F5462",
  23. "name": "题目2.1",
  24. "type": "解答题",
  25. "score": 10
  26. }, {
  27. "id": "EQ06-C5D5191018B94E8C8D1E9AB3AD5E4C61",
  28. "name": "题目2.2",
  29. "type": "解答题",
  30. "score": 20,
  31. "children": [{
  32. "id": "EQ06-037CBCDFD897434A839619D4AF07E030",
  33. "name": "题目2.2.1",
  34. "type": "解答题",
  35. "score": 5
  36. }, {
  37. "id": "EQ06-FC7CAE767F4E48D6B3E0B78D5E4BC473",
  38. "name": "题目2.2.2",
  39. "type": "解答题",
  40. "score": 6
  41. }, {
  42. "id": "EQ06-FC7CAE767F4E48D6B3E0B78D5E4BC474",
  43. "name": "题目2.2.3",
  44. "type": "解答题",
  45. "score": 7
  46. }]
  47. }],
  48. "score": 40
  49. }];

起初朋友给我发了一段数据,输出的是题目节点信息,其中包含题目的分数值:score,原始数据已经过树形结构处理了。

他的需求是:题目的分数值 score 是创建题目时预估定义的一个分数值,如20分;实际情况是在某个大题的下面还可以创建小题,小题也会定义一个分数值 score,这样一来,某个大题原先预估定义的分数值 score 可能与它下面所有小题的分数值 score 加起来的和并不相等,这样大题的分数值 score 就显得不准确,希望我在前端能帮忙处理一下,使得大题的分数值等于汇总了其下所有小题的分数值之和,以符合题目分数在实际展现时的准确无误。

接到朋友的这个 issue,我想了一下,大致要求就是针对于某个节点的属性(这里是 score),汇总累加其下所有子节点的这个属性(score)的数值,然后将这一过程中累加得到的数值赋到父节点的这个属性(score)上。

为了实现树型结构数据的遍历与处理,免不了要想到使用递归函数来实现。我们先来看一下定义,所谓递归算法,是将问题转化为规模缩小的同类问题的子问题,每一个子问题都用一个同样的算法去解决。一般来说,一个递归算法就是函数调用自身去解决它的子问题。

递归算法的特点:

在函数过程中调用自身。

在递归过程中,必须有一个明确的条件判断递归的结束,既递归出口。

递归算法简洁但效率低,通常不作为推荐算法。

上面这是原理性的解释,讲的也是十分明确,下面我们结合实例来细细琢磨。

二、编写一个递归算法,实现汇总累加节点的分数值

  1. var getScoreSum=function (data, options){
  2. //默认参数配置
  3. var options={
  4. scoreField: options.scoreField || "score", //分数属性名
  5. childrenField: options.childrenField || "children", //子节点集合属性名
  6. spread: options.spread || false
  7. };
  8. var scoreSum=0; //定义父级节点汇总分数的局部变量
  9. if(data && data.length > 0){
  10. for(var i=0, item; i < data.length; i++){
  11. item=data[i];
  12. var itemScore=item[options.scoreField] || 0, itemChildren=item[options.childrenField] || []; //定义本次循环中的局部变量
  13. var tempSum=0; //定义当前条目汇总分数的临时变量
  14. //是否有子节点
  15. if(itemChildren && itemChildren.length > 0){
  16. var tempCldSum=getScoreSum(itemChildren, options) || 0; //递归调用 getScoreSum() 方法,获取当前节点下的子节点集合的汇总分数 tempCldSum
  17. tempSum +=tempCldSum; //子节点集合的汇总分数 tempCldSum,追加到当前节点汇总分数 tempSum 上
  18. }else{
  19. tempSum +=itemScore; //没有子节点,以当前节点的分数值追加到当前节点汇总分数 tempSum 上
  20. delete item[options.childrenField]; //删除属性
  21. }
  22. item["scoreSum"]=tempSum; //已有或一个新的节点属性:scoreSum,并使用当前节点汇总分数 tempSum 赋值
  23. item["name"]=item.name + '(' + (item.scoreSum || item.score) + ' 分)' //其他属性设置
  24. item["spread"]=options.spread;
  25. scoreSum +=tempSum; //当前节点汇总分数追加到父级节点汇总分数上
  26. }
  27. }
  28. return scoreSum;
  29. }

在方法中用到了调用方法自身的执行语句,目的是遍历所有子节点,做相同的累加处理。

三、调用递归函数,并测试题目的分数值在实际数据展现时是否准确无误

  1. //layui 模块化组件引用
  2. layui.use(['jquery', 'layer', 'tree'], function () {
  3. var $=layui.$, layer=layui.layer, tree=layui.tree;
  4. //分数汇总处理
  5. getScoreSum(nodes, {scoreField: "score", childrenField: "children", spread: true});
  6. //console.log(nodes);
  7. //构建树节点
  8. var buildTreeNodes=function (options) {
  9. options=options || {};
  10. var treeNodes=[{ name: "全部分组", spread: true, children: nodes }];
  11. $("#treeGroup").empty(); //先清空DOM
  12. layui.tree({
  13. elem: '#treeGroup',
  14. nodes: treeNodes,
  15. click: function (node) {
  16. var self=$(this.elem);
  17. var nodeLinks=self.find("li>a");
  18. nodeLinks.removeClass("active");
  19. nodeLinks.filter(function (index) {
  20. return $('cite', this).text()==node.name;
  21. }).addClass('active');
  22. nodeLinks.splice(0, 1); //删除数组第一项:全部分组
  23. console.log(node); //node即为当前点击的节点数据
  24. document.getElementById("nodeContent").innerHTML=JSON.stringify(node, null, 2); //使用JSON.stringify() 格式化输出JSON字符串
  25. }
  26. });
  27. if (options.selectedNodeName) {
  28. var elem=$("#treeGroup");
  29. var nodeLinks=elem.find("ul>li>a");
  30. nodeLinks.removeClass("active");
  31. nodeLinks.filter(function (index) {
  32. return $('cite', this).text()==options.selectedNodeName;
  33. }).trigger('click');
  34. }
  35. }
  36. buildTreeNodes();
  37. });

在这里我用的是 layui 框架中的 tree 组件来展现递归处理后的数据。新建一个 scoreSum.html 和 scoreSum.js 文件,在 scoreSum.html 中放一个 id="tree" 的元素,用来加载递归处理汇总累加分数值之后的树形节点数据。

scoreSum.html 页面的代码如下:

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4. <meta charset="utf-8">
  5. <meta name="renderer" content="webkit">
  6. <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
  7. <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
  8. <meta name="apple-mobile-web-app-status-bar-style" content="black">
  9. <meta name="apple-mobile-web-app-capable" content="yes">
  10. <meta name="format-detection" content="telephone=no">
  11. <title>使用递归汇总累加题目分数值</title>
  12. <link rel="stylesheet" href="assets/layui/css/layui.css" media="all" />
  13. <style type="text/css">
  14. body{
  15. margin: 12px;
  16. }
  17. .layui-tree li a.active{
  18. border-color: lightblue;
  19. background-color: #b1deff;
  20. }
  21. </style>
  22. </head>
  23. <body>
  24. <div class="layui-row layui-col-space20" style="margin-top: 15px;">
  25. <div class="layui-col-md4">
  26. <fieldset class="layui-elem-field">
  27. <legend>题目索引</legend>
  28. <blockquote class="layui-elem-quote layui-quote-nm layui-bg-gray">
  29. <p>大题下面有小题,大题的分数是汇总其下各小题的分数</p>
  30. </blockquote>
  31. <div class="layui-field-box">
  32. <ul id="tree"><li class="text-muted">正在加载...</li></ul>
  33. </div>
  34. </fieldset>
  35. </div>
  36. <div class="layui-col-md8">
  37. <fieldset class="layui-elem-field">
  38. <legend>题目信息</legend>
  39. <div class="layui-field-box">
  40. <blockquote class="layui-elem-quote">
  41. <p><i class="layui-icon"></i> 题目的分数值以“scoreSum”为准,“score”是从数据库中读出来的,仅作参考。</p>
  42. </blockquote>
  43. <blockquote class="layui-elem-quote layui-quote-nm">
  44. <pre id="nodeContent"><span class="layui-word-aux">点击左边节点,以加载节点信息……</span></pre>
  45. </blockquote>
  46. </div>
  47. </fieldset>
  48. </div>
  49. </div>
  50. <script type="text/javascript" src="assets/layui/layui.js"></script>
  51. <script type="text/javascript" src="scoreSum.js"></script>
  52. </body>
  53. </html>

scoreSum.js 存放的就是上面几段脚本:

  1. //节点数据集合
  2. var nodes=[{
  3. ……
  4. }];
  5. //使用递归算法,实现汇总累加节点的分数值
  6. var getScoreSum=function (data, options){
  7. ……
  8. }
  9. //layui 模块化组件引用
  10. layui.use(['jquery', 'layer', 'tree'], function () {
  11. var $=layui.$, layer=layui.layer, tree=layui.tree;
  12. ……
  13. buildTreeNodes();
  14. });

四、效果截图

效果截图:大题的分数值是其下小题分数值的累计之和(11=5+6)。

本案例完整的项目文件目录截图。