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