JS数组的常用方法 - 摘录收集1. 循环遍历：forEach forEach 用于循环遍历数组，是最常用的方法之一，它

1. 循环遍历：forEach

forEach 用于循环遍历数组，是最常用的方法之一，它提供一个回调函数，可以用来处理数组的每一个元素，默认没有返回值。回调函数的第一个参数是数组的每一项，第二个参数是数组中每一项的下标。

var arr = [1,2,3,4,5,6]
arr.forEach((item,index) => {
    console.log(item,index)
})

2. 其实 map 也可以做到

map 方法返回一个新数组，不会对空数组进行检测、不会改变原数组，按照原始数组元素顺序依次处理元素

let person = [{
    name:'张三',
    age:18,
    sex:1
},{
    name:'李四',
    age:20,
    sex:1
},{
    name:'王菲',
    age:25,
    sex:0
}]
let newPerson = person.map(item => {
    return {
        name: item.name,
        sex: item.sex
    }
})
console.log(newPerson) 
//  [{
//    name:'张三', 
//    sex:1
// },{
//    name:'李四', 
//    sex:1
// },{
//    name:'王菲', 
//    sex:0
// }]

3. filter 的同时当然也是一个在遍历的过程 filter：过滤数组

filter 返回值是一个新的数组
filter 可以直接 return 筛选条件

var arr = [10,20,30]
let newArr = arr.filter((item,index,array) => {
    return item >= 20
})
console.log(newArr)

4. concat：拼接数组

用来拼接数组并且会返回一个新数组，该方法不会改变原数组。

var arr1 = [1,2,3]
var arr2 = [4,5,6]
var arr3 = arr1.concat(arr2)
console.log(arr3) // 1,2,3,4,5,6

5. every，一个容易和 some 搞混的方法

every 遍历数组，一般用于判断数组中是否有满足条件的数组元素，所有元素遍历后都满足条件则返回 true ，只要有一项不满足则返回 false

let arr = [1,2,3,4,5,6]
let result1 = arr.every(item => item > 0)
console.log(result1) // true
let result2 = arr.every(item => item > 1)
console.log(result2) // false

6. some，一个容易和 every 搞混的方法

some 和 every 方法非常类似，在遍历所有元素后，只要有一项元素满足条件则返回 true，全部不满足则返回 false

let arr = [1,2,3,4,5,6]
let result1 = arr.some(item => item > 2)
let result2 = arr.some(item => item < 0)
console.log(result1,result2) // true false

7. 再来个高级的用法 reduce：数组求和

reduce 方法可以做的事情特别多，遍历循环能做的它都可以做，比如：数组求和、数组求积、数组中元素出现的次数、数组去重等等

语法：

arr.reduce(function(prev,cur,index,arr){
    ...
},init)

参数：

prev 必需：累计器累计回调的返回值，表示上一次调用回调时的返回值，或者初始值init
cur 必需：表示当前正在处理的数组元素
index 可选：表示当前正在处理的数组元素的索引，若提供了init值，则其实索引为0，否则为1
arr 可选：表示原数组
init 可选：表示初始值

// 举一个简单常用的求和栗子
var arr = [1,2,3,4,5]
let sum = arr.reduce((sum,val)=> sum + val,0)
console.log(sum) // 15

8. 容易混淆的方法 find 和 findIndex：查找数组中第一个满足条件的属性并

find 找到第一个满足条件的值
findIndex 方法返回的是第一个满足条件元素的下标

let arr = [25,35,12,8,40,12,72,86]
let value1 = arr.find(item => {
    return item > 50
})
let value2 = arr.findIndex(item => {
    return item > 50
})
console.log(value1) // 72 找到值
console.log(value2) // 6 找到下标

9. 很多人都不知道区别的 substring 和 substr：截取字符串

相同点：只传一个参数两者作用相同

let arr = '123456789'
console.log(arr.substr(5)) // '6789'
console.log(arr.substring(5)) // '6789'

不同点：传两个参数
substr(startIndex,length) 第二个参数是从起始点开始计算所截取的字符串的长度
substring(starIndex,endIndex) 第二个参数是截取的字符串最终下标

let arr = '123456789'
console.log(arr.substr(2,5)) // '34567'
console.log(arr.substring(2,5)) // '345'

10. 一个常用方法 splice：删除数组中的属性

splice 方法可以删除从 index 处开始的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素，该方法会直接对数组进行修改

let arr = ['a','b','c','d','e','f','g']
arr.splice(0,1,'aaa')
console.log(arr) // ['aaa','b','c','d','e','f','g']

11. 数组嘎巴机 slice：截取元素

slice 会返回一个新的数组，返回选定的元素，不会修改原数组

let arr = ['a','b','c','d','e','f','g']
let newArr = arr.slice(0,2) 
console.log(arr) //  ['a','b','c','d','e','f','g']
console.log(newArr) // 返回的是被截取的元素 ['a','b']

12. join：把数组中所有元素放入一个字符串

把数组中所有元素放入一个字符串，元素之间通过指定的分隔符进行分割

let arr = ['H','E','L','L','O']
let str = arr.join('')
console.log(str) // HELLO

13. push：从数组末尾追加

push 从数组末尾添加项，返回值是数组的长度，会改变原数组

let arr = [1,2,3,4,5,6]
console.log(arr.push(7,8)) // 8 arr 数组的长度
console.log(arr) // [1,2,3,4,5,6,7,8]

14. unshift：从数组前面添加

unshift 从数组前面添加，返回值是数组的长度，会改变原数组

let arr = [1,2,3,4,5,6]
console.log(arr.unshift(7,8)) //  8 arr 数组的长度
console.log(arr) // [7,8,1,2,3,4,5,6]

15. pop：从数组末尾删除

pop 从数组末尾删除，返回值是删除的元素，会改变原数组

let arr = [1,2,3,4,5,6]
console.log(arr.pop()) // 6 删除的值
console.log(arr) // [1,2,3,4,5]

16. reverse：反转数组

reverse 作用是将数组翻转

let arr = [1,2,3,4,5,6]
console.log(arr.reverse()) // [5,4,3,2,1]

17. sort：数组排序

sort 方法按照 Unicode code 位置排序，默认升序

let str = ['e','z','o','k','v']
let num = [5,8,1,3,0,9]
console.log(str.sort()) // ["e", "k", "o", "v", "z"]
console.log(num.sort()) // [0, 1, 3, 5, 8, 9]

18. indexOf 和 lastIndexOf：查找

indexOf 和 lastIndexOf 都接受两个参数L查找的值、查找的起始位置，不存在时返回 -1；存在返回下标位置
indexOf是从前往后查找，lastIndexOf是从后往前查找

let arr = [2,7,6,8,5,7,1]
// 传入一个参数
console.log(arr.indexOf(4)) // -1 不存在
console.log(arr.indexOf(7)) // 1 找到的第一个元素的下标位置
// 传入两个参数
console.log(arr.indexOf(7,3)) // 5