ibatis查询结果返回数组_ES6 的新鲜玩意儿——数组结构的功能增强（1）

js中的数组是非常非常重要的数据结构，也非常非常的灵活，方法非常的齐全。本来es5就已经有非常多的的方法，es6又对其进行了扩展，可见这数据结构在开发过程中真的非常的重要。撸起：

let arr = new Array();
console.log(arr);//剖析数据结构

结果：

先来总结一下ES5的Array的重要方法：

谁能告诉我，表格如何输入，我实在不知道如何输入表格数据，所以使用了图片。

方法详解

1、concat()：合并数组，可以合并一个或多个数组，返回合并数组之后的新数组，不会改变原来的数组。

// 1：concat(); 功能：合并数组，可以合并一个或多个数组，返回合并数组之后的新数组，不会改变原来的数组。
let arr1 = new Array(1,2);
let arr2 = new Array("a","b");
let concatResultArr = arr1.concat(arr2);
console.log("concatResultArr:",concatResultArr);//[1,2,"a","b"]
console.log("arr1:",arr1); //[1,2]
console.log("arr2:",arr2); //["a","b"]

2、join()： 将数组转为字符串并返回转化的字符串数据，不会改变原来的数组。

// 2：join(); 功能：将数组转为字符串并返回转化的字符串数据，不会改变原来的数组。
let str = new Array("a","b",1,2).join(",");//以,号隔开
console.log(str);//a,b,1,2

3、pop()：删除数组的最后一位，并且返回删除的数据，会改变原来的数组。

//3、pop()：删除数组的最后一位，并且返回删除的数据，会改变原来的数组。
let popArr = new Array(1,2,3);
console.log("popArr.pop():",popArr.pop());//3

console.log(popArr); //1.2

4、shift()：删除数组的第一位数据，并且返回新数组的长度，会改变原来的数组。

//4、shift()：删除数组的第一位数据，并且返回新数组的长度，会改变原来的数组。
let shiftArr = new Array(1,2,3);
console.log("shiftArr.pop():",shiftArr.shift());//1

console.log(shiftArr); //2 3

5、unshift()：在数组的首位新增一个或多数据，并且返回数组的长度，会改变原来的数组。

//5、unshift()：在数组的首位新增一个或多数据，并且返回数组的长度，会改变原来的数组。
let unshiftArr = new Array(1,2,3);
console.log("unshiftArr.unshift():",unshiftArr.unshift(4,5));//5  (数组的长度)

console.log(unshiftArr);//[4, 5, 1, 2, 3]  //数组已经发生了变化

6、push()：在数组的最后一位新增一个或多个数据，并且返回数组的长度，会改变原来的数组。

//6、push()()：在数组的最后一位新增一个或多个数据，并且返回数组的长度，会改变原来的数组。
let pushArr = new Array(1,2,3);
console.log("pushArr.push():",pushArr.push(4,5)); //pushArr.push(): 5 (数组的长度)

console.log("pushArr:",pushArr); //[1, 2, 3, 4, 5]

7、reverse()：将数组的数据进行反转，并且返回反转后的数组，会改变原数组。

//7、reverse()()：将数组的数据进行反转，并且返回反转后的数组，会改变原数组。
let reverseArr = new Array(1,[1,2,3],2,3,{name:"爱钱的大傻憨"});
console.log("reverseArr:",reverseArr);//reverseArr: (5) [1, Array(3), 2, 3, {…}]
console.log("reverseArr.reverse():",reverseArr.reverse(4,5)); //[{…}, 3, 2, Array(3), 1]

console.log("reverseArr:",reverseArr); // [{…}, 3, 2, Array(3), 1]

8、sort()：对数组内的数据进行排序(默认为升序)，并且返回排过序的新数组，会改变原来的数组。

//8、sort()：对数组内的数据进行排序(默认为升序)，并且返回排过序的新数组，会改变原来的数组。
let sortArr = new Array(1,100,3);
console.log("sortArr:",sortArr);//
console.log("sortArr.reverse():",sortArr.sort()); // [1, 2, 3] 默认是顺序排序

console.log("sortArr:",sortArr); // [1, 2, 3]  默认是顺序排序

sortArr = [100,500,300,400];
sortArr.sort(function(num1,num2){
    return num1 - num2;
})

console.log("sortArr:",sortArr); // sortArr: (4) [100, 300, 400, 500] 默认是顺序排序

sortArr.sort(function(num1,num2){
    return num2 - num1; //倒序排列
})

console.log("sortArr:",sortArr); // sortArr: (4) [500, 400, 300, 100] 倒序排列

9、slice()：截取指定位置的数组，并且返回截取的数组，不会改变原数组。

参数：slice(startIndex, endIndex)

