---
原文链接 https://juejin.cn/post/7089973191484899359
theme: channing-cyan
highlight: foundation
---
### 1. arr.push()
从后面添加元素，返回值为添加完后的数组的长度
```
let arr = [1,2,3,4,5]
console.log(arr.push(6)) // 6
console.log(arr) // [1,2,3,4,5,6]
```
### 2. arr.pop()
从后面删除元素，只能是一个，返回值是删除的元素
```
let arr = [1,2,3,4,5]
console.log(arr.pop()) // 5
console.log(arr) // [1,2,3,4]
```
### 3. arr.shift()
从前面删除元素，只能删除一个，返回值是删除的元素
```
let arr = [1,2,3,4,5]
console.log(arr.shift()) // 1
console.log(arr) // [2,3,4,5]
```
### 4. arr.unshift()
从前面添加元素, 返回值是添加完后的数组的长度
```
let arr = [1,2,3,4,5]
console.log(arr.unshift(2)) // 6
console.log(arr) // [2,1,2,3,4,5]
```
### 5. arr.splice()
splice方法可以用来对js的数组进行删除，添加，替换等操作。
```
Ⅰ. 删除功能，第一个参数为第一项位置，第二个参数为要删除几个
用法：array.splice(index,num)，返回值为删除内容，array为结果值。
let arr = [1,2,3,4,5]
console.log(arr.splice(2,2)) // [4,5]
console.log(arr) // [1,2,5]
Ⅱ. 插入功能，第一个参数（插入位置），第二个参数（0），第三个参数（插入项）
用法：array.splice(index,0,insertValue)，返回值为空数组，array值为最终结果值。
let arr = [1,2,3,4,5]
console.log(arr.splice(2,0,'insertValue')) // []
console.log(arr) // [1, 2, 'insertValue', 3, 4, 5]
Ⅲ. 替换功能，第一个参数（起始位置），第二个参数（删除的项数），第三个参数（插入任意数量的项）。
用法：array.splice(index,num,insertValue)，返回值为删除内容，array为结果值。
let arr = [1,2,3,4,5]
console.log(arr.splice(2,4,'insertValue')) // [3, 4]
console.log(arr) // [1, 2, 'insertValue', 5]
```
### 6. arr.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]
```
### 7. str.split()
将字符串转化为数组
```
let str = '123456'
console.log(str.split('')) // ["1", "2", "3", "4", "5", "6"]
```
### 8. arr.join()
将数组转化为字符串
```
let arr = [1,2,3,4,5]
console.log(arr.join('let arr = [1,2,3,4,5]
console.log(arr.join('')) // 12345
console.log(arr.join(',')) 指定分隔符 // 1,2,3,4,5
```
### 9. arr.sort()
将数组进行排序,返回值是排好的数组，默认是按照最左边的数字进行排序，不是按照数字大小排序的
```
let arr = [5,10,510,1,2,5,88]
console.log(arr.sort()) // [1, 10, 2, 5, 5, 510, 88]
let arr1 = arr.sort((a, b) =>a - b)
console.log(arr1) // [1, 2, 5, 5, 10, 88, 510]
let arr2 = arr.sort((a, b) =>b-a)
console.log(arr2) // [510, 88, 10, 5, 5, 2, 1]
```
### 10. arr.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. arr.slice(start,end)
分割索引值start到索引值end的数组，不包含end索引的值，返回值是分割出来的数组
```
let arr = [1,2,3,4,5]
console.log(arr.slice(1,4)) // [2,3,4]
console.log(arr) // [1,2,3,4,5]
```
### 12. arr.forEach(callback)
遍历数组,无return 即使有return，也不会返回任何值，并且会影响原来的数组
callback的参数
1. - value 当前索引的值
2. - index 索引
3. - array 原数组
```
let arr = ['a', 'b', 'c', 'd', 'e']
arr.forEach( (value,index,array)=>{
console.log(`value:${value} index:${index} array:${array}`)
})
// value:a index:0 array:a,b,c,d,e
// value:b index:1 array:a,b,c,d,e
// value:c index:2 array:a,b,c,d,e
// value:d index:3 array:a,b,c,d,e
// value:e index:4 array:a,b,c,d,e
let arr = ['a', 'b', 'c', 'd', 'e']
arr.forEach( (value,index,array)=>{
value = value + 2
console.log(`value:${value} index:${index} array:${array}`)
})
// value:a2 index:0 array:a,b,c,d,e
// value:b2 index:1 array:a,b,c,d,e
// value:c2 index:2 array:a,b,c,d,e
// value:d2 index:3 array:a,b,c,d,e
// value:e2 index:4 array:a,b,c,d,e
let arr = ['a', 'b', 'c', 'd', 'e']
let res = arr.forEach((item,index,arr)=>{
item = index;
arr[index] = item * 2;
return arr
})
console.log(arr); // [0,2,4,6,8]
console.log(res); // undefined
```
### 13. arr.map(callback)
-映射数组(遍历数组),有return 返回一个新数组
callback的参数
1. - value 当前索引的值
2. - index 索引
3. - array 原数组
```
let arr = [1,2,3,4,5]
arr.map( (value,index,array)=>{
value = value * 2
console.log(`value:${value} index:${index} array:${array}`)
})
console.log(arr)
//value:2 index:0 array:1,2,3,4,5
//value:4 index:1 array:1,2,3,4,5
//value:6 index:1 array:1,2,3,4,5
//value:8 index:0 array:1,2,3,4,5
//value:10 index:0 array:1,2,3,4,5
//[1, 2, 3, 4, 5]
var Newarr = [1,2,3,4,5];
var res = Newarr.map((item,index,arr)=>{
item = item * 3;
return item;
})
console.log(Newarr); // [1,2,3,4,5]
console.log(res); // [3,6,9,12,15]
```
- `PS：` arr.forEach()和arr.map()的区别
- arr.forEach()是和for循环一样，是代替for。
- arr.map()是修改数组其中的数据，并返回新的数据。
- arr.forEach() 没有return arr.map() 有return。
### 14. arr.filter(callback)
过滤数组，返回一个满足要求的数组
callback的参数
1. - value 当前索引的值
2. - index 索引
```
let arr = [1,2,3,4,5]
let Newarr = arr.filter( (value, index) => value < 3 )
console.log(Newarr) // [1, 2]
```
### 15. arr.every(callback)
依据判断条件，数组的元素是否全满足，若满足则返回ture
callback的参数
1. - value 当前索引的值
2. - index 索引
```
let arr = [1,2,3,4,5]
let arr1 = arr.every( (value, index) =>value<3)
console.log(arr1) // false
let arr2 = arr.every( (value, index) =>value<6)
console.log(arr2) // true
```
### 16. arr.some(callback)
依据判断条件，数组的元素是否有一个满足，若有一个满足则返回ture
callback的参数
1. - value 当前索引的值
2. - index 索引
```
let arr = [1,2,3,4,5]
let arr1 = arr.some( (value, index) =>value<3)
console.log(arr1) // true
let arr2 = arr.some( (value, index) =>value>6)
console.log(arr2) // false
```
### 17. arr.reduce(callback, initialValue)
reduce 为数组中的每一个元素依次执行回调函数，不包括数组中被删除或从未被赋值的元素，接受四个参数：初始值（或者上一次回调函数的返回值），当前元素值，当前索引，调用 reduce 的数组。
callback的参数
1. - previousValue （上一次调用回调返回的值，或者是提供的初始值（initialValue））
2. - currentValue （数组中当前被处理的元素）
3. - index （当前元素在数组中的索引）
4. - array （调用 reduce 的数组）
- initialValue: （作为第一次调用 callback 的第一个参数）
#### reduce的简单用法 (6个常用的方法)
##### *1. 数组求和丶求乘积*
```
var arr = [1, 2, 3, 4];
var sum = arr.reduce((x,y)=>x+y)
var mul = arr.reduce((x,y)=>x*y)
console.log( sum ); //求和，10
console.log( mul ); //求乘积，24
```
##### *2. 计算数组中每个元素出现的次数*
```
let names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];
let nameNum = names.reduce((pre,cur)=>{
if(cur in pre){
pre[cur]++
}else{
pre[cur] = 1
}
return pre
},{})
console.log(nameNum); //{Alice: 2, Bob: 1, Tiff: 1, Bruce: 1}
```
##### *3. 数组去重*
```
let arr = [1,2,3,4,4,1]
let newArr = arr.reduce((pre,cur)=>{
if(!pre.includes(cur)){
return pre.concat(cur)
}else{
return pre
}
},[])
console.log(newArr);// [1, 2, 3, 4]
```
##### *4. 将二维数组转化为一维*
```
let arr = [[0, 1], [2, 3], [4, 5]]
let newArr = arr.reduce((pre,cur)=>{
return pre.concat(cur)
},[])
console.log(newArr); // [0, 1, 2, 3, 4, 5]
```
##### *5. 将多维数组转化为一维*
```
let arr = [[0, 1], [2, 3], [4,[5,6,7]]]
const newArr = function(arr){
return arr.reduce((pre,cur)=>pre.concat(Array.isArray(cur)?newArr(cur):cur),[])
}
console.log(newArr(arr)); //[0, 1, 2, 3, 4, 5, 6, 7]
```
##### *6. 对象里的属性求和*
```
var result = [
{
subject: 'math',
score: 10
},
{
subject: 'chinese',
score: 20
},
{
subject: 'english',
score: 30
}
];
var sum = result.reduce(function(prev, cur) {
return cur.score + prev;
}, 0);
console.log(sum) //60
```
- `PS：` 总结
- reduce() 是数组的归并方法，与 forEach()、map()、filter()等迭代方法一样都会对数组每一项进行`遍历`，但是reduce() 可同时将前面数组项遍历产生的结果与当前遍历项进行运算，这一点是其他迭代方法无法企及的。
### 18. arr.indexOf()
查找某个元素的索引值，若有重复的，则返回第一个查到的索引值若不存在，则返回 -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
```
### 19. arr.lastIndexOf()
和arr.indexOf()的功能一样，不同的是从后往前查找
```
let arr = [1,2,3,4,5,2]
let arr1 = arr.lastIndexOf(1)
console.log(arr1) // 0
let arr2 = arr.lastIndexOf(9)
console.log(arr2) // -1
```
### 20. Array.from()
将伪数组变成数组，就是只要有length的就可以转成数组
```
let str = '12345'
console.log(Array.from(str)) // ["1", "2", "3", "4", "5"]
let obj = {0:'a',1:'b',length:2}
console.log(Array.from(obj)) // ["a", "b"]
let obj = {0:'a',1:'b',length:5}
console.log(Array.from(obj)) // ['a', 'b', undefined, undefined, undefined]
```
### 21. Array.of()
将一组值转换成数组，类似于声明数组
```
let str = '12345'
console.log(Array.of(str)) // ['12345']
// 等价于
console.log(new Array('12345')) // ['12345]
```
- `PS：` 总结
- 但是new Array()有缺点，就是参数问题引起的`重载`
```
console.log(new Array(2)) //[empty × 2] 是个空数组
console.log(Array.of(2)) // [2]
```
### 22. arr.copyWithin()
在当前数组内部，将制定位置的数组复制到其他位置，会覆盖原数组项，返回当前数组
- target -- 必选 索引从该位置开始替换数组项
- start -- 可选 索引从该位置开始读取数组项，默认为0.如果为负值，则从右往左读。
- end -- 可选 索引到该位置停止读取的数组项，默认是Array.length，如果是负值，表示倒数
```
let arr = [1,2,3,4,5,6,7]
let arr1 = arr.copyWithin(1)
console.log(arr1) // [1, 1, 2, 3, 4, 5, 6]
let arr2 = arr.copyWithin(1,2)
console.log(arr2) // [1, 3, 4, 5, 6, 7, 7]
let arr3 = arr.copyWithin(1,2,4)
console.log(arr3) // [1, 3, 4, 4, 5, 6, 7]
```
### 23. arr.find()
找到第一个符合条件的数组成员
```
let arr = [1,2,3,4,5,2,4]
let arr1 = arr.find((value, index, array) => value > 2)
console.log(arr1) // 3
```
### 24. arr.findIndex()
找到第一个符合条件的数组成员的索引值
```
let arr = [1,2,3,4,5]
let arr1 = arr.findIndex((value, index, array) => value > 3)
console.log(arr1) // 3
```
### 25. arr.fill(target, start, end)
使用给定的值，填充一个数组 `ps：`填充完后会改变原数组
- target -- 待填充的元素
- start -- 开始填充的位置-索引
- end -- 终止填充的位置-索引（不包括该位置)
```
let arr = [1,2,3,4,5]
let arr1 = arr.fill(5)
console.log(arr1) // [5, 5, 5, 5, 5]
console.log(arr) // [5, 5, 5, 5, 5]
let arr2 = arr.fill(5,2)
console.log(arr2)
let arr3 = arr.fill(5,1,3)
console.log(arr3)
```
### 26. arr.includes()
判断数中是否包含给定的值
```
let arr = [1,2,3,4,5]
let arr1 = arr.includes(2)
console.log(arr1) // ture
let arr2 = arr.includes(9)
console.log(arr2) // false
let arr3 = [1,2,3,NaN].includes(NaN)
console.log(arr3) // true
```
`ps：`与indexOf()的区别：
- indexOf()返回的是数值，而includes()返回的是布尔值
- indexOf() 不能判断NaN，返回为-1 ，includes()则可以判断
### 27. arr.keys()
遍历数组的键名
```
let arr = [1,2,3,4]
let arr1 = arr.keys()
for (let key of arr1) {
console.log(key); // 0,1,2,3
}
```
### 28. arr.values()
遍历数组键值
```
let arr = [1,2,3,4]
let arr1 = arr.values()
for (let val of arr1) {
console.log(val); // 1,2,3,4
}
```
### 29. arr.entries()
遍历数组的键名和键值
```
let arr = [1,2,3,4]
let arr1 = arr.entries()
for (let item of arr1) {
console.log(item); // [0,1] [1,2] [2,3] [3,4]
}
```
### 30. arr.flat()
flat() 方法会按照一个可指定的`深度`递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
```
let arr = [1,2,['a','b',['中','文',[1,2,3,[11,21,31]]]],3];
//扁平化数组，不传递参数的时候默认为一层
console.log( arr.flat( ) );
//[1, 2, 'a', 'b', ['中', '文',[1, 2, 3, [11, 21, 31]]], 3]
//设置扁平化的深度
console.log( arr.flat( 3 ) );
//[1, 2, 'a', 'b', '中', '文', 1, 2, 3, [11, 21, 31], 3]
//使用 Infinity，可展开任意深度的嵌套数组
console.log( arr.flat( Infinity ) );
//[1, 2, 'a', 'b', '中', '文', 1, 2, 3, 11, 21, 31, 3]
//当数组里面有空项的时候，会过滤掉空值
let arr1 = [1, , 2, [3]];
let reasut = arr1.flat()
console.log(reasut) // [1, 2, 3]
```
## 最后：
> 这些都是我复习整理出来的数组方法，若有不对的地方，请留言或者私信，一起讨论，一起进步。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
