一：異步編程背景：

JS引擎建立在單線程事件循環(huán)的概念上，js引擎同一時間只能執(zhí)行一段代碼，每當一段代碼準備被執(zhí)行，他就會被添加到作業(yè)隊列。當JS引擎結(jié)束當前代碼的執(zhí)行后，事件循環(huán)就會執(zhí)行隊列的下一個作業(yè)。作業(yè)會從隊列的第一個開始，一次運行到最后一個。
之前普遍使用的異步方式是回調(diào)模式。這種模式運作的很好，但是如果嵌套過多，就會讓人覺得很麻煩。

     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);
                    })

                })
            })
        })

在上述例子下回調(diào)會創(chuàng)建復雜的代碼，讓人難以理解.

二：Promise基礎(chǔ)：

Promise出現(xiàn)可以解決回調(diào)地獄的問題。

promise就是一個承諾，js承諾會在未來某個時刻返回結(jié)果。

Promise使用
1：使用promise構(gòu)造函數(shù)創(chuàng)建新的promise

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

2:可以創(chuàng)建已決的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鏈式調(diào)用

     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()方法：
接收一個數(shù)組作為參數(shù)，只有他們都完成后，返回的Promise才會被完成。

 //結(jié)果是一個數(shù)組
    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就會返回。

  //結(jié)果是第一個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環(huán)境下：
正常情況下我們使用catch去捕獲異常。

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

unhandledRejection：當一個promise被拒絕，而在事件循環(huán)的一個輪次中沒有任何拒絕處理函數(shù)被調(diào)用，改事件就會被觸發(fā)；

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被拒絕，并在事件循環(huán)的一個輪次之后再由拒絕處理函數(shù)被調(diào)用，該事件就會被觸發(fā)。

let rejected;
process.on("rejectionHandled",function(promise){
console.log(rejected===promise);
})
rejected = Promise.reject(new Error("this is wrong"));
//延遲添加拒絕處理函數(shù)
setTimeout(function(){
     rejected.catch(function(value){
     console.log(value.message)})
},2000)

此處的rejectionHandled事件在拒絕處理函數(shù)被調(diào)用時觸發(fā)。若在rejected唄創(chuàng)建后直接將拒絕處理函數(shù)附件到它上面，那么此事件不會觸發(fā)。因為立即附加的拒絕處理函數(shù)在rejected被創(chuàng)建的事件循環(huán)的同一個輪次內(nèi)就會被調(diào)用。這樣rejectionHandled就不會起作用。

四：Promise和異步的聯(lián)系：

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