注意：可从已有的数组中返回选定的元素。该方法接收两个参数slice(start,end)，strat为必选，表示从第几位开始；end为可选，表示到第几位结束(不包含end位)，省略表示到最后一位；start和end都可以为负数，负数时表示从最后一位开始算起，如-1表示最后一位。

在实际的开发中，最好不要使用负数做为参数。

//9、slice()：截取指定位置的数组，并且返回截取的数组，不会改变原数组。
let sliceArr = new Array(1,100,3);
console.log("sliceArr:",sliceArr);//sliceArr: (3) [1, 100, 3]
console.log("sliceArr.slice():",sliceArr.slice(0,2)); // sliceArr.slice(): (2) [1, 100]

console.log("sliceArr:",sliceArr); // sliceArr: (3) [1, 100, 3]

10、splice()：向数组中添加，或从数组删除，或替换数组中的元素，然后返回被删除/替换的元素。

参数：splice(start,num,data1,data2,...); 所有参数全部可选。

//10、splice()：向数组中添加，或从数组删除，或替换数组中的元素，然后返回被删除/替换的元素。
let spliceArr = new Array(1,100,3);
console.log("spliceArr:",spliceArr);//spliceArr: (3) [1, 100, 3]
console.log("spliceArr.splice():",spliceArr.splice(0,2,"a")); // spliceArr.splice(): (2) [1, 100]

console.log("spliceArr:",spliceArr); // spliceArr: (2) ["a", 3]

11、valueOf()：返回数组的原始值（一般情况下其实就是数组自身）。

//11、valueOf()：返回数组的原始值（一般情况下其实就是数组自身）。
let valueOfArr = new Array(1,100,3);
console.log("valueOfArr:",valueOfArr);//valueOfArr: (3) [1, 100, 3]
console.log("valueOfArr.valueOf():",valueOfArr.valueOf()); // valueOfArr: (3) [1, 100, 3]

console.log("valueOfArr===valueOfArr.valueOf():",valueOfArr===valueOfArr.valueOf()); //valueOfArr===valueOfArr.valueOf(): true

12、indexOf()：根据指定的数据，从左向右，查询在数组中出现的位置，如果不存在指定的数据，返回-1，找到了指定的数据返回该数据的索引。不会更改数组结构。

参数：indexOf(value, start);value为要查询的数据；start为可选，表示开始查询的位置，当start为负数时，从数组的尾部向前数；如果查询不到value的存在，则方法返回-1

注意：如果找到该数据，立即返回该数据的索引，不再往后继续查找。在开发过程中最好不要设置start值。

//12、IndexOf()：根据指定的数据，从左向右，查询在数组中出现的位置，如果不存在指定的数据，返回-1，找到了指定的数据返回该数据的索引。
let indexOfArr = new Array(1,100,3);
console.log("indexOfArr:",indexOfArr);//indexOfArr: (3) [1, 100, 3]
console.log("indexOfArr.IndexOf():",indexOfArr.indexOf(100)); // indexOfArr.IndexOf(): 1

13、lastIndexOf()：根据指定的数据，从左向右，查询在数组中最后出现的位置，如果不存在指定的数据，返回-1。不会更改数组结构。

//13、lastIndexOf()：根据指定的数据，从左向右，查询在数组中最后出现的位置，如果不存在指定的数据，返回-1。不会更改数组结构。
let lastIndexOfArr = new Array(1,100,3,100,100,200);
console.log("lastIndexOfArr:",lastIndexOfArr);//lastIndexOfArr: (6) [1, 100, 3, 100, 100, 200]
console.log("lastIndexOfArr.lastIndexOf():",lastIndexOfArr.lastIndexOf(100)); // lastIndexOfArr.lastIndexOf(): 4

14、forEach()：数组迭代器，循环遍历数组。此方法最好是在数组中的元素结构一致的时候使用。不会更改数组结构。

//14、forEach()：数组迭代器，循环遍历数组。
let forEachArr = new Array(1,100,3,100,100,200);
console.log("forEachArr:",forEachArr);//forEachArr: (6) [1, 100, 3, 100, 100, 200]
forEachArr.forEach(function(item,index){
    console.log("index：",index,"item：",item);
})

15、map()：数组迭代器，循环遍历数组。此方法最好是在数组中的元素结构一致的时候使用，与forEach一样的功能。不会更改数组结构。

//15、map()：数组迭代器，循环遍历数组。
let mapArr = new Array(1,100,3,100,100,200);
console.log("mapArr:",mapArr);//forEachArr: (6) [1, 100, 3, 100, 100, 200]
mapArr.map(function(item,index){
    console.log("index：",index,"item：",item);
})

16、filter()：数组过滤，依过滤回调函数逻辑，返回满足要求的新数组。不会更改数组结构。

//16、filter()：数组过滤，依过滤回调函数逻辑，返回满足要求的新数组。
let filterArr = new Array(1,100,3,100,100,200);
console.log("filterArr:",filterArr);//forEachArr: (6) [1, 100, 3, 100, 100, 200]
let filterResultArr = filterArr.filter(function(item,index){
    return item > 100;
})
console.log("filterResultArr:",filterResultArr);//filterResultArr: [200]
console.log("filterArr:",filterArr);//filterArr: (6) [1, 100, 3, 100, 100, 200]

17、every()：判断数组中每一项是否都满足条件，只有所有项都满足条件，才会返回true。不会更改数组结构。

//17、every()：判断数组中每一项是否都满足条件，只有所有项都满足条件，才会返回true。
let everyArr = new Array(1,100,3,100,100,200);
console.log("everyArr:",everyArr);//everyArr: (6) [1, 100, 3, 100, 100, 200]
let everyResult = everyArr.every(function(item){
    return item > 50;
})
console.log("everyResult:",everyResult);//everyResult: false
console.log("everyArr:",everyArr);//everyArr: (6) [1, 100, 3, 100, 100, 200]

let everyResult2 = everyArr.every(function(item){
    return item > 0;
})

console.log("everyResult2:",everyResult2);//everyResult2: true

18、some()：判断数组中是否有一项符合要求，如果有返回true，否则返回false。不会更改数组结构。

//18、some()：判断数组中是否有一项符合要求，如果有返回true，否则返回false。不会更改数组结构。
let someArr = new Array(1,100,3,100,100,200);
console.log("someArr:",someArr);//someArr: (6) [1, 100, 3, 100, 100, 200]
let someResult = someArr.some(function(item){
    return item > 50;
})
console.log("someResult:",someResult);//someResult: true
console.log("someArr:",someArr); //someArr: (6) [1, 100, 3, 100, 100, 200]

let someResult2 = everyArr.every(function(item){
    return item > 300;
})

console.log("someResult2:",someResult2);//someResult2: false

19、reduce()：从数组的第一项开始，逐个遍历到最后，迭代数组的所有项，然后构建一个最终返回的值。

参数：reduce()接收一个或两个参数：第一个是回调函数，表示在数组的每一项上调用的函数；第二个参数（可选的）作为归并的初始值，被回调函数第一次执行时的第一个参数接收。 reduce(callback,initial);callback默认有四个参数，分别为prev，now，index，self。 callback返回的任何值都会作为下一次执行的第一个参数。 如果initial参数被省略，那么第一次迭代发生在数组的第二项上，因此callback的第一个参数是数组的第一项，第二个参数就是数组的第二项。

 //19、reduce()：从数组的第一项开始，逐个遍历到最后，迭代数组的所有项，然后构建一个最终返回的值。
let reduceArr = new Array(1,100,3,100,100,200);
console.log("reduceArr:",reduceArr);//reduceArr: (6) [1, 100, 3, 100, 100, 200]
reduceArr.reduce(function(prev,now,index,self){
    console.log(prev + "--" + now + "--" + index )
})

let sum = reduceArr.reduce(function(prev,now,index,self){
    return prev + now;
})
console.log("sum:",sum);//sum: 504

20、reduceRight()：从数组的最后一项开始，逐个遍历到最前，迭代数组的所有项，然后构建一个最终返回的值。

//20、reduceRight()：从数组的最后一项开始，逐个遍历到最前，迭代数组的所有项，然后构建一个最终返回的值。
let reduceRightArr = new Array(1,100,3,100,100,200);
console.log("reduceRightArr:",reduceRightArr);//reduceRightArr: (6) [1, 100, 3, 100, 100, 200]
reduceRightArr.reduceRight(function(prev,now,index,self){
    console.log(prev + "--" + now + "--" + index )
})

let reduceRightSum = reduceRightArr.reduce(function(prev,now,index,self){
    return prev + now;
})
console.log("reduceRightSum:",reduceRightSum);//reduceRightSum: 504

21、toString()：将数组转换成字符串。

//21、toString()：将数组转换成字符串。
let toStringArr = new Array({name:"爱钱的大傻憨"},1,2,"a","b");
let strResult = toStringArr.toString();
console.log("strResult:",strResult);//strResult: [object Object],1,2,a,b

好了，数组的方法介绍完成了，总结一下：

1、修改了数组结构的方法有：

unshift()、push()、shift()、pop()、sort()、reverse()、splice()

2、比较容易错的方法有：

splice()、slice()

该文章参照了：https://www.cnblogs.com/jiuxia/p/11509616.html

晚安