一：异步编程背景：

JS引擎建立在单线程事件循环的概念上，js引擎同一时间只能执行一段代码，每当一段代码准备被执行，他就会被添加到作业队列。当JS引擎结束当前代码的执行后，事件循环就会执行队列的下一个作业。作业会从队列的第一个开始，一次运行到最后一个。
之前普遍使用的异步方式是回调模式。这种模式运作的很好，但是如果嵌套过多，就会让人觉得很麻烦。

     methcod1(function(err,result){
            if(err){
                throw err;
            }
            mothod2(function(err,result){
                if(err){
                    throw err;
                }
                mothod3(function(err,result){
                    if(err){
                        throw err;
                    }
                    mothod4(function(err,result){
                        if(err){
                            throw err;
                        }
                        mothod5(result);
                    })

                })
            })
        })

在上述例子下回调会创建复杂的代码，让人难以理解.

二：Promise基础：

Promise出现可以解决回调地狱的问题。

promise就是一个承诺，js承诺会在未来某个时刻返回结果。

Promise使用
1：使用promise构造函数创建新的promise

new Promise(function(resolve,reject){
setTimeout(()=>{resolve(10)},100)}).then(v=>console.log(v))//10

2:可以创建已决的Promise

 Promise.resolve(5).then(v => console.log(v)) // 5
 Promise.reject(5).catch(v => console.log(v)) // 5

3:通过catch捕获异常

   new Promise(function(resolve, reject) {
        if(true) {
           throw new Error('error!!')
        }
    }).catch(v => console.log(v.message)) // error!!

4:promise链式调用

     new Promise((resolve, reject) => {
            if (xxx) {
                resolve("haha");
            } else {
                reject("this is wrong")
            }
        }).then((value) => {
            return "Hi " + value
        }).then((value) => {
            return " welcome!"
        }).catch((err) => {
            console.log(err.message)
        })

5:Promise.all()方法：
接收一个数组作为参数，只有他们都完成后，返回的Promise才会被完成。

 //结果是一个数组
    Promise.all([
            new Promise(((resolve, reject) => resolve(1))),
            new Promise(((resolve, reject) => resolve(2))),
            new Promise(((resolve, reject) => resolve(3))),
        ]).then(arr=>{
            console.log(arr)//[1,2,3]
        })

6:Promise.race()方法
与Promise.all类似，Promise.race是只要有一个promise被解决了，Promise.race就会返回。

  //结果是第一个promise返回的值
     Promise.race([
            new Promise(((resolve, reject) => {
                setTimeout(()=>{resolve(1)},1000)
            })),
            new Promise(((resolve, reject) => {
                setTimeout(()=>{resolve(1)},2000)
            })),
            new Promise(((resolve, reject) => resolve(3))),
        ]).then(arr=>{
            console.log(arr)// 3
        })

三：全局的Promise拒绝处理：

node环境下：
正常情况下我们使用catch去捕获异常。

Promise.reject("this is wrong").catch(err=>console.log(err))

unhandledRejection：当一个promise被拒绝，而在事件循环的一个轮次中没有任何拒绝处理函数被调用，改事件就会被触发；

let rejected = Promise.reject("this is wrong")
process.on("unhandledRejection",function(reason,promise){
console.log(reason.message) //"this is wrong"
console.log(rejected === promise) //true
})

rejectionHandled:若一个Promise被拒绝，并在事件循环的一个轮次之后再由拒绝处理函数被调用，该事件就会被触发。

let rejected;
process.on("rejectionHandled",function(promise){
console.log(rejected===promise);
})
rejected = Promise.reject(new Error("this is wrong"));
//延迟添加拒绝处理函数
setTimeout(function(){
     rejected.catch(function(value){
     console.log(value.message)})
},2000)

此处的rejectionHandled事件在拒绝处理函数被调用时触发。若在rejected呗创建后直接将拒绝处理函数附件到它上面，那么此事件不会触发。因为立即附加的拒绝处理函数在rejected被创建的事件循环的同一个轮次内就会被调用。这样rejectionHandled就不会起作用。

四：Promise和异步的联系：

Promise本身不是异步的，只有他的then()或者catch()方法才是异步的，也可以说Promise的返回值是异步的.