ES6第二部分

一 set数据结构

1. Set：里面存储的是值，并且值是唯一的，没有重复的（因此set可以对数组直接去重）。Set本身是一个构造函数；
2. 使用的时候：new；
3. Set的构造函数constructor 是自己的本身；
4. Size：属性，返回的是Set对象里面的成员变量；
5. add：方法，将值添加到Set里面；
6. delete：方法，删除某个值，返回true false；
7. has：方法，检测是否有某个值，返回true false；
8. clear：方法，清除所有的成员 没有返回值；
9. for of：遍历set对象；
10. foreach遍历set对象：

s.forEach((value,key)=>{
     console.log(value,key);
});

11. Array.from(set)： 将set集合转化为数组；
12. let […array]=[…set1]：将set集合拆为数组；
13. Set.prototype：针对set对象遍历的方法；
14. keys：返回set对象所有的键；
15. object对象不能直接存储set；
16. 在Set对象里面输出的keys和values的值一样；
17. set对象里面存储数组，不能直接存储键：值对象；
18. WeakSet,类似Set,也是唯一的,它里面可以存储数组和对象，WeakSet:成员必须是一个对象。==一维数组赋值直接报错，二维数组可以存储，==没有遍历的方法；
19. WeakSet：存储的是对象,对象会不定时消失,好处是不会造成内存的泄露；

二 map数据结构

1. Map数据结构存储的是,键值对；
   Map构造函数----不传参
2. size:返回map的长度的；
3. set:设置Map结构中的值的；
4. get:获取Map结构中的值；
5. has:检测键是否存在 返回true/false；
6. delete:删除键 返回true/false；
7. clear:全部清除；
8. map中不能直接写数组；
9. Map结构设置相同的键值会被覆盖,下面的array把上面的一维数据覆盖了；
10. map结构的遍历方法：
    keys：返回map所有的键，可以拆为数组；
    value：返回map中所有的值，可以拆为数组；
    entries：返回map中所有的键值对，可以拆为数组；
11. 遍历map：

map.forEach((value,key)=>{
        console.log(value,key);
    });

    for(let key of map.keys()){
        //console.log(key);
        console.log(map.get(key));//返回值
    };

    for(let val of map.entries()){
        //console.log(val);//返回键值对
        console.log(map.get(val[0]));//返回值
    };

12. map中可以直接放二维数组，一维不行，需要键和值。注意：map中必须有键值；
13. Map转换为对象：

let map=new Map();
    map.set("a1","a");
    map.set("a2","b");
    map.set("a3","c");
    map.set("a4","d");
    let obj={};
    for(let key of map.keys()){
        obj[key]=map.get(key);
    }
    console.log(JSON.stringify(obj));

三 Promise

Promise异步编程，在原生JS写过函数的回调函数、事件；Promise是一个容器，里面放未来或者异步即将发生的东西；Promise对象的三大状态不收外界影响，在内部的异步编程的结果会影响；

1. Promise对象的使用，也是一个构造函数，new；
2. resolve：成功,在异步操作成功的时候调用；
3. reject ：失败,在异步操作失败的时候调用；
4. promise对象的使用：then()，两个回调函数，第一个是resolve时候调用，第二个是reject时候调用。then方法存在原型对象上面，then方法返回的是一个promise对象，和之前的不一致，还可以继续点then；
5. all方法,将多个promise整合为一个对象,接收一个数组；
6. Promise.resolve() ：将现有的对象转换为promise对象；

四 async–异步函数，让异步编程更简单

1. 语法，构建async函数：内部等待执行多个promise对象执行，将多个promise对象进行包装，返回的是一个promise对象；
2. awate:等待；
3. 异步函数的执行方式和函数一致;
4. async函数里面等待多个promise对象执行:

        let promethod= function (ms) {
            return new Promise(function (resolve,reject) {
                setTimeout(resolve,ms,"成功");
            });
        }
        async function method(){
        console.log("开始");
        let p1=await promethod(1000);
        console.log("执行完一个");
        let p2=await promethod(1500);
        console.log("执行完2个");
        return{
            pro1:p1,
            pro2:p2
        }
    }

        method().then(function (res) {
            console.log(res);
        }).catch(function (err) {
            console.log(err);
        });

5. async里面的await连用:

        function addNum(num){
            return new Promise(function (resolve,reject) {
                if(true){
                    console.log(num * 100);
                }
            });
        }

        async function method(){
        let p1=await new Promise(function (resolve,reject) {
            if(false) {
                resolve(100);
            }
            else{
                reject("程序失败");
            }
        });
        let p2=await addNum(p1);
        return p2;
    }
        method().then(function (res) {
            console.log(res);
        }).catch(function (err) {
            console.log(err);
        }).finally(function () {
            console.log("在这里写后续");
        });

6. 抛异常:

async function method(){
        try{
            let p1=await new Promise();
            let p2=await new Promise();
            return p2;
        }
        catch(e){
            throw e;
        }
        finally{

        }
    }