第一部分：数组

一.数组遍历

（1）数组.reduce遍历（经典案例：求和）（里面函数后面不要忘记加0了）

*注意点：reduce（（形参1，形参2，形参3）=>{  return 形参1+形参2  },0），需要接收返回值。

let arr =[20,30,40,50]
//自己参悟，不注释了
 let sum =arr.reduce((sum,value,index)=>{
  //sum是上一次回调的value的值，value是每一次遍历数组的值，
    index数组下标
     console.log(sum,value,index)
     return sum+value
  },0)
 // sum为最大值
     console.log(sum)

（2）数组.filter遍历（筛选数组）

*注意点：filter（（形参1，形参2）=>{ i f ( ){ return true } }），需要接收返回值。

语法特点：

2.1：return ture :满足筛选条件，当前元素放入新数组

2.2：return false:不满足筛选条件，当前元素不放入新数组中

（案例：筛选数组中的偶数）

完整写法

let res = arr.filter((value,index)=>{
//value为每个数组的遍历，index为数组下标
   if(value%2==0){
        return true
      }
    })

(3) 数组.map遍历（修改数组，返回一个新数组）

*注意点：map（（形参1，形参2）=>{ return 修改后的数组值 }），需要接收返回值。

（案例：让数组中每个数值*2）

let arr =[20,37,83,29]
  //第一个value为数组元素，第二个index为数组下标
  let res =arr.map(function(value,index){
    return value*2
  })
   console.log(res)

（4）数组.some遍历（ 判断数组中是否有满足条件的元素( 逻辑或|| ) ）

        数组.every遍历（判断数组中是否所有的元素都满足条件(逻辑与&&) ）

*注意点：eyery （（形参1，形参2）=>{ return true（继续）}），需要接收返回值。

 回调函数内部return的作用

对于every逻辑或  (return true :循环继续 )（找到满足条件的继续找，只要有一个不满足结束）

判断数组中是否全部为正数
let arr =[20,29,394,71,1]
   let res =arr.every((item,index)=>{
     if(item>0){
 //只有当数组中的元素item是正数，才会执行if判断retrun才能往回调
         return true
      }
   })
  console.log(res)

对于some 逻辑与（return true:循环结束）（只要找到满足条件的元素即可）

*注意点：some（（形参1，形参2）=>{ return true(结束) }），需要接收返回值。

 //需求：判断数组中有没有负数
  let arr =[-10,283,474,382,273]
  let res=arr.some((value,index)=>{
    if(value<0){
      return true
    }
  })
  console.log(res)

 （5）数组.forEach遍历（代替for循环）（无返回值）

 let arr =[10,28,37,47,30.38]
    /*
    1.forEach作用与场景：遍历数组
      不加return
    */
   arr.forEach((value,index)=>console.log(value,index))

（6）arr.findIndex((value,index)=>{return 比较数据}) 用来查询数组中是否有符合条件的值，有则返回该数组的下标，没有则返回-1

let arr =[10,20,30,40,50]
let i = arr.findIndex((value,index)=>{return value>20})
console.log(2)

 二 .内置构造函数Set给数组去重（new Set）

（案例：清除数组中重复的数据）

  let arr=[10,29,28,30,293,29]
    //(1)声明Set,把数组类型重复的数据转换为set类型
    let set = new Set(arr)
    //(2)把set转换Array
    let newArr =[...set]
    console.log(newArr)
    //一行代码实现数组去重
    let abc = [...new Set(arr)]
    console.log(abc)

三.展开运算符（...数组）

    作用：类似于对象遍历

（案例1）连接数组

let arr1=[10,20,30,40,20]
    let arr2=[20,39,48,58,27]
    //连接数组
    arr1.push(...arr2)
    console.log(arr1)

（案例2）连接对象

//连接对象
    let obj={
      name:'张三'
    }
    let obj1={
      name1:'1',
      ...obj
    }
    console.log(obj1)

（案例3）求最大值

let arr1=[10,20,30,40,20]
    let arr2=[20,39,48,58,27]
    //求最大值
    let receive =Math.max(...arr1,...arr2)
    console.log(receive)//58

