API数组的使用

// forEach：循环遍历数组
// map : 函数对象，1、循环遍历原始数组的元素，对其每个元素（或符合条件的元素）进行值的修改，并返回一个新的数组对象（在内存中开辟一个新的空间，严格属于数组对象的浅拷贝）
// 注：map执行的函数对象中 一定要有返回值，如果没有返回值 则以undefined作为返回值

// filter: 函数对象 对数组元素进行过滤筛选
// reducer: 对数组的元素值进行累计
// some：判断当前数组一个或多个元素值的条件成立 返回值是布尔类型 true:当前数组一个或多个元素值的条件成立(至少要有一个元素符合条件才会返回true)。 false： 当前数组没有一个元素值的条件成立 才会返回false
// every：判断数组元素的条件是否成立，返回布尔类型， true:当前数组所有元素值条件成立 返回true false:当前数组一个元素或多个元素的条件不成立 返回false，至少有一个元素值不符合条件
// find:查找符合条件的元素(注：查找第一个条件成立的元素) 返回匹配成功的元素对象，如果没有匹配的元素则返回undefined
// findIndex：查找符合条件的元素下表（和indexOf 非常相似,查找第一个成立的）返回匹配成功的元素下表（下标值大于等于0),如果没有匹配的元素则返回一个小于0的值


//Map
  let arr = [1, 2, 3];
        //使用map修改每个元素值（元素值*2）
        let newArray = arr.map((item, idx, targetArray) => {
            return item * 2;
        })
        console.log('arr:', arr, '\n newArray:', newArray);

        //对数组中 元素值为偶数的乘以2
        let newArray2 = arr.map((item, idx, target) => {
            if (item % 2 === 0) return item * 2;
            else return item
        })

every

<script>
        // every:
        let arr = [1, 2, 3];
        let flag = arr.every((item, idx, tarfet) => {
            return item >= 2
        });
        console.log(flag);

        function checkWhiteList(url) {

        }
    </script>

 filter

    <script>
        // filter: 数组元素过滤/筛选
        // filter：处理函数对象 必须有返回值，返回值为布尔类型 true： 该元素返回至新的数值中，false：该元素不返回至新的数组中
        // Array.filter( ( item,index,target )=>{ // 必须要有返回值 布尔类型 })

        let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
        let newArray = arr.filter((item, idx, target) => {
            return item % 2 !== 0;
        });
        console.log(newArray);
        let stus = [{
            sname: '张三',
            score: 59
        }, {
            sname: '李四',
            score: 69
        }, {
            sname: '王五',
            score: 49
        }];

        let newStu = stus.filter(item => item.score >= 60)
        console.log(newStu);
    </script>

find

    <script>
        // find函数
        let arr = [1, 2, 3, 3];
        // 查找数组arr 元素为3的值
        let queryObject = arr.find((item, idx, target) => {
            return item === 3;

        });
        console.log('queryObject:', queryObject);

        let persons = [{
            pname: '张三',
            page: 28
        }, {
            pname: '李四',
            page: 56
        }, {
            pname: '张三',
            page: 280
        }];
        let queryPerson = persons.find(item =>
            item.pname === '张三'
        );
        console.log(queryPerson);
    </script>

findIndex

    <script>
        // findIndex函数
        let arr = [1, 2, 3, 3];
        // 查找数组arr 元素为3的下标值
        let queryIndex = arr.findIndex((item, idx, target) => {
            return item === 3;

        });
        console.log('queryIndex:', queryIndex);
    </script>

forEach

<script>
        // forEach: 循环遍历 数组元素 
        // Array.forEach( (item,index,taget)=>{})
        // item:循环遍历的数组的元素
        // index:每次循环遍历数组元素对应的下标
        // target:循环遍历数组的目标对象 
        let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
        // for (let index = 0; index < arr.lengthlindex++){}
        let newArray = [];
        // arr.forEach(item => newArray.push(item));


        //将arr数组中偶数的元素值乘以2
        arr.forEach(item => {
            if (item % 2 === 0) newArray.push(item * 2);
            else newArray.push(item)
        })
        console.log(arr, newArray);
    </script>

reduce

 <script>
        // reduce : 对数组的元素值进行累计（元素值进行加减乘除）
        // acc： 累计数 上一个元素值与初始的数据进行累计的结果
        // cur: 当前循环遍历的元素
        // idx： 当前循环遍历的数组下标
        // target：循环遍历的数组对象
        // initvalue： 累计的初始值，如果该参数未提供，则累计的初始值以数组第一个元素值为累计的初始值
        // 注：initvalue在正式循环遍历过程中自遍历的次数 数组长度-1
        // reduce函数的返回值 数组所有元素累计的结果值
        // Array.reduce((acc,cur,idx,target) =>{},initvalue);

        // let arr = [1, 2, 3];
        // // 对 arr 数组中每个元素进行累加
        // let total = arr.reduce((acc, cur, idx, target) => {
        //     console.log('acc:', acc, '\n cur:', cur, 'idx:', idx, 'target:', target);

        //     // 将上次累计的总和再和当前的元素进行累加后，再加累计的值返回
        //     return acc + cur;
        // }, 10);
        // console.log(total);

        // // 对往年的销售业绩进行
        // let sales = [{
        //     year: '2018',
        //     sale: -100,
        // }, {
        //     year: '2019',
        //     sale: 10,
        // }, {
        //     year: '2020',
        //     sale: 50
        // }];
        // let salseTatol = sales.reduce((acc, cur, idx, target) => {
        //     console.log('acc:', acc, '\n cur:', cur, 'idx:', idx, 'target:', target);

        //     return acc + cur.sale
        // }, 0);
        // console.log('销售总额：', salseTatol);

        // 统计销售量
        let sales2 = [{
            year: '2018',
            sale: 0.05,
        }, {
            year: '2019',
            sale: 0.05,
        }, {
            year: '2020',
            sale: 0.05
        }];
        let totalsale = sales2.reduce((acc, cur) => {
            return acc * (1 + cur.sale);
        }, 100);
        console.log('三年后销售总额：', totalsale);
    </script>

some

   <script>
        // some: 判断数组元素 是否成立
        let arr = [1, 2, 3];
        let flag = arr.some((item, idx, target) => {
            return item >= 3;
        });
        console.log('flag:', flag);
        // 通过some 函数 设置一个白名单列表检测业务
        function checkWhiteList(url) {
            let whiteList = [
                'http://www.baidu.com',
                'http://www.sina.com',
                'http://www.taobao.com'
            ]
            return whiteList.some(item => item === url)
        }
        console.log('checkWhiteList:', checkWhiteList('http://www.taobao.com'));
    </script>