深入理解ES6之Promise與異步編程

深入理解ES6之var,let,const區別
深入理解ES6之函數
深入理解ES6之對象
深入理解ES6之類
深入理解ES6之解構
深入理解ES6之模塊

一：異步編程背景：

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的返回值是異步的.