四：数组解构

    /*把数组元素赋值给变量*/
    let arr=[10,20,30]
    let [n1,n2,n3,n4]=arr
    
    console.log(n1,n2,n3,n4)

    //相当于是把变量的值赋值给数组
    let num1 =1
    let num2=2
    let num3=3
    let arr1=[num1,num2,num3]

对象解构

（1）把对象的属性值 赋值给 变量

    let  { name,age,sex } =  obj

（2）把变量的值赋值给对象

     let obj ={ name,age,sex }

//1.把对象的属性值 赋值给 变量
    let obj ={
      name:'张三',
      age:'23',
      sex:'男',
    }
    let {name,age,sex} = obj

    console.log(name)

    //(2)把变量的值赋值给对象
    let a = 10
    let abc ={
      name,
      age,
      num:a
    }
    console.log(abc)

第二部分：对象遍历

静态方法（Object.values(对象名)）

返回值是一个数组，会存储对象的每一个属性值

let arr =Object.values(person)
 console.log(arr)

Object.keys(对象名)

返回的是一个数组，会存储对象的每一个属性名

let arr =Object.keys(person)
 console.log(arr)

一、Set

keys方法、values方法、entries方法返回的都是遍历器对象

1.forEach

Set 结构的实例与数组一样，也拥有forEach方法，用于对每个成员执行某种操作，没有返回值。

let set=new Set([1,2,3,4,5]);
set.forEach((key,value)=>{
  console.log(key+':'+value);
})
//1:1
//2:2
//3:3
//4:4
//5:5

2.keys

keys返回的对象：[Set Iterator] { 1, 2, 3, 4, 5 }
keys返回的遍历器，或者说迭代器，它提供了一个next方法，调用返回一个包含两个属性的对象，分别是value和done,value表示当前位置的值，done表示是否迭代完。当done的值为false时，继续调用next()就可以访问下一个值。我们可以利用这个方法来遍历Set结构的值。

let set=new Set([1,2,3,4,5]);
let obj=set.keys();
let item;
while(!(item=obj.next()).done){
  console.log(item.value);
}
//1
//2
//3
//4
//5

3.values

由于Set结构没有键名只有键值，或者说键名和键值是同一个值，所以keys方法和values方法的行为完全一致。

let set=new Set([1,2,3,4,5]);
let obj=set.values();
let item;
while(!(item=obj.next()).done){
  console.log(item.value);
}
//1
//2
//3
//4
//5

4.entries

entries方法返回的遍历器，同时包括键名和键值，所以每次输出一个数组，它的两个成员完全相等。

let set=new Set([1,2,3,4,5]);
let obj=set.entries();
let item;
while(!(item=obj.next()).done){
  console.log(item.value);
}
//[ 1, 1 ]
//[ 2, 2 ]
//[ 3, 3 ]
//[ 4, 4 ]
//[ 5, 5 ]

二、Map

需要特别注意的是，Map 的遍历顺序就是插入顺序。

1.forEach

Map 有一个forEach方法，与数组的forEach方法类似，可以实现遍历。

let map=new Map([
  ['name','curry'],
  ['age',20]
]);
map.forEach((value,key)=>{
  console.log(key+':'+value);
})
//name:curry
//age:20

2.keys

遍历Map结构的键名，和Set的不一样了。

let map=new Map([
  ['name','curry'],
  ['age',20]
]);
let obj=map.keys();
let item;
while(!(item=obj.next()).done){
  console.log(item.value);
}
//name
//age

3.values

遍历Map结构的键值。

let map=new Map([
  ['name','curry'],
  ['age',20]
]);
let obj=map.values();
let item;
while(!(item=obj.next()).done){
  console.log(item.value);
}
//curry
//20

4.entries

遍历Map结构的键值对。

let map=new Map([
    ['name','curry'],
    ['age',20]
  ]);
  let obj=map.entries();
  let item;
  while(!(item=obj.next()).done){
    console.log(item.value);
  }
//[ 'name', 'curry' ]
//[ 'age', 20 ]