10月es6学习记录

1.var , let , const 区别？

a.变量提升
    var声明的变量存在变量提升，即变量可以在声明之前调用，值为undefined。
    let/const不存在变量提升，即声明的变量一定要在声明后使用，否则报错。
b.暂时性死区
    var不存在暂时性死区。
    let/const存在暂时性死区。
c.块级作用域
    var不存在块级作用域
    let/const存在块级作用域
d.重复声明
    var允许重复声明变量；
    let/const在同一作用域不允许重复声明变量。
e.修改声明的变量
    var/let 可以修改声明的变量。
    const声明一个只读的常量，一旦声明，常量的值就不能改变。【注意，如果定义的是对象/数组，那么是可以修改里面的属性值。原因在于
    对象和数组是引用类型，const声明的变量保存的仅是数组和对象的指针，修改属性值不会改变对象的指针，所以是可以修改的。】
f.使用
    能用const就用const,其他情况用let，避免使用var。

2.es6数组新增了哪些扩展？

1.扩展运算符的应用 即 ...，好比 rest参数的逆运算，将一个数组转为用逗号分隔的参数序列。
  例如：
      console.log(...[1,2,3]); // 1,2,3
  主要用于函数调用时，将一个数组变为参数序列。
  可以将某些数据结构转为数组；
  也能实现数组复制和合并。【注意：通过扩展运算符实现的是浅拷贝，修改了引用指向的值，会同步反映到新数组】
  扩展运算符可以与解构赋值结合起来，用于生成数组。
  如果将扩展运算符用于数组赋值，只能放在参数的最后一位，否则会报错。

2.构造函数新增的方法：
     Array.from():
        将两类对象转为真正的数组：类似数组的对象和可遍历的对象。
     Array.of()：
        用于将一组值，转换为数组。

3.实例对象新增的方法：
     copyWithin(): 将指定位置的成员复制到其他位置，会覆盖原有成员，然后返回当前数组。
     find(),findIndex()：
       find(): 用于找出第一个符合条件的数组成员。
       findIndex(): 返回第一个符合条件的数组成员的位置，如果都不符合条件，则返回-1。
     fill()： 使用给定值，填充一个数组。
     entries(),keys(),values()：
       entries():对键值对的遍历。
       values(): 对键值的遍历。
       keys(): 对键名的遍历。
     includes()： 用于判断数组是否包含给定的值。
     flat(),flatMap()： 将数组扁平化处理，返回一个新数组，对原数据没有影响。

3.es6对象新增了哪些扩展？

1.属性的简写：即相同的名字可以省略
2.属性名表达式：
    例如： 
      let ab = 'ab';
      let a = {
        [ab]: 'ab',
        'he': 'hello'
      }
3.super关键字：指向当前对象的原型对象。
4.扩展运算符的应用： 用于对象解构，解构赋值是浅拷贝相当于 Object.assign()方法。
5.属性的遍历：
     for..in: 循环遍历对象自身和继承的可枚举属性。
     Object.keys(obj): 返回一个数组，属性的键名，
     Object.getOwnPropertyNames(obj): 返回对象自身的所有属性的键名。
     Reflect.ownKeys(obj): 返回一个数组，包含对象自身的所有键名。
6.对象新增的方法：
     Object.is():
        严格判断两个值是否相等，与===相似，不同之处在于： 
           +0===-0 // true
           NaN === NaN; // false
           Object.is(+0,-0);// false
           Object.is(NaN,NaN);// true
     Object.assign():

        用于对象合并，Object.assign(target,source1,source2..);
     Object.getOwnPropertyDescriptors():
        返回指定对象所有自身属性的描述对象。

     Object.setPrototypeOf()：用来设置一个对象的原型对象。
     Object.getPrototypeOf(): 用来读取一个对象的原型对象。
     Object.keys(),Object.values(),Object.entries():
     Object.fromEntries(): 用于将一个键值数组转为对象。

4.es6函数新增了哪些扩展？

1.参数
  函数的参数可以设置默认值。参数默认值应该是函数的尾参数。
  function foo({x,y=2} = {}){}

2.箭头函数
  函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象；
  不可以当作构造函数，即不可以使用new关键字；
  不可以使用arguments对象，该对象在函数体内不存在，如果要用，可以用rest参数代替；
  不可以使用yield命令，因此箭头函数不能用作generator函数。

5.Set,Map两种数据结构区别？

set 是一种叫做集合的数据解构；map是一种叫做字典的数据解构。

set:
   类似于数组，里面的值都是唯一的。
   使用方法：
      add(); delete(); has(); clear();
   使用场景：
      1.扩展运算符+set结构相结合可以实现数组或字符串去重。
        let arr = [...new Set([1,2,1,2,3,5,23,6]);
      2.实现并集，交集，查缉
        let arr1 = [1,2,3,1,24,5,6];let arr2 = [4,5,2,3,6,5];
        并集： let arr = [...new Set([...arr1,...arr2])];
        交集： let arr = [...new Set(arr1)].filter(item=>arr2.includes(item))
        前者相对于后者的差集：let arr = [...new Set(arr1)].filter(item=!arr2.includes(item));

map:键值对的有序列表，且键值可以是任意类型。
    使用方法：
        size属性；
        set();
        get();
        has();
        delete();
        clear();

6.promise

是异步编程的一种解决方案。

状态： promise对象仅有三种状态
  pending， fulfilled， rejected。

const promise = new Promise(function(resolve, reject){});

实例方法： then(), catch(), finally();

构造函数方法有： all(), race(), allSettled(), resolve(), reject(), try()

7.generator

function* foo(){
  yield 'hello';
  yield 'i hope you happy everyday';
  yield 'good luck to you';
}
结合next方法执行函数；
let f = foo();
f.next(); // {value: 'hello', done: false}
...
直到结果显示为： {value: undefined, done: true} 代表执行结束。

异步解决方案：
   回调函数：
      就是在函数里面嵌套函数。
   promise对象：
      将回调函数的嵌套改成链式调用。
   generator函数：
      yield表达式可以暂停函数执行，next方法用于恢复函数执行，这使得generator函数非常适合将异步任务同步化。
      例如：
          const gen = function* (){
             const f1 = yield readFile('xx');
             const f2 = yield readFile('yy');
             console.log(f1.toString());
             console.log(f2.toString());
          }
   async/await；
      将上面generator函数改成async/await形式，更为简洁，语义化更强了。是处理异步编程的最终方案。
          const asyncFoo = async function(){
             const f1 = await readFile('xx');
             ...
          }

8.proxy

var proxy = new Proxy(target, handler);
target: 表示要拦截的目标对象；
handler： 通常以函数作为属性的对象，各属性中的函数分包定义了在执行各种操作时代理proxy的行为。

例如：
   let objP = new Proxy(obj,{
     get(target, key, proxy){
       return Reflect.get(target, key, proxy);
     },
     set(target, key, value, proxy){
       return Reflect.get(target, key, value, proxy);
     }
   })

9.es6中的module使用

模块功能主要由两个命令构成：
   export： 模块的对外接口。
   import： 输入其他模块提供的功能。

一个文件中export可以有多个，export default 只能有一个。
export 暴露的是一个接口，在import时不能改变它的变量名，并且必须加上大括号{}。【注意，引入时可以用as取别名】
   export var a = 1; import {a} from 'xx.js';
export default 暴露的是一个变量，在import时可以使用任意变量名导入，不用大括号{}。
   var a = 1; export default a; import anyName from 'xx.js';