ES6基础知识

1、var、let、const

• var
  • 变量声明提升、可重复定义、全局变量挂载到window、变量作用域只能是全局或者函数
• let&const
  • 没有上述的3个特点
  • 会和大括号形成块级作用域（解决闭包问题）
• const
  • 定义常量的同时必须赋值(let、var可以先定义，后赋值）

1、临时死区(一)
let a = 10;
{
    console.log(a);
    let a = 20;  //报错
}

2、临时死区(二)
{
    var a = 5;
    let b = 6;
}
console.log(a);  //可以输出
console.log(b);  //b报错未定义

3、for循环输出i的闭包问题
let arr = [];
for (let i = 0; i < 10; i++){
    arr[i] = function () {
        console.log(i);
    }
}

arr[0]();  //0
arr[1]();  //1
arr[2]();  //2
解析：相当于如下……
{  let i = 0;  arr[i] = function…… }
{  let i = 1;  arr[i] = function…… }
……  

2、箭头函数和普通函数的区别

• 箭头函数
  • 只能作为函数使用，不能当做构造函数
  • 参数不可以重复命名
  • 返回值可同时省略return 和 {}
  • 没有实参列表arguments
    • 可以在参数处写...arg来代替实参列表
  • 没有this，调用箭头函数的this时，指向是其声明所在作用域的this

let sum = x => y => z => x+y+z;
console.log(sum(1)(2)(3));  //6

3、class

• 基本yong

class Person {
    constructor(name) {  // 对应 ES5 中的 构造函数
        this.name = name;  // this 代表实例对象
    }
    eat() {
        console.log("I am eating");
    }
}
let one = new Person("sss");

• constructor()
  • 通过 new 生成实例时，会自动调用该方法。一个类必须有 constructor() 方法，如果没有则默认隐式添加
  • constructor() 默认返回实例对象（即 this ）
• 严格模式
  • class 和 module 的内部，默认严格模式
• class 的继承
  • class 之间可以通过 extends 关键字实现继承
  • 子类的 constructor() 中必须有 super()
    • 子类的 super() 就是父类的 constructor()
    • 子类没有自己的 this 对象，而是继承父类的 this 对象，然后对其加工
    • 如果不调用 super() ，子类就得不到 this 对象

//子类
class Son extends Person {
    constructor(name, age) {
        super(name);  //调用父类的 constructor(name)
        this.age = age;
    }

    eatAndSay() {
        super.eat();  //调用父类的 eat()
        console.log("I am saying!");
    }
}

//父类
class Person {
    constructor(name) {
        this.name = name;
    }

    eat() {
        console.log("I am eating!");
    }
}

• class 的 prototype 和 _proto_ 属性
  • 在 ES5 中，每个对象都有 __proto__ 属性，指向对应的构造函数的 prototype 属性
  • class 作为构造函数的语法糖，同时有 prototype 属性和 __proto__ 属性，因此同时存在两条继承链
    • 子类的 __proto__ 属性，表示构造函数的继承，总是指向父类
    • 子类的 prototype 属性的 __proto