ES6的数组方法

• forEach(callback)
• map(callback)
• filter(callback)
• every(callback)
• some(callback)
• reduce(callback, initialValue)

arr.forEach 数组遍历，无法返回值，代替for循环。

        let arr = [1, 2, 3, 4];
        // value:当前项的值  index:当前项的索引值，array:原本的数组
        arr.forEach((value, index, array) => {
            value = value + 2
            console.log(`value:${value} index:${index} array:${array}`)
        });
        console.log("forEach-arr", arr);       // [1, 2, 3, 4]

arr.map 数组映射，有返回值，返回一个新的数组

        // 1
        let arr = [1, 2, 3, 4];
        // value:当前项的值  index:当前项的索引值，array:原本的数组
        let newArr = arr.map(function (value, index, array) {
            return value * 2;
        });
        console.log('map-arr:', arr);          // [1, 2, 3, 4]
        console.log('map-newArr:', newArr);    // [2, 4, 6, 8]
        
        // 2 对象数组
        let arr = [
            { id: 1, url: "a|b|c|d", title: "aaa" },
            { id: 2, url: "a", title: "bbb" },
            { id: 3, url: "a|b", title: "ccc" }
        ]
       // 2
        let newArr = arr.map((item, index, arr) => {
            return {
                id: item.id,
                url: item.url.split("|"),
                title: item.title
            }
        })
        console.log("arr", arr)
        console.log("new", newArr)
        // 2
        let b = []
        arr.forEach((item) => {
            item.url = item.url.split("|")
            b.push(item);
        });

arr.filter过滤数组(“筛选”函数)，返回一个符合要求的数组(只保留返回是true的元素)

        // 1
        let arr = [1, 2, 3, 4];
        let newArr = arr.filter(function (value, index, array) {
            return value > 2;
        });
        console.log('filter-arr:', arr);          // [1, 2, 3, 4]
        console.log('filter-newArr:', newArr);    // [3, 4]
        // 2-去除无效项
        let arr = ["1", "", undefined, "2", "3", "4", null]
        let newArr = arr.filter((item) => {
            return item;   // return Boolean(item);
        })
        console.log('filter-arr:', arr);         //  ["1", "", undefined, "2", "3", "4", null]
        console.log('filter-newArr:', newArr);   //  [1, 2, 3, 4]
        // 3-去除重复项
        let arr = ["anita", "lily", "anita", "ann", "ann", "jhon", "candy"]
        let newArr = arr.filter((item, index, arr) => {
            console.log(`item:${arr.indexOf(item)} index:${index}`)
            // arr.indexOf() 返回元素第一次出现的索引值，若元素第一次出现的索引值与其在数组的索引值不同，则表示有重复出现
            return arr.indexOf(item) === index
        })
        console.log('filter-arr:', arr);         //  ["anita", "lily", "anita", "ann", "ann", "on", "candy"]
        console.log('filter-newArr:', newArr);   //  ["anita", "lily", "ann", "on", "candy"]

arr.every 依据条件判断，数组的每一项元素若是满足条件，返回true

        let arr = [1, 2, 3, 4, 5, 6, 9]
        let isTrue = arr.every((item, index, arr) => {
            return item > 7
        })
        console.log("isTrue", isTrue)  // false

arr.some依据条件判断，数组若是有一项满足条件，返回true

        let arr = [1, 2, 3, 4, 5, 6, 9]
        let isTrue = arr.some((item, index, arr) => {
            return item > 7
        })
        console.log("isTrue", isTrue)  // true

arr.reduce(callback, [initialValue]) 累加器，数组中的每个值（从左到右）合并，最终计算为一个值

// pre: 必选 --上一次调用回调返回的值，或者是提供的初始值（init）
// cur: 必选 --数组中当前被处理的数组项
// index: 可选 --当前数组项在数组中的索引值
// arr: 可选 --原数组
// init: 可选 --初始值
// callback第一次执行时，pre 和 cur 可以是一个值
// 如果 init 在调用, reduce() 时被提供，那么第一个 pre等于 init, 且cur等于数组中的第一个值
// 如果 init 未被提供，那么pre等于数组中的第一个值
       // 1
        let arr = [0, 1, 2, 3, 4]
        let value = arr.reduce((pre, cur, index, arr) => {
            return pre + cur
        }, 100)
        console.log("value", value)
       // 判断一个某个元素在数组中出现次数
       const countTimes = (arr, value) => arr.reduce((a, v) => v === value ? a + 1 : a + 0, 0);
       console.log('[1,1,1,2]中 1 出现的次数是：'+ countTimes([1,1,1,2],1));