js---Array对象的常用遍历方法

1.forEach(),遍历数组的每个元素

    let arrFor = ['muzi','digbig','muzidigbig','lucky']
    //forEach(),遍历数组的每个元素
    arrFor.forEach((item,index) => {
        console.log(`${index}---${item}`)
    })

2.map(参数为回调函数)函数，遍历数组每个元素，并回调操作，需要返回值，返回值组成新数组，原数组不变；

    let arr = [{id:1,name:'muzi'},{id:2,name:'digbig'},{id:3,name:'muzidigbig'},{id:4,name:'lucky'}]
    const arrMap = arr.map((item,index) => {
        return {
            id:item.id,
            name:item.name,
            sex:'男'
        }
    })
    console.log(arrMap)

3.filter(参数为回调函数)函数：过滤通过条件的元素组成一个新数组，原数组不变；

    let arr = [{id:1,name:'muzi'},{id:2,name:'digbig'},{id:3,name:'muzidigbig'},{id:4,name:'lucky'}]
    const arrFilter = arr.filter((item,index) => {
        return item.id >= 2;
    })
    console.log(arrFilter)

 

4.some(参数为回调函数)函数，遍历数组中是否有符合条件的函数，返回布尔值；

    let arr = [{id:1,name:'muzi'},{id:2,name:'digbig'},{id:3,name:'muzidigbig'},{id:4,name:'lucky'}]
    const arrSome = arr.some((item,index) => {
        return item.id === 5
    })
    console.log(arrSome)

5.every(参数为回调函数)函数，遍历数组是否每个元素都符合条件，返回布尔值；

    let arr = [{id:1,name:'muzi'},{id:2,name:'digbig'},{id:3,name:'muzidigbig'},{id:4,name:'lucky'}]
    const arrEvery = arr.every((item,index) => {
        return item.id >= 1
    })
    console.log(arrEvery)

6.find()函数，数组中的每个元素都执行这个回调函数；返回第一个满足条件的元素的值 之后的元素就不在调用；没有符合的返回undefined；并没有改变数组的原始值。

    let arr = [{id:1,name:'muzi'},{id:2,name:'digbig'},{id:3,name:'muzidigbig'},{id:4,name:'lucky'}]
    const arrFind = arr.find((item,index) => {
        return item.id === 1
    })
    console.log(arrFind)

7.reduce(),合并二维数组   更多详情

    var twoArr = [['mu','zi'],['dig','big'],['lucky','jiji']];
    var oneArr = twoArr.reduce(function(total,currentValue){
        // console.log(total)
        return total.concat(currentValue);
    },[])
    console.log(oneArr);//["mu", "zi", "dig", "big", "lucky", "jiji"]

8.includes()方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。该方法属于 ES7 ，但 Babel 转码器已经支持。

    [1, 2, 3].includes(2); // true
    [1, 2, 3].includes(4); // false
    [1, 2, NaN].includes(NaN); // true

该方法的第二个参数表示搜索的起始位置，默认为 0 。如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为 -4 ，但数组长度为 3 ），则会重置为从 0 开始。

    [1, 2, 3].includes(3, 3); // false
    [1, 2, 3].includes(3, -1); // true

9.indexOf()方法有两个缺点，一是不够语义化，它的含义是找到参数值的第一个出现位置，所以要去比较是否不等于 -1 ，表达起来不够直观。二是，它内部使用严格相当运算符（ === ）进行判断，这会导致对NaN的误判。

[NaN].indexOf(NaN)
// -1

includes()使用的是不一样的判断算法，就没有这个问题。
[NaN].includes(NaN)
// true