ES5新增的数组方法

共性: 对数组进行循环,循环要做的事情都在回调函数里写

1、 foreach

功能：遍历数组中每个元素，不改变原数组，仅仅只是遍历，常用于注册组件、指令等等。

参数：回调函数(回调函数的参数: 数组的当前元素,下标,数组本身){

解释: 回调函数的代码就是在循环体里要执行的代码

}

返回值：无返回值

var scores = [98,99,65,84,82,71];

   scores.forEach((item,index,arr) => {
       //item = item + 1    // 这样写就不行了(item是形参)
        arr[index] = item + 1;
    });
 console.log(scores);  //99 100 66 85 83 72

拓展：定义一个forEach函数

Array.prototype.myForEach = function(callback) {

        //这里this是  scores

  for ( let i = 0; i < this.length; i++ ) {

                callback(this[i],i,this)

        }

}

调用：

scores.myForEach((item,index,arr) => {

        arr[index] = item +2;

})

console.log(scores)

2、map

功能：映射一个新的数组(遍历数组中每个元素,对每个元素做一定的处理,把处理的结果放在新的数组里)

参数：回调函数(数组的当前元素,下标,数组本身)

返回值：新的数组

var scores = [98,99,65,84,82,71];

let arr = scores.map((item,index,arr) => {
     return item+1;  //这个结果是放在新的数组里了
});
 console.log(scores,arr);

3、filter

功能：  过滤掉数组中不满足条件的值（满足回调函数里的条件元素放入新的数组）

参数：回调函数( 数组的当前元素, 下标, 数组本身)

返回值：新的数组，不改变原数组

var scores =  [98,99,65,84,82,71,50,45];

let arr = scores.filter((item,index,arr) => {
        return item >= 60;  //满足的条件
});
 console.log(arr); // 98 99 65 84 82 71

4、some

功能：  完成的是判断,判断数组中是否有一些元素满足条件(回调函数里写的条件)

参数：  回调函数(回调函数的参数： 数组的当前元素,下标,数组的本身)

返回值： 布尔值true代表有一些满足条件的元素,false代表没有满足条件的元素(每一个都不满足)

var scores =  [98,99,65,84,82,71,50,45];
    // 判断是否有人不及格
  let has = scores.some((item,index,arr) => {
        return  item < 60;
});
 console.log(has);   //true

5、every

功能:   完成的是判断,判断数组中是否每一个元素 都 满足条件(回调函数里写的条件)

参数：  回调函数(回调函数里的参数: 数组的当前元素, 下标, 数组本身)

返回值：   每一个都满足则为true   有一些没有满足则为false

<script>
//   item < 60 每一个都满足则为true
// let scores =  [41,50,45,32,58,44];  (比如购物车中当所有的单个复选框
                                        //都勾选上了，则全选的复选框会选中
                     //this.allchecked = this.shopCars.every(item => item.isChecked)) 
let scores =  [98,99,65,84,82,71,50,45];    //有一些没有满足则为false
    let has = scores.every((item) => {
        return  item < 60;
    });
 console.log(has);   //false
</script>

6、reduce

arr: 表示将要原数组

prev:表示上一次调用回调时的返回值，或者初始值init

cur:表示当前正在处理的数组元素

index:表示正在处理的数组元素的索引，若提供init值，则索引为0，否则索引为1

 init: 表示初始值

功能：让数组的前后两项进行某种计算,然后返回其值，并继续计算,不改变原数组,返回计算的最终结果，从数组的第二项开始遍历。

 var arr = [1, 2, 3, 4];

  arr.reduce((prev, cur, index, arr) => {

        console.log(prev);

        console.log(cur);

        console.log(index);

        return prev + cur;
    });

案例：reduce求和

<script>
     let arrw = [1,2,3]

     let results = arrw.reduce((prev,item)=> {
            return prev+item
     })
     console.log('results',results); // 6
</script>

案例：reduce去重

<script>  
        const arr3 = [1,2,3,4,5,3,2,1,6,4,7,8]

        const resultArr = arr3.reduce((pre,cur)=>{
            if(!pre.includes(cur)){
                return pre.concat(cur)
            } else {
                return pre
            }
        },[])

        console.log(resultArr)
</script>

案例：reduce

  let fruitList = [
    {
      name: "苹果",
      createTime: null,
      updateTime: null,
      id: 1001,
      AidAndsID: "100:105",
    },
    {
      name: "橘子",
      createTime: null,
      updateTime: null,
      id: 1002,
    },
    {
      name: "葡萄",
      createTime: null,
      updateTime: null,
      id: 1003,
      AidAndsID: "102:107",
    },
  ];
  /*
      想要的结果result格式 [
            { Aid: '100', sID:'105' },
            { Aid: '102', sID:'107'  }
        ]
  */

  let result = fruitList.reduce((prev, next) => {
    if (next.AidAndsID) {
      let [Aid, sID] = next.AidAndsID.split(":");
      prev.push({
        Aid,
        sID,
      });
    }
    return prev;
  }, []);
  console.log(result);