ES6新增的数组迭代方法

一、数据类型Set（集合）,

他类似于数组，但不是数组，与数组的唯一的区别是：不能存储重复元素 他最大的应用场景就是数组去重。

  //let arr=[10,22,22,13,13,45,66,82,11,17,17]
      
       // let set =new Set(arr)
        //  
        //let newArr=Array.from(set) 
        console.log(set);
        console.log(newArr);
 简写：
  let newArr=Array.from(new Set(arr))
        console.log(newArr,111);

二、 forEatch 循环遍历数组每一项，没有返回值，用来了代替for循环

特点 1：没有返回值， 2：没有return

应用场景：就是遍历数组每一项

var arr = [
  { id: 1, name: 'jack', age: 18 },
  { id: 2, name: 'rose', age: 28 },
  { id: 3, name: 'tom', age: 38 },
]
 let arrList=arr.forEach((itme) => {
 console.log(itme.id);
 console.log(itme.name);
  console.log(itme.age);
  return 123
 });

三、map（）他是循环遍历数组的每一项，然后返回一个新的的数组，同时支持自定义返回值

特点：1 有返回值，返回一个新的数组， 2 有return 同时可以自定义返回值

应用场景：映射数组，对数组每一个元素进行映射处理，得到一个全新的数组

  //1： map场景
        let arr=[10,22,22,13,13,45,66,82,11,17,17]
        /* map方法的特点 
          1:回调函数执行次数：就是本身数组的长度
          2：本身的返回值：映射之后的新数组
          3：回调函数内部 return 
            return 映射之后的值
        */
       let arrMap=arr.map((item,index)=>{
        // 全场8折
         return item*0.8
       })
       console.log(arrMap);

四、 filter() 他是用筛选满足条件的元素

特点：1：有返回值，返回一个新的数组，2：有return ，返回满足条件的那一项的数据

应用场景：方法他是用来筛选数组元素，过滤数组。

   let arr=[10,22,22,13,13,45,66,82,11,17,17]
        let newArr=arr.filter((item,index)=>{
            //找能被2整除的数
            // if(item%2===0){
            //     return item
            // }
            //简写
            return item%2===0
          
        })
        console.log(newArr);

五：some （）方法，判断数组中是否有满足条件的元素（只要一项满足就结束）

特点： 1、有返回值，返回一个 Boolean值，2、有return ，只要一项满足条件就立刻终止循环

应用场景：找出符合条件的数


let  newArr1=arr.some((itme)=>{
  return itme.id==4
})
let  newArr2=arr.some((itme)=>{
  return itme.age==38
})

console.log(newArr1); // ====false
console.log(newArr2);//====true

方法5：every（）方法，判断数组中是否有满足条件的元素

特点：1：有返回值，返回一个 Boolean值 2：有return ，只要有个不满足就结束循环返回一个false,只有都满足才会返回true

应用场景:他的经典场景就用来做开关法的

var arr1 = [

  { id: 1, name: 'jack', age: 18 },
  { id: 2, name: 'rose', age: 18 },
  { id: 3, name: 'tom',  age: 18 },
]

let newArr= arr1.every((item)=>{
 return item.age==18
})
let newArr1= arr1.every((item)=>{
  return item.name=='tow'
 })
console.log(newArr);//true
console.log(newArr1);//false

方法6：reduce （）方法

特点：1：有返回值，返回一个Boolean值， 2：有return ，只要有一个不满足就是false

应用场景:主要应用在数组的求和和数组的最大值

应用场景：主要在数组求和，求数组的最大值。
var arr2 = [
  { id: 1, name: 'lining', price: 100, num: 2},
  { id: 2, name: 'anta', price: 200, num: 2 },
  { id: 3, name: 'nike', price: 300, num: 2},
  { id: 4, name: 'tebu', price: 400, num: 2 },
]
 他有三个参数：
 参数sum:上一次回调的返回值，默认是第一个元素值
 value :当前元素值，值从1下标元素开始
 index：当前下标，默认从1开始
 他有一个局限，如果遇到空数组，就会报错，我们在结尾加一个0，这个0代表是从数组0下标开始，值同时也为0
let newArr= arr2.reduce((sum,item,index)=>{

  return sum+item.price  

   console.log(newArr6)

},0)
console.log(newArr);

7：findIndex（）方法

特点： 1：有返回值，会返回一个索引[下标] 2：有return ，只要条件满足就会返回索引

应用场景：findIndex跟indexOf不同的是，findIndex能对数组对象的引用类型数据操作，而indexOf只能对数组的普通值类型操作

 var arr = [

 { id: 1, name: '张三', age: 18 },
  { id: 2, name: '李四', age: 18 },
  { id: 3, name: '王五',  age: 18 },
]

let newArr=arr.findIndex((item,index)=>{
    return item.name=='王五'

})
console.log(newArr);

let arr1=[10,20,30,40,50]
let newArr2=arr1.indexOf(40)
console.log(newArr2);

8：find（）方法

特点： 1、有返回值，返回一个对象，2、有return ，只要有条件满足就会返回当前满足

 let newArr=arr.find((item)=>{
   if(item.id==2){
    return true
   }
})
 console.log(newArr);

9：slice（）方法 ===截取数据

1个参数：截取数组中的数据返回一个新的数组，不会影响原数组
2个参数：从参数1开始，到参数2的前一位结束
3：从下标1开始截取，到下标4，不包含4，包头不包尾

 slice 截取数据

let arr2=['a','b','c','d','e','f']
let newArr= arr2.slice(1,4)
console.log(newArr);

10：splice（）方法 ===截取数据

1个参数：截取数组中的数据返回一个新的数组，会影响原数组
2 从当前参数的索引开始往后截取
3 打印原数组返回的是没有背截取的数组

let arr2=['a','b','c','d','e','f']
let newArr1=arr2.splice(1,4)
console.log(newArr1);

总结

当然也可以用图片来形象理解。

三、数组迭代方法