一.Symbol

1.ES5，ES6,ES2015的区别
ES2015特指在2015年发布的JS语言标准，ES6是一个泛指,泛指下一代JS语言标准，包含ES2015、ES2016、ES2017、ES2018等。ES5泛指上一代语言标准。ES2015可以理解为ES5和ES6的时间分界线。
ES6代表着 JS 这门语言最新的标准，是非常有必要学习的。目前以Chrome为首的现代浏览器已经基本实现了ES6的大多数新特性，即使在不支持ES6的浏览器上，开发者也可以通过转译工具如Babel将ES6代码转译为ES5代码来实现兼容。
ES6 引入了一种新的原始数据类型Symbol，表示独一无二的值。它是 JavaScript 语言的第七种数据类型，前六种是：undefined、null、Boolean、String、Number、Object
直接调用Symbol函数即可生成一个Symbol，注意Symbol函数前不能使用new命令，否则会报错。
Symbol函数可以接受一个字符串作为参数，表示对 Symbol 的描述，主要是为了比较容易区分。
2.Symbol的唯一性

Symbol函数的参数只是表示对当前 Symbol 值的描述，因此相同参数的Symbol函数的返回值是不相等的。

        let s1 = Symbol();let s2 = Symbol();s1 === s2 // falselet s1 = Symbol('foo');let s2 = Symbol('foo');s1 === s2 // false

3.Symbol作为属性
Object.getOwnPropertySymbols方法，可以获取指定对象的所有 Symbol 属性名。

        var a = {};var mysymbol = Symbol("uname");// var a={                       //第一种//     [mysymbol]:"aaa"// };// a[mysymbol]="anjiang";       //第二种Object.defineProperty(a, mysymbol, { value: "ssss" });    //第三种console.log(a);//获取对象的属性名console.log(Object.getOwnPropertySymbols(a));

4.Symbol.for
Symbol.for()与Symbol()这两种写法，都会生成新的 Symbol。它们的区别是，前者会被登记在全局环境中供搜索，后者不会。

       var s1 = Symbol("aaa");var s2 = Symbol.for("aaa");console.log(s1 == s2);//falselet s1 = Symbol.for('foo');let s2 = Symbol.for('foo');s1 === s2 // true

5.实现私有属性

    //获取私有属性，对象不能通过属性来获取到属性值，只能通过内部的方法获取到var Person=(function(){var mysymbol=Symbol("uname");function Person(uname){this[mysymbol]=uname;      }Person.prototype.getName=function(){return this[mysymbol];}return Person;})();缺陷：仍然会被Object.getOwnPropertySymbols获取到属性，进而修改该属性对应的值

