ES6

ES5常见的数组方法（迭代/遍历数组）

forEach() ：缺点: 不能使用break和continue

map() ： (映射)：遍历数据并返回一个新的数组，对数的处理会返回原先对应的位置

filter() ：过滤，返回复合条件的数据 return true，则是吧当前真的数据存入新的数组否则不存

some() :　如果有复合条件的记录，　则返回真，否则返回假

every()：　如果每一个数据都复合条件，则返回真，否则返回假

reduce()：　常用来实现累加的

  let arr = [300,600,200,100]
  // 首次调用时,sum是第一个元素，val是第二个元素，index是1
  // 再次调用时，sum是上一次return的结果，val依次是下一个元素
  let result = arr.reduce((sum,val,index)=>{
      console.log(sum,val,index);
      return sum + val;
  })
  console.log(result);

  //第二个参数是sum的初值，则第一次调用 时，val是第一个元素
  let result = data.list.reduce((sum,val,index)=>{
      return sum + val.price;
  },0)
  console.log(result);

let - const

ES5作用域：全局作用域，函数作用域(局部作用域)
ES6
let： (1)定义块级作用域 {} (2)在同一块级作用域不能重复声明
const: 定义常亮 (1)声明必须负值 (2)不允许更改

箭头函数

箭头函数的语法： ()=>{}

箭头函数中的this指向：指向定义它的函数的this
没有参数可以写 ()=>{} ; -- 有一个参数可以写 item=>{}; -- 只有一条return语句，可以不写{} let fun = ()=>1;

类和继承

  class Parent {
      // 等同es5中的构造函数
      constructor(name,age){
          this.name = name;
          this.age = age
      }
      //等同es5中向原型对象添加方法
      run(){
          console.log("run")
      }
  }

  class Child extends Parent{
      constructor(name,age,grade){
          //相当于调用父类的构造函数
          super(name,age)
          this.grade = grade;
      }
      study(){
          console.log('study')
      }
  }

  let c1 = new Child('Jack',23,'六');
  console.log(c1)

ES6对象字面量的简写属性名和属性一样的话可以直接写obj{name,age}
模板字符串模板字符串的写法和拼接： <p>内容：${变量}</p>
结构赋值 : 对象的 let {name,age} = obj 数组的 let [num1,num2] = arr
展开运算符： [...arr1] 等价于：把arr1中的元素一个一个拿出来，放到新的数组中

默认参数和剩余参数
ES5的默认参数： function(a){ a = a || 12 }
ES6的默认参数：可以直接在参数的后面加上 function(a=12){} ---有是有多个参数的话默然参数必须写在最后面

剩余参数

  // ===================剩余(rest)参数: 得到所有的实参，等同于es5中 arguments,
  function total(...a){
      // ES5: 
      // console.log(arguments)  //伪数组

      // args: 真数组
      // console.log(args instanceof Array);
      console.log(a);
  }
  total(23,45)

Symbol数据类型

Symbol: 获取唯一不会重复的变量，是ES6新增的数据类型

set

set: 是ES6中新增的集合的数据类型，用来存放数组。但是，数组的元素不允许重复
set 可以用for..each 遍历不能使用数组对象的方法map()...
ES6使用set的数组去重

    let arr = [1,2,3,5,1,2,1]
    let result = [...new set(arr)]

    // set的声明：
    let set = new Set([1,2,3,4]);

for..of语句

遍历语句：

forEach: (1) 可以遍历对象以外的集合（数组，Set）（2）不能使用break和continue

for...in (1)遍历对象 (2)不能直接访问对象的属性值

ES6新增的for...of: (1)可以用于部署了Symbol.iterator的对象（自定义的对象不能使用for...of,但大部分原生的数据集合都可以使用）
(2)可以使用break和continue

iterator迭代器

是一个函数
可以统一处理所有集合数据
返回一个next方法，调用next之后会返回一个包含两个属性的对象 {value:'',done:true}
iterator是专供for...of来消费的

Object.keys方法

Object.keys(): 返回指定对象所有属性名组成的数组

Map类型的数据

Map: 类似与对象，用来存储键值对。
对象只能使用字符串作为属性名，而Map可以使用任意类型的数据做为属性名

  let map = new Map([["a",1],["b",2]])  //map声明 输出{"a"=>1,"b"=>2}

map的Apl
属性： size 和length一样是代表长度的
方法：
- set: 添加 map.set("name","alice"); 给map添加了name=>alice
- get: 读取 console.log(map.get("a")) 读取map里面a的属性输出 1
- has: 查找有没有该属性有则为真则为假
- delete: 删除某个属性
- clear: 清除所有属性

    //============================================for...of遍历
        // 获取属性名
        // for(let key of map.keys()){
        //     console.log(key)
        // }

        // 获取值
        // for(let val of map.values()){
        //     console.log(val)
        // }

        // 同时获取键值
        // for(let i of map){
        //     console.log(i)
        // }
        // 等同于
        // for(let i of map.entries()){
        //     console.log(i[0])
        //     console.log(i[1])
        // }

        // for(let [key,value] of map.entries()){
        //     console.log(key)
        //     console.log(value)
        // }


        // let obj = {
        //     name: 1,
        //     age: 2
        // }
        // delete obj.age
        // console.log(obj)

Promise

promise是什么

1、主要用于异步计算
2、可以将异步操作队列化，按照期望的顺序执行，返回符合预期的结果
3、可以在对象之间传递和操作promise，帮助我们处理队列

为什么会有promise？

为了避免界面冻结（任务）

同步：假设你去了一家饭店，找个位置，叫来服务员，这个时候服务员对你说，对不起我是“同步”服务员，我要服务完这张桌子才能招呼你。那桌客人明明已经吃上了，你只是想要个菜单，这么小的动作，服务员却要你等到别人的一个大动作完成之后，才能再来招呼你，这个便是同步的问题：也就是“顺序交付的工作1234，必须按照1234的顺序完成”。
异步：则是将耗时很长的A交付的工作交给系统之后，就去继续做B交付的工作，。等到系统完成了前面的工作之后，再通过回调或者事件，继续做A剩下的工作。

ES6笔记