前言
说到数组的常用方法，主要归纳为增、删、改、查、排序、迭代等，需要注意使用这些方法对原数组是否产生影响，以及是否有返回值。在算法学习时，数组的操作方法尤其重要，我就从这六个方面总结数组的常用方法，帮助大家学习。
增
对数组增加操作的方法主要有下面四种，前三种对数组产生影响，第四种不会对数组产生影响
- push()
- unshift()
- splice()
- concat()
1> push()
可以接收任意数量的参数，并将他们从数组的尾部推入数组，对原数组产生影响，返回添加后的数组长度
let arr = ['zero']
const len = arr.push('one','two')
console.log(len) // 3
console.log(arr) // ['zero','one','two']
2> unshift()
可以接收任意数量的参数，并将他们从数组的头部添加入数组，对原数组产生影响，返回添加后的数组长度
let arr = ['zero']
const len = arr.unshift('one','two')
console.log(len); // 3
console.log(arr); //[ 'one', 'two', 'zero' ]
3> splice()
可以接收三个参数，第一个参数表示在第几位开始添加，第二个参数只有是 0 才表示添加，之后的参数都是需要添加的元素，影响原数组，返回一个空数组
let arr = ['zero','one','two']
const res = arr.splice(1,0,'three','four') // 表示从下标 1 开始添加 'three','four' 两个元素
console.log(res); // []
console.log(arr); // [ 'zero', 'three', 'four', 'one', 'two' ]
4> cancat()
将原数组和参数合并添加到一个新的数组，返回这个新的数组，对原数组不产生影响
*注：若原数组和参数出现多维数组，合并时只会解析出最外层数组的元素添加到新数组
let arr = ['zero',['one','two']]
const newarr = arr.concat('three',['four',['five','six']],'seven');
console.log(newarr); // []
console.log(arr); // ['zero',[ 'one', 'two' ],'three','four',[ 'five', 'six' ],'seven']
删
对数组进行删除操作也有四种，前三种会影响原数组，第四种不影响原数组
- pop()
- shift()
- splice()
- slice()
1> pop()
删除数组的最后一项，同时减少数组的 length 值，返回被删除的项，影响原数组
let arr = ['zero','one','two']
const item = arr.pop()
console.log(item); // two
console.log(arr,arr.length); // [ 'zero','one' ] 2
2> shift()
删除数组的第一项，同时减少数组的 length 值，返回被删除的项，影响原数组
let arr = ['zero','one','two']
const item = arr.shift()
console.log(item); // zero
console.log(arr,arr.length); // [ 'one', 'two' ] 2
3> splice()
可以接收两个参数，第一个参数表示从第几位开始删除，第二个参数表示删除元素的数量，返回包含删除元素的数组，影响原数组
let arr = ['zero','one','two']
const res = arr.splice(0,2)
console.log(res); // [ 'zero', 'one' ]
console.log(arr); // [ 'two' ]
4> slice()
也叫切片方法，可以接收两个参数，第一个参数表示从第几位开始切片，第二个参数表示切到第几位（不包括本位置），返回包含切割出来的元素的数组，不影响原数组
*注：当只有一位参数时，表示从该位置开始切片到数组的最后一位
let arr = ['zero','one','two','three']
const res1 = arr.slice(1)
const res2 = arr.slice(1,3)
console.log(res1); // [ 'one', 'two', 'three' ]
console.log(res2); // [ 'one', 'two' ]
console.log(arr); // [ 'zero', 'one', 'two', 'three' ]
改
如果要改变数组中的某个元素，我们通常可以直接通过下标修改该下标对应的值，但是在改变连续下标的值时，我们就可以用下面这个方法直接实现
splice()
使用splice()，改变连续几个值时，可以接收多个参数，第一个参数表示想要连续修改的第一个下标，第二个参数表示想要连续修改元素的数量，之后的参数表示想要修改后的连续的元素，返回的是包含想要修改的原数组的连续元素的新数组，影响原数组。其原理就是，先利用splice()删除从某个下标后的几个元素，再从这个下标开始添加元素，即结合了前两种splice()方法的使用
查
对数组进行查询的常用方法有三种，是查询，所以对原数组都不产生影响，但是返回的值有所不同
- indexOf()
- lastIndexOf()
- includes()
1> indexOf()
查找指定元素在数组中的下标（索引），返回找到的该元素的下标，若不存在则返回-1
let arr = ['zero','one','two','three']
const res = arr.indexOf('two')
console.log(res); // 2
console.log(arr); // [ 'zero', 'one', 'two', 'three' ]
2> lastIndexOf()
从数组尾部开始查找指定元素，返回找到的该元素的下标，若不存在则返回-1，返回和indexOf()一样
3> includes()
查找数组中是否存在指定元素，返回一个布尔值，若存在就返回true,若不存在则返回false
let arr = ['zero','one','two','three']
const res = arr.includes('two')
console.log(res); // true
console.log(arr); // [ 'zero', 'one', 'two', 'three' ]
排序
常用的对数组进行排序的方法有两种，都对数组产生影响，返回排序后的原数组
- sort()
- reverse()
1> sort()
对数组中的元素进行排序，默认按照字母顺序和数字从小到大排序。当数组中只有数字时，可以接收一个回调函数控制数字从大到小或从小到大排序。当数组中同时出现数字和字符串，那么数字排在字符串前面，且按照默认规则排序，此时也不能接收回调函数。
let arr1 = ['zero','one','two','2','1','three','4','3']
let arr2 = ['2','1','4','3']
let arr3 = ['2','1','4','3']
let arr4 = ['zero','one','two','three']
const res1 = arr1.sort()
console.log(res1); // ['1', '2', '3', '4', 'one', 'three','two', 'zero']
const res2 = arr2.sort()
console.log(res2); // [ '1', '2', '3', '4' ]
const res3 = arr3.sort((a,b) => b - a) //b-a即从大到小，a-b即从小到大
console.log(res3); // [ '4', '3', '2', '1' ]
const res4 = arr4.sort()
console.log(res4); // [ 'one', 'three', 'two', 'zero' ]
2> reverse()
颠倒原数组中元素的顺序
let arr = ['zero', 'one', 'three', 'two']
let res = arr.reverse()
console.log(res); //[ 'two', 'three', 'one', 'zero' ]
迭代
迭代也就是我们常说的遍历循环，迭代的常用方法有四种
- forEach()
- map()
- filter()
- reduce()
1> forEach()
对数组中的每个元素执行提供的回调函数，回调函数接收三个参数，分别是数组每一项和该项下标，以及数组本身，也可以只接收第一个参数，没有返回值或者说为undefined，不影响原数组
let arr = [2,1,4,3]
arr.forEach((item,index) => {
console.log(item + 1,index);
})
结果：
2> map()
创建一个新的数组，包含对原数组中每个元素进行操作后的结果，回调函数接收三个参数，分别是数组每一项和该项下标，以及数组本身，也可以只接收第一个参数，返回这个新的数组，不影响原数组
let arr = [2,1,4,3]
let newArr = arr.map((item,index,arr) => {
return item + index
})
console.log(newArr); //[ 2, 2, 6, 6 ]
console.log(arr); //[ 2, 1, 4, 3 ]
3> filter()
创建一个新的数组，包含对原数组中符合条件的所有元素，回调函数接收三个参数，分别是数组每一项和该项下标，以及数组本身，也可以只接收第一个参数，返回这个新的数组，不影响原数组
let arr = [2,1,4,3]
let newArr = arr.filter((item) => {
return item > 2
})
console.log(newArr); //[ 4, 3 ]
console.log(arr); //[ 2, 1, 4, 3 ]
4> reduce()
将数组中的元素进行累积处理，可以接收两个参数，第一个参数是回调函数，第二个参数是累积处理的初始值。回调函数接收四个参数，第一个参数是累积处理的上一个结果，之后分别是数组每一项和该项下标，以及数组本身，返回累积处理的结果，不影响原数组
let arr = [2,1,4,3]
let res = arr.reduce((pre,item,index) => {
return pre + item
},0)
console.log(res); //10
console.log(arr); //[ 2, 1, 4, 3 ]
join()
join()也是一个数组经常使用的方法：指定一个分隔符，将数组的每个元素，用分隔符连接起来成为一个字符串，分隔符默认为逗号(‘,’)，也可以自主设置，返回这个连接起来的字符串，不影响原数组
let arr = [2,1,4,3]
let res1 = arr.join()
let res2 = arr.join('-')
console.log(arr); //[ 2, 1, 4, 3 ]
console.log(res1); //2,1,4,3
console.log(res2); //2-1-4-3
split()
split()是一个用在字符串的方法，它和join()相反，指定一个分隔符将字符串分开成一个数组的各个元素，返回这个数组，对原字符串不产生影响
let str = '2-1-4-3'
let res = str.split('-')
console.log(res); //[ '2', '1', '4', '3' ]
console.log(str); //2-1-4-3
总结
以上就是我总结的数组比较常用的方法，希望对大家的学习有所帮助，但是数组可以使用的方法还有很多，比如find(),返回数组中满足条件的第一个元素的值，等等，这些方法都可以在mdn上查询和学习，它们在我们开发和学习过程中都可能使用到