6.消除魔术字符串
常用的消除魔术字符串的方法，就是把它写成一个变量。

   var type={"Triangle":Symbol(),"Triangle1":Symbol()}function getArea(shape, options) {let area = 0;switch (shape) {case type.Triangle: // 魔术字符串area = .5 * options.width * options.height;break;}return area;}getArea(type.Triangle1, { width: 100, height: 100 }); // 魔术字符串

二，Set和WeakSet

1.Set
ES6 提供了新的数据结构 Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。
用途：数组去重

        var s = new Set();s.add(1).add(2).add(3)console.log(s.size);s.delete(1)// s.clear()console.log(s.size);var a = NaN;var b = NaN;var s1 = new Set();s1.add(a).add(b);console.log(s1);//也会把NaN去重console.log(a == b);//false  注意：js当中自己不等于自己的NaN//遍历方法// Set.prototype.keys()// Set.prototype.values()// Set.prototype.entries()// Set.prototype.forEach()// 注意：Set实例中key和value是一样的，所以keys()和values()这两个方法的结果是一样的s.forEach((key, value) => {console.log(key, value);})for(var key of s.keys()){console.log(key);}//使用Set来去重let arr=[1,1,2,3,4,4]let temp = [...(new Set(arr))]console.log(temp);

2.weakSet
WeakSet 结构与 Set 类似，也是不重复的值的集合。但是，它与 Set 有两个区别。
（1）WeakSet 的成员只能是对象，而不能是其他类型的值。（2）WeakSet 中的对象都是弱引用。
垃圾回收机制：如果一个对象没有任何引用，那么此对象会尽快被垃圾回收，释放掉它占用的内存。但是，垃圾回收机制不考虑 WeakSet 对该对象的引用,所以他是弱引用.
注意：WeakSet 不能遍历，是因为成员都是弱引用，随时可能消失

        let div = document.querySelector('div')let set = new Set()set.add(div)document.body.removeChild(div)div = null //dom对象仍在内存中，因为Set中仍然引用此对象let div = document.querySelector('div')let weakset = new WeakSet()weakset.add(div)document.body.removeChild(div)div=null;//dom对象的已经没有引用，将被垃圾回收机制回收

三，Map和WeakMap

四， Proxy

Proxy 可以理解成在目标对象之前架设一层的“拦截”。外界对该Proxy对象的访问，都必须先通过这层拦截，可以对外界的访问进行过滤和改写。
注意：只有对生成的 Proxy 实例操作才能起到拦截的作用

       var obj = {uname: "aaa",age: 11}var handle = {//阻止访问私有属性(get)get: function (target, prop) {if (prop == "age") {console.log("not set value");}},//set拦截器set: function (target, prop, value) {console.log("set");}}var proxy = new Proxy(obj, handle);//    proxy.age=100;console.log(proxy.age)

下面是 Proxy 支持的拦截操作一览，一共 13 种。

 let obj = {uname:"aaa",age:12}let func = function () {}let proxy = new Proxy(func, {get(target, key, receiver) {   //拦截对象属性的读取    proxy.unameconsole.log(`get拦截 ${key}!`);},set(target, key, value, receiver) {  //拦截对象属性的设置   proxy.uname="bbb"console.log(`set拦截 ${key}!`);},has(target, propKey) {   //判断对象中是否有这个属性    propKey in Proxy       返回布尔值console.log('has拦截'); },deleteProperty(target, propKey) {  //删除对象中的某个属性   delete proxy[propKey]   返回布尔console.log('deleteProperty拦截');},ownKeys(target) {   //拦截 Object.getOwnPropertyNames(proxy) Object.getOwnPropertySymbols(proxy)  Object.keys(proxy)  for in循环console.log('ownKeys拦截');return []  //必须加这个},apply(target, object, args) {   //拦截Proxy实例作为函数调用的操作   proxy()   proxy.call()   proxy.apply()console.log('apply拦截');},getOwnPropertyDescriptor(target, propKey) {console.log('getOwnPropertyDescriptor拦截');},defineProperty(target, propKey, propDesc) {console.log('defineProperty拦截');return true},getPrototypeOf(target) {console.log('getPrototypeOf拦截');return {}},setPrototypeOf(target, proto) {console.log('setPrototypeOf拦截');return true},construct(target, args) {console.log('construct拦截');return {}},isExtensible(target) {console.log('isExtensible拦截');},preventExtensions(target) {console.log('preventExtensions拦截');},});

Proxy给了开发者拦截语言默认行为的权限，可以不改变原有对象或函数的情况下，轻松运用在很多场景。例如：统计函数调用次数，实现响应式数据观测（Vue 3.0），实现不可变数据（Immutable）等等

五，Reflect

Reflect是 ES6 为了操作对象而提供的新 API。
将Object对象的方法（比如Object.defineProperty），放到Reflect对象上

let target = {}let property = 'a'Object.defineProperty(target,property,{configurable:false,   //给对象配置的属性，是不可以再次修改的value:1})//// // 老写法try {Object.defineProperty(target, property,{   //用来捕获错误configurable:true,});// success} catch (e) {// failureconsole.log('错误',e);}//// // 新写法if (Reflect.defineProperty(target, property,{    //返回是一个布尔值configurable:true,})) {// success} else {console.log('reflect失败');// failure}

// 老写法
'assign' in Object // true// 新写法
Reflect.has(Object, 'assign') // true

六，Iterator

七， Generator函数

八，async函数的概念、用法和用途