ES6学习

1. let声明变量
   1. 暂时性死区
   2. 不允许重复声明 
2. 块级作用域：
   1. 使得立即执行函数不再必要 
3. const：
   1. 声明只读常量，声明后不能改变；
   2. 并且声明的时候就必须赋值，不能等之后再赋值
   3. 变量不提升、也有暂时性死区
      1. 实际上是在保证：变量指向的那个内存地址所保存的数据不得改动
4.  顶层对象与全局对象脱钩，不再相等
5.  
6.  
7.  
8. 解构赋值：
   1. 解构不成功，赋予undefined
   2. 可以使用默认值（在情况为undefined时）
   4. 可以对对象解构赋值，属性名要对应
   6. 对字符串的解构
   7.  
   8. 用途
      1. 交换变量的值
      2. 从函数返回值提取
      3. 函数参数的定义
      4. 提取JSON数据
      5. 遍历Map解构
      6.  
   9.  
9.  
10.  
11.  
12.  模板字符串
    1. 用反引号  ` 表示
    2. 可以单行使用、多行使用、嵌入变量使用
    3. ${变量}嵌入变量
    4. 保留空格以及缩进
    5.   
13.  
14.  
15.  函数的扩展
    1. 允许设置函数参数默认值
       2. 设置默认值后，查询参数长度时，长度将会失真
       4.  
    2.  rest参数（...变量名）
       1. 搭配的是一个数组，多余的参数可以放进该数组
       2.  
       3. rest参数必须作为最后一个参数
       4. length中不包括rest参数
       5.  
    3. 箭头函数
       1. ES6 允许使用“箭头”（=>）定义函数。
       2. 如果箭头函数不需要参数或需要多个参数，就使用一个圆括号代表参数部分。
       5. 箭头函数的this总是指向函数定义生效时所在的对象
       7. 箭头函数没有自己的this；所以总是指向寻找外层的this
       8.  
    4. 双冒号运算符
       2.  
    5. 尾调用
       1.  
    6.  
16.  
17.  
18.  数组（扩展运算符）
    1. 复制数组
    2.  合并数组
       1. 浅拷贝
       2.  解构赋值
          2. 赋值为数组
          3.  
    3.  
19. 对象的扩展
    2. object.js()：验证严格相等
    3. object.assign（）：复制对象
       1.  
       2. 浅拷贝、同名属性采用替换、
       3. 如果赋值的是取值函数，那么将先求值后再复制
       4. 用法：
          2. 合并对象：
          3.  
       5. ES6的遍历方法
          2. 遍历规则：
          3.  
       6. ES6原型继承方法：
          1. __proto__属性：读取或设置prototype对象
          2. Object.setPrototypeOf()方法：也是设置或读取对象的prototype对象【ES6推荐的设置原型对象方法】
          3.  Object.getPrototypeOf()方法：读取一个对象的原型对象
          4. JS中的this总是指向函数所在的当前对象；
          5. ES6新增的super（）：指向当前对象的原型对象
          6. Object.key()方法：返回一个数组，成员是对象参数中可遍历属性的键名
          7. Object.values()方法：返回一个数组，成员是对象参数中可遍历属性的键值
          8. Object.entries()方法：返回一个数组，成员是对象参数自身可遍历的属性键值对数组
          9.  
          10.  
       7.  
    4.  
20.  
21.  
22.  Symbol 
    1.  一种用于名字冲突的命名机制
    3.  
    4. Symbol.for()方法：会先查找是否有给定Key的存在，没有才会创建新Symbol值；【登记的是全局变量】
    5. Symbol.for()方法：返回一个已经登记过的Symbol类型的值；
    6.  
23.  
24.  
25.  Set和Map的数据结构
    1.  Set
       1. 类数组，不过成员内没有重复的值；本身也是构造函数
       2. 可以接收数组作为参数来进行初始化；在Set内部NaN也只能存在一个
       3.  
       4.  属性：
          1. Set.prototype.constructor：默认指向的就是Set函数
          2. Set.prototype.size
       5. 方法：
          1. add(value):添加值，返回结构本身
          2. delete():删除值，返回一个判断的boolean值
          3. has():返回一boolean，判断是否Set有该值
          4. clear():清除所有成员，没有返回值
          5.  
          6.  
          7.  
          8. 遍历方法：
             1. key（）：返回键名的遍历器
             2. values（）：返回键值的遍历器
             3. entries（）：返回键值对的遍历器
             4. forEach（）：使用回调函数遍历每个成员
             5. key（）与values（）的行为一致，因为Set结构没有键名，所以键值也就是它的键名
             6.  
       6.  
    2. WeakSet:
       1. 与Set结构相似，不过只能用于放置对象；不能遍历，没有size属性
       2. 方法
          1. WeakSet.prototype.add():
          2. WeakSet.prototype.delete():
          3. WeakSet.prototype.has(): 
       3.  
    3. Map：
       1. 属性
          1. size（）
          2. set（key，values）
          3. get（key）
          4. has（key）
          5. delete（key）
          6. clear（）
       2. 方法 
          1. 遍历方法 
             1. key():
             2. values():
             3. entries():
             4. forEach(): 
          2.  
       3.  
    4.  
26.    
27.  Reflect
    1.  
28.  
29. Promise:简单的说就是容器，里面保存着某个未来才会结束的事件（一个异步操作）结果
    1. 特点：
       1. promise对象状态不受外界影响
       2. 三种状态：pending、fulfilled、rejected
       3. 改变：pending->fulfilled、pending->rejected【两种情况发生，就称为resolved（已定型）】
    2.  缺点：
       1. 无法中途取消promise；一旦新建就会立即执行
       2. promise的错误，不会抛出到外部
       3. 处于pending时，无法得知目前处于哪一个阶段
    3. promise是一个构造函数：
       2. 执行后可以用then指定状态的回调函数：
          2. 一函数是成功的resolve的返回、二函数可以没有，是rejected的返回
          3. （本图分析：回调的resolve函数会在脚本同步任务console.log(‘Hi’)）执行完后才执行，说以就是有这个顺序
       3. 调用回调函数resolved和rejected并不会终结promise函数的执行；在它们前面加上return 即可跳过后续函数
       4. promise的错误是有“冒泡性质的”
       5. finally方法：；不接受任何参数
       6. promise.all（）方法：
       7.  
       8.  
    4.  
30.  
31.  Iterator（遍历器）：
    1. 为各种不同的数据结构提供统一的访问机制
    2. 作用：
       1. 提供一个统一、简便的访问接口
       2. 能使数据结构按照某种次序排列
       3. 提供for...of循环
    3. 过程：
       1. 创建一个指针对象，指向初始位置
       2. 第一次调用next()方法，指向数据结构的第一个成员
       3. 依次一直用next（）；
    4. 返回：一个value和done两个属性的对象；value是当前成员的值，done是布尔值是否遍历结束
    5.  Iterator 只是把接口规格加到数据结构之上，所以，遍历器与它所遍历的那个数据结构，实际上是分开的，完全可以写出没有对应数据结构的遍历器对象，或者说用遍历器对象模拟出数据结构 
    6.  只要部署了Symbol.Iterator属性；就可以进行for...of循环
    8. 字符串实现iterator接口：
    9.  
    10.  
32.  
33.  Generator（）函数：异步编程解决方案【是一个状态机，内部封装了多个内部状态】
    1. 执行Generator函数会返回一个遍历器对象，返回的对象可以依次遍历函数内部的每一种状态
    2. 过程&定义：
       4.  
    3. 由于遇到了yield才会执行，所以相当于提供了一个暂停执行的函数
    4. yield只能用在Generator函数中
    5. 如果yield要用在表达式中，必须加括号：
    6. 如果作为函数参数或赋值表达式的右边，可以不加括号： 
    7.   
    9. for...of方法可以自动、无需next的遍历Iterator对象
    10. 遍历任意对象Object的方法（加上Generator接口）：
    12. Generator内部以及外部的错误问题，得先确定是谁来抛出错误；内部抛出错误前要保证，有第一次next；并且执行throw抛出错误的同时还执行一次next
    13. 如果调用Generator函数的return方法，如果带参数，则返回以value，done；否则：undefined  & 
        1. 如果调用return时内部有finally时，先执行完finally才执行return：
    14.  
    15. next（）、throw（）、return（）方法：
    16. yield* 表达式：返回一个遍历器对象；只要有Iterator接口，也可以被yield*遍历
    17. yield遍历二叉树：
        2.  
    18.  
    19. Generator函数的异步应用：
        1.  es6之前回调函数的写法：；第三个参数即是回调函数，为什么方法中第一个参数是err呢？因为前边执行完成的错误，已经没办法处理了，只能由下一个函数接收处理；
           1. 回调函数地狱：多个回调函数嵌套，导致修改的时候，上层下层函数都要跟着修改
        2.  promise函数：允许了回调函数的嵌套；
        3. Generator函数：协程；用next（）方法分阶段执行Generator函数；同时还具有暂停执行和恢复执行；内外数据交换和错误处理机制
        4. 还可以部署捕获函数体外抛出的错误； 
        5.  
        6. Thunk函数：
           1. 发展之前：传值调用、传名调用；分别理解为是否先取值传入进行调用
           4. Thunk函数+Generator函数：自动的异步执行
           5.  
        7. co模块：
           2.  
           3.  
        8.  
    20.  
    21. async函数：
        1. 是Generator的语法糖：
        2. 改进：
           1.  内置执行器，只需要一行即可，不需要调用next呀，或者co模板等
           2. 语义更清晰：asycn表示有异步操作；await表示后面表达式需要等待结果
           3. 更广的适用性；
           4. 返回值是promise
        3.   
        4. async的多种使用形式：
           2. 返回的promise对象的状态改变，即要执行then方法的话，要等待await命令执行完才行
              2.  
              3. 只要一个await语句后面的promise变成reject，那么整个async函数就会中断执行
              4. 如果不希望前一句的await reject影响到后面的执行，可以将其放入try...catch中；或者紧跟依据catch方法
              5.  
           3. 使用的注意点：
              1. await语句错误的话，返回的promise对象结果可能是reject；所以可以将await语句加入try...catch语句中
              2.  如果await语句不存在继发操作，我们可以让他们同时触发，缩短程序执行时间：
                 2.  
              3.  
           4. 异步遍历器：
              1. 调用next方法之后，返回一个promise对象：
              2.  
              3.  
           5.  
        5.  
    22. Class语法：
        1. 定义类中方法时，不需要加function，直接将函数定义进去就可以了，不需要逗号
        2. 类的数据类型就是函数；类本身就指向构造函数
        3.   
        5. 类会自动添加constructor方法： 
        6. constructor的作用：
        7. 创建实例需要加 new；类的实例共享一个原型对象；
        9.  类也可以用表达式来定义：&如果内部不用到的话，可以省略Me
        10. class不存在变量提升&
        11.  使用变通方法进行私有方法与属性的注册： 
            2.  
            3. 用#方法写私有属性以及私有方法：
            4. 相应的get、set方法
            5.  加上static关键字，方法不会被实例继承，而是直接通过类来调用：
            6.  静态方法中的this指针，指向内部静态类
            7. 子类可以继承父类的静态方法；静态属性加static即可；
            8. new target属性：
            9.  
            10.  
        12. class的继承：
            3. 静态方法也会继承；
            4. Ob'ject.getPrototypeOf(xxx) === xxx；：可以判断一个类是否继承另一个类
            10.  
            11.  
        13.  
    23. 修饰器(Decorator） 
        1.   
        2. 【修饰函数在编译阶段就可以运行代码】
        3. 为类添加静态属性：
        4. 第三方模块：core-decorators.js提供了一些常见的修饰器
        5. @autobind：使得方法中的this，绑定原始对象；@readonly：使得属性或方法不可写；@override：检验子类是否正确覆盖父类的同名方法；@deprecate：表示控制台显示废除方法的警告线；
        6. Mixin模式：在一个对象之中混入另一个对象的方法；
           3. 或者创建一个中间类，让他来进行沟通工作
           5.  
           6.  
        7.  
    24. module模块
        1. 静态加载；
        2. 严格模式的限制：
           • 变量必须声明后使用；
           • 函数的参数不能有同名属性
           • 不能使用with语句
           • 不能对只读属性赋值；不能使用前缀0表示八进制
           • 不能删除不可删除的属性；eval不会在它的外层作用域引入变量
           • eval和arguments不能被重新赋值；arguments不会自动反映函数参数的变化
           • 不能使用arguments.callee；arguments.caller
           • 禁止this指向全局对象；不能用fn.caller和fn.arguments获取函数堆栈
           • 增加保留字 
        3. export：用于规定模块的对外接口；import：用于输入其他模块提供的功能
        4. export：
           1.   
           2. 可以使用as关键字重命名：
           3.  
           4.  
        5. import：
           2. 也可以用as重命名输入的变量；
           3. import命令输入的变量都是只读的；输入的对象确实可以改写的；
           4. import命令有提升效果：，因为是在编译阶段就运行的import
           5. 整体加载的方法（*号）： 
           6.  
        6. export default：指定默认的输出；
        7. import（）函数：动态加载；
           1. 按需加载；
           2. 条件加载；【if】
           3. 动态的模块路径；
           4.  
           5.  
        8. 等同于异步加载：
        9.  
    25. CommonJs与ES6模块的差异：
    26.  
    27.  
34.