以下所有方法来源于网络，统计归纳所得·.....自测没有问题。
若有任何不对的或者有补充的，可以评论区提出哈~
// 1、push()（末尾添加元素）
// 作用：向数组的末尾添加n个元素
// 参数：参数时新增的元素，可以串多个
// 返回值：新数组的数组成员的个数
// 原数组发生变化
let arr = [1,2,3,4,5];
console.log(arr.push(5)); // 6
console.log(arr); // [1,2,3,4,5,5]
// 2、pop()（删除最后一项）
// 作用：删除数组的最后一项
// 参数：不需要传参数
// 返回值：被删除的那一项
// 原数组发生改变
let arr = [1,2,3,4,5];
console.log(arr.pop());// 5
console.log(arr); //[1,2,3,4]
// 3、unshift()（开始位置添加一项）
// 作用：向数组的开始位置添加n个元素
// 参数：参数是新增的元素，可以是多个
// 返回值：新数组的长度
// 原数组发生改变
let arr = [1,2,3,4,5]
console.log(arr.unshift(2)) // 6
console.log(arr) //[2,1,2,3,4,5]
/** 4、shift()（开始位置删除一项）作用：删除数组的第一项，
参数：不需要传参数
返回值：被删除的那一项
原数组发生改变*/
let arr = [1,2,3,4,5] console.log(arr.shift()) // 1
console.log(arr) // [2,3,4,5]
/** 5、splice()（删除、添加、修改元素）
作用：删除元素，并向数组添加新元素
参数：splice(m,n);从索引m开始，删除n项;splice(m);
从索引m开始删除到末尾splice(m,n,x,...);从索引m开始删除n项，
并将x添加到原来位置；添加项可以是多个（如果删除项为0个，那么添加是
在m元素前面）
返回值：是个数组，数组中是被删除的项
原数组发生变化*/
let arr = [1,2,3,4,5]
console.log(arr.splice(2,2)) //[3,4]
console.log(arr) // [1,2,5]
/** 6、indexOf()（从左向右查询）不兼容IE低版本浏览器：IE6,7,8
作用：检测数组中是否存在某个元素参数：
被查询的元素（m,n）从索引n开始，m第一次出现的索引位置
返回值：返回数组中第一次匹配到的元素的索引,如果数组中没有匹配项返回-1
原数组不发生变化*/
let arr = [1,2,3,4,5,2]
let arr1 = arr.indexOf(2)
console.log(arr1) // 1
let arr2 = arr.indexOf(9)
console.log(arr2) // -1
/** 7、lastIndexOf()（从左到右查询）不兼容IE低版本浏览器：IE6,7,8
作用：检测数组中是否存在某个元素参数：被检测的元素
返回值：返回数组中最后一次匹配到的元素的索引,如果数组中没有匹配项返回-1
原数组不发生变化*/
let arr = [1,2,3,4,5,2]
let arr1 = arr.lastIndexOf(2)
console.log(arr1) // 5
let arr2 = arr.lastIndexOf(9)
console.log(arr2) // -1
/** 8、slice()（截取）作用：按照起始和结束位置的索引截取数组
参数：有两个参数slice(m,n)：从索引m开始，截取到索引n；
（包前不包后）有一个参数slice(m)：从索引m开始截取到末尾；
没有参数：数组的克隆；(slice(0)也是数组的克隆)；
以上情况参数都支持负数，负数情况会默认被加上数组的长度，处理成正数.
返回值：截取的数组
原数组不发生变化*/
let arr = [1,2,3,4,5]
console.log(arr.slice(1,3)) // [2,3]
console.log(arr) // [1,2,3,4,5]
/** 9、sort()（排序）
作用：对数组的元素进行排序参数：
没有参数
sort()：只能排序数组成员项是相同位数的数字
sort(function(a,b){return a-b})：从小到大排序sort(function(a,b){return b-a})：
从大到小排序
返回值：排序之后的数组原数组发生变化*/
var ary=[1,3,10,50,2,120,30];
ary.sort(
function fn(a,b){
return a-b; //这里是一个回调函数，把函数当作实参传给sort的方法
})
console.log(ary);
/** 10、reverse()（倒序）
作用：使数组中元素倒序
参数：不需要参数
返回值：成员倒序的数组
原数组发生变化
*/
let arr = [1,2,3,4,5]
console.log(arr.reverse()) // [5,4,3,2,1]
console.log(arr) // [5,4,3,2,1]
/** 11、concat()（拼接数组）
作用：拼接两个或多个数组
参数： 不传参数：数组的克隆 传参数：将传入的参数拼接到数组中、可以传多个
返回值：拼接之后的新数组
原数组不发生变化
*/
let arr = [1,2,3,4,5]
console.log(arr.concat([1,2])) // [1,2,3,4,5,1,2]
console.log(arr) // [1,2,3,4,5]
/** 12、join()（数组拼接成字符串）
作用：将数组的成员项通过制定字符拼接成字符串参数：
不传参数：会默认按照逗号拼接传参数：会按照参数字符拼接
返回值：拼接之后的字符串原数组不发生变化*/
var arr = [1,2]
var result = arr.join();
console.log(result); //'1,2'
//13、map()（映射）
// 作用：方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值；
// 参数：参数是一个回调函数；数组有几项，回调函数就执行多少次；在回调函数中处理数组中的每项；
// 返回值：映射的新数组；
// 原数组不发生变化；
// 示例：
var ary = [1,2,3];
ary.map(function(item,index,arr){});
// item是遍历数组的每一项
// index是遍历数组的索引
// arr就是原数组
let ary = [1,2,3,4,5]
ary.map( (item,index,arr)=>{
item= item* 2
console.log(`item:${item} index:${index} arr:${arr}`)
})
console.log(ary)
//14、forEach()（遍历数组）
// 作用：遍历数组；
// 参数：参数是一个回调函数；数组有几项，回调函数就执行多少次；
// 返回值：没有返回值；undefined；
// 原数组不发生变化；
// 示例：
var ary = [1,2,3];
ary.forEach(function(item,index,arr){});
// item是遍历数组的每一项
// index是遍历数组的索引
// arr就是原数组
let ary = [1,2,3,4,5]
ary.forEach( (item,index,arr)=>{
console.log(`item:${item} index:${index} arr:${arr}`)
})
// item:1 index:0 arr:1,2,3,4,5
// item:2 index:1 arr:1,2,3,4,5
// item:3 index:2 arr:1,2,3,4,5
// item:4 index:3 arr:1,2,3,4,5
// item:5 index:4 arr:1,2,3,4,5
let ary = [1,2,3,4,5]
ary.forEach( (item,index,arr)=>{
item= item* 2
console.log(`item:${item} index:${index} arr:${arr}`)
})
console.log(ary)
// item:2 index:0 arr:1,2,3,4,5
// item:4 index:1 arr:1,2,3,4,5
// item:6 index:2 arr:1,2,3,4,5
// item:8 index:3 arr:1,2,3,4,5
// item:10 index:4 arr:1,2,3,4,5
// [1, 2, 3, 4, 5]//
// ary.forEach()和ary.map()的区别
// 1、 ary.forEach()是和for循环一样，是代替for。
// ary.map()是修改数组其中的数据，并返回新的数据。
// 2、ary.forEach() 没有return ary.map() 有return。
// 3、map有映射，forEach没有映射。
// 15、toString()（数组转字符串）
// 作用：数组转字符串；
// 参数：不需要参数；
// 返回值：一个字符串，由数组的每项组成，数组的每一项用逗号隔开；
// 原数组不发生变化；
let arr = [1, 2, 3, 4, 5];
let str = arr.toString();
console.log(str)// 1,2,3,4,5
// 16、find(查找)
// 从左到右依次进行查找，找到符合条件的那一项，直接返回，不再进行查找；
// 如果找不到，那么返回undefined； 返回true,说明就找到了；
// find会根据回调函数的返回值，判断是否要继续向右查找；
let arr = [12,3,45,6,78];
let a = arr.find((item,index)=>{
console.log(100);
//输出三次
return item>20;
})
console.log(a);//45
//17、 filter(过滤) 过滤; 原数组不发生改变；返回一个过滤后的新数组
let arr = [12,3,45,6,78];
let ary = arr.filter((item,index)=>{
// 根据当前函数的返回值是true来获取这一项；如果是false，
// 返回值中就没有这一项；
return item>30;
});
console.log(arr); // [12, 3, 45, 6, 78]
console.log(ary); // [45, 78]
//18、every 每一个都是true则返回true，如果有一个是false，那么直接返回false；只要找到false，直接结束，不再继续向下查找；返回值是布尔值
let arr = [12,3,45,6,78];
let e = arr.every((item,index)=>{
return item>13;
})
console.log(e);//false
//19、some 返回一个布尔值；只要有一个符合条件就返回true；
//找到true，就不再向右进行查找；
let arr = [12,3,45,6,78];
let a = arr.some((item,index)=>{
console.log(100);
return item>10;
})
console.log(a);//true
//20、includes 返回一个布尔值；如果有就返回true, 没有就返回false
let arr = [12,3,45,6,78];
console.log(arr.includes(45));//true
/** 21、reduce迭代数组的所有项，累加器，数组中的每个值（从左到右）合并，最终计算为一个值*/
let arr = [12,3,45,6,78];
let a = arr.reduce((prev,next)=>{
// prev : 第一次代表数组的第一项，以后都代表上一次回调函数的返回值；
console.log(prev,next);
//第一次输出：112 3，
//第二次输出：115 45，
//第三次输出：160 6，
//第四次输出：166 78
return prev +next;
});
console.log(a);//244
// reduce回调函数后面可以传一个参数
let arr = [12,3,45,6,78];
let a = arr.reduce((prev,next)=>{
console.log(prev,next);
//第一次输出：100 12，
//第二次输出：100 3，
//第三次输出：100 45，
//第四次输出：100 6，
//第五次输出：100 78
return 100;
}, 100);
console.log(a);//100
/** 22、flat
作用：用于将嵌套的数组“拉平”，变成一维数组
返回值：返回一个新数组;
参数：有参数，默认是一层，如果有多层，就需要传层数；
如果不管有多少层嵌套，都要转成一维数组，可以用Infinity关键字作为参数。
原数组不改变*/
// 第一种
let arr = [12,3,[1,2,3],6,78];
let ary=arr.flat()
console.log(ary);//[12,3,[1,2,3],6,78]
console.log(arr)// [12, 3, 1, 2, 3, 6, 78]//
// 第二种
var arr = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10];
consolelog(arr.flat(Infinity))
//[1, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12, 13, 14, 10]