ES6知识点

兼容性：目前各大浏览器都支持ES6的新特性，IE7~11基本不支持ES6；

let和const：
let 为变量，块级作用域，并且可选的将其初始化为一个值；
const 为常量，非常类似用let变量，常量的值是无法（通过重新赋值）改变的，也不能重新声明；
创建一个值的只读引用。但不意味着所持有的值是不可变的，只是变量标识符不能重新分配。比如在引用的内容是对象情况下，可以修改对象的内容；
常量声明需要一个初始值，否则会报错；
共同特点：
块级作用域
不能重复声明
不存在变量提升
暂存死区

解构赋值：是对赋值运算符的扩展，一种针对数组或者对象进行模式匹配，然后对其中的变量进行赋值。

数组解构
let [a, b, c] = [1, 2, 3];
// a = 1
// b = 2
// c = 3

let [a, [[b], c]] = [1, [[2], 3]];
// a = 1
// b = 2
// c = 3

let [a, , b] = [1, 2, 3];
// a = 1
// b = 3

let [a = 1, b] = []; // a = 1, b = undefined

let [a, ...b] = [1, 2, 3];
//a = 1
//b = [2, 3]

对象解构
let { foo, bar } = { foo: 'aaa', bar: 'bbb' };
// foo = 'aaa'
// bar = 'bbb'
 
let { baz : foo } = { baz : 'ddd' };
// foo = 'ddd'

let obj = {p: ['hello', {y: 'world'}] };
let {p: [x, { y }] } = obj;
// x = 'hello'
// y = 'world'
let obj = {p: ['hello', {y: 'world'}] };
let {p: [x, {  }] } = obj;
// x = 'hello'

let obj = {p: [{y: 'world'}] };
let {p: [{ y }, x ] } = obj;
// x = undefined
// y = 'world'

let {a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40};
// a = 10
// b = 20
// rest = {c: 30, d: 40}

let {a = 10, b = 5} = {a: 3};
// a = 3; b = 5;
let {a: aa = 10, b: bb = 5} = {a: 3};
// aa = 3; bb = 5;

Symbol一种基本数据类型，其值都是唯一的；

Map对象保存键值对，并且能够记住键的原始插入顺序。任何值（对象或者原始值）都可以作为一个键或者一个值。
object和map类似的是，都允许你按键存取一个值、删除键、检测一个键是否绑定了值。

const map1 = new Map();
map1.set('a', 1);
map1.set('b', 2);
map1.set('c', 3);
console.log(map1.get('a'));
// expected output: 1

map1.set('a', 97);
console.log(map1.get('a'));
// expected output: 97

console.log(map1.size);
// expected output: 3

map1.delete('b');
console.log(map1.size);
// expected output: 2

Proxy 对象用于创建一个对象的代理，从而实现基本操作的拦截和自定义（如属性查找、赋值、枚举、函数调用等）。
不是直接操作对象，而是像代理模式，通过对象的代理对象进行操作，在进行这些操作时，可以添加一些需要的额外操作。
术语：
handler (en-US)：包含捕捉器的占位符对象，可译为处理器对象。
traps：提供属性访问的方法。这类似于操作系统中捕获器的概念。
target：被 Proxy 代理虚拟化的对象。它常被作为代理的存储后端。根据目标验证关于对象不可扩展性或不可配置属性的不变量（保持不变的语义）。
语法：
const p = new Proxy(target, handler)
两个属性：
target：要使用Proxy包装的目标对象（可以是任何类型的对象，包括原生数组，函数，甚至另一个代理）
handler：一个通常以函数作为属性的对象，各属性中的函数分别定义了在执行各种操作时代理p的行为。

let target = {
    name: 'Tom',
    age: 24
}
let handler = {
    get: function(target, key) {
        console.log('getting '+key);
        return target[key]; // 不是target.key
    },
    set: function(target, key, value) {
        console.log('setting '+key);
        target[key] = value;
    }
}
let proxy = new Proxy(target, handler)
proxy.name     // 实际执行 handler.get
proxy.age = 25 // 实际执行 handler.set
console.log(target)
// getting name
// setting age
// 25
//{name: 'Tom', age: 25}

模板字符串相当于加强版的字符串，用反引号 `,除了作为普通字符串，还可以用来定义多行字符串，还可以在字符串中加入变量和表达式。

let name = "Jia";
let age = 26;
let info = `My Name is ${name},I am ${age+1} years old next year.`
console.log(info);
// My Name is Jia,I am 27 years old next year.

对象字面量简写

const person = {
  sayHi(){
    console.log("Hi");
  }
}
person.sayHi();  //"Hi"
//等同于
const person = {
  sayHi:function(){
    console.log("Hi");
  }
}
person.sayHi();//"Hi"

对象的扩展运算符，assign的属性拷贝是浅拷贝
Object.assign(target, source_1, ···)

let target = {a: 1};
let object2 = {b: 2};
let object3 = {c: 3};
Object.assign(target,object2,object3);  
// 第一个参数是目标对象，后面的参数是源对象
target;  // {a: 1, b: 2, c: 3}

模块：export 与 import
export 用于从模块中导出实时绑定的函数、对象或者原始值，以便import引入；
import 命令会提升到整个模块的头部，首先执行。

async和await ，这两个一般都是配合使用将异步改成同步。

这有另外出详细
箭头函数：语法比函数表达式更简洁，并且没有自己的this，arguments，super或new.target。箭头函数表达式更适用于那些本来需要匿名函数的地方，并且它不能用作构造函数。
Promise：对象用于表示一个异步操作的最终完成 (或失败)及其结果值。