作者：呂大豹
連結：https://www.cnblogs.com/lvdabao/p/es6-promise-1.html

2015年6月份， ES2015正式釋出（也就是ES6，ES6是它的乳名），其中Promise被列為正式規範。作為ES6中最重要的特性之一，我們有必要掌握並理解透徹。本文將由淺到深，講解Promise的基本概念與使用方法。

ES6 Promise 先拉出來遛遛

複雜的概念先不講，我們先簡單粗暴地把Promise用一下，有個直觀感受。那麼第一個問題來了，Promise是什麼玩意呢？是一個類？物件？陣列？函式？

別猜了，直接打印出來看看吧，console.dir(Promise)，就這麼簡單粗暴。

這麼一看就明白了，Promise是一個建構函式，自己身上有all、reject、resolve這幾個眼熟的方法，原型上有then、catch等同樣很眼熟的方法。這麼說用Promise new出來的物件肯定就有then、catch方法嘍，沒錯。

那就new一個玩玩吧。

1. var p = new Promise(function(resolve, reject){
2. //做一些非同步操作
3. setTimeout(function(){
4. console.log('執行完成');
5. resolve('隨便什麼資料');
6. }, 2000);
7. });

Promise的建構函式接收一個引數，是函式，並且傳入兩個引數：resolve，reject，分別表示非同步操作執行成功後的回撥函式和非同步操作執行失敗後的回撥函式。其實這裡用“成功”和“失敗”來描述並不準確，按照標準來講，resolve是將Promise的狀態置為fullfiled，reject是將Promise的狀態置為rejected。不過在我們開始階段可以先這麼理解，後面再細究概念。

在上面的程式碼中，我們執行了一個非同步操作，也就是setTimeout，2秒後，輸出“執行完成”，並且呼叫resolve方法。

執行程式碼，會在2秒後輸出“執行完成”。注意！我只是new了一個物件，並沒有呼叫它，我們傳進去的函式就已經執行了，這是需要注意的一個細節。所以我們用Promise的時候一般是包在一個函式中，在需要的時候去執行這個函式，如：

1. function runAsync(){
2. var p = new Promise(function(resolve, reject){
3. //做一些非同步操作
4. setTimeout(function(){
5. console.log('執行完成');
6. resolve('隨便什麼資料');
7. }, 2000);
8. });
9. return p;
10. }
11. runAsync()

這時候你應該有兩個疑問：1.包裝這麼一個函式有毛線用？2.resolve('隨便什麼資料');這是幹毛的？

我們繼續來講。在我們包裝好的函式最後，會return出Promise物件，也就是說，執行這個函式我們得到了一個Promise物件。還記得Promise物件上有then、catch方法吧？這就是強大之處了，看下面的程式碼：

1. runAsync().then(function(data){
2. console.log(data);
3. //後面可以用傳過來的資料做些其他操作
4. //......
5. });

在runAsync()的返回上直接呼叫then方法，then接收一個引數，是函式，並且會拿到我們在runAsync中呼叫resolve時傳的的引數。執行這段程式碼，會在2秒後輸出“執行完成”，緊接著輸出“隨便什麼資料”。

這時候你應該有所領悟了，原來then裡面的函式就跟我們平時的回撥函式一個意思，能夠在runAsync這個非同步任務執行完成之後被執行。這就是Promise的作用了，簡單來講，就是能把原來的回撥寫法分離出來，在非同步操作執行完後，用鏈式呼叫的方式執行回撥函式。

你可能會不屑一顧，那麼牛逼轟轟的Promise就這點能耐？我把回撥函式封裝一下，給runAsync傳進去不也一樣嗎，就像這樣：

1. function runAsync(callback){
2. setTimeout(function(){
3. console.log('執行完成');
4. callback('隨便什麼資料');
5. }, 2000);
6. }
8. runAsync(function(data){
9. console.log(data);
10. });

效果也是一樣的，還費勁用Promise幹嘛。那麼問題來了，有多層回撥該怎麼辦？如果callback也是一個非同步操作，而且執行完後也需要有相應的回撥函式，該怎麼辦呢？總不能再定義一個callback2，然後給callback傳進去吧。而Promise的優勢在於，可以在then方法中繼續寫Promise物件並返回，然後繼續呼叫then來進行回撥操作。

鏈式操作的用法

所以，從表面上看，Promise只是能夠簡化層層回撥的寫法，而實質上，Promise的精髓是“狀態”，用維護狀態、傳遞狀態的方式來使得回撥函式能夠及時呼叫，它比傳遞callback函式要簡單、靈活的多。所以使用Promise的正確場景是這樣的：

1. runAsync1()
2. .then(function(data){
3. console.log(data);
4. return runAsync2();
5. })
6. .then(function(data){
7. console.log(data);
8. return runAsync3();
9. })
10. .then(function(data){
11. console.log(data);
12. });

這樣能夠按順序，每隔兩秒輸出每個非同步回撥中的內容，在runAsync2中傳給resolve的資料，能在接下來的then方法中拿到。執行結果如下：

猜猜runAsync1、runAsync2、runAsync3這三個函式都是如何定義的？沒錯，就是下面這樣（程式碼較長請自行展開）：

1. function runAsync1(){
2. var p = new Promise(function(resolve, reject){
3. //做一些非同步操作
4. setTimeout(function(){
5. console.log('非同步任務1執行完成');
6. resolve('隨便什麼資料1');
7. }, 1000);
8. });
9. return p;
10. }
11. function runAsync2(){
12. var p = new Promise(function(resolve, reject){
13. //做一些非同步操作
14. setTimeout(function(){
15. console.log('非同步任務2執行完成');
16. resolve('隨便什麼資料2');
17. }, 2000);
18. });
19. return p;
20. }
21. function runAsync3(){
22. var p = new Promise(function(resolve, reject){
23. //做一些非同步操作
24. setTimeout(function(){
25. console.log('非同步任務3執行完成');
26. resolve('隨便什麼資料3');
27. }, 2000);
28. });
29. return p;
30. }

在then方法中，你也可以直接return資料而不是Promise物件，在後面的then中就可以接收到資料了，比如我們把上面的程式碼修改成這樣：

1. runAsync1()
2. .then(function(data){
3. console.log(data);
4. return runAsync2();
5. })
6. .then(function(data){
7. console.log(data);
8. return '直接返回資料'; //這裡直接返回資料
9. })
10. .then(function(data){
11. console.log(data);
12. });

那麼輸出就變成了這樣：

reject的用法

到這裡，你應該對“Promise是什麼玩意”有了最基本的瞭解。那麼我們接著來看看ES6的Promise還有哪些功能。我們光用了resolve，還沒用reject呢，它是做什麼的呢？事實上，我們前面的例子都是隻有“執行成功”的回撥，還沒有“失敗”的情況，reject的作用就是把Promise的狀態置為rejected，這樣我們在then中就能捕捉到，然後執行“失敗”情況的回撥。看下面的程式碼。

1. function getNumber(){
2. var p = new Promise(function(resolve, reject){
3. //做一些非同步操作
4. setTimeout(function(){
5. var num = Math.ceil(Math.random()*10); //生成1-10的隨機數
6. if(num<=5){
7. resolve(num);
8. }
9. else{
10. reject('數字太大了');
11. }
12. }, 2000);
13. });
14. return p;
15. }
17. getNumber()
18. .then(
19. function(data){
20. console.log('resolved');
21. console.log(data);
22. },
23. function(reason, data){
24. console.log('rejected');
25. console.log(reason);
26. }
27. );

getNumber函式用來非同步獲取一個數字，2秒後執行完成，如果數字小於等於5，我們認為是“成功”了，呼叫resolve修改Promise的狀態。否則我們認為是“失敗”了，呼叫reject並傳遞一個引數，作為失敗的原因。

執行getNumber並且在then中傳了兩個引數，then方法可以接受兩個引數，第一個對應resolve的回撥，第二個對應reject的回撥。所以我們能夠分別拿到他們傳過來的資料。多次執行這段程式碼，你會隨機得到下面兩種結果：

或者

catch的用法

我們知道Promise物件除了then方法，還有一個catch方法，它是做什麼用的呢？其實它和then的第二個引數一樣，用來指定reject的回撥，用法是這樣：

1. getNumber()
2. .then(function(data){
3. console.log('resolved');
4. console.log(data);
5. })
6. .catch(function(reason){
7. console.log('rejected');
8. console.log(reason);
9. });

效果和寫在then的第二個引數裡面一樣。不過它還有另外一個作用：在執行resolve的回撥（也就是上面then中的第一個引數）時，如果丟擲異常了（程式碼出錯了），那麼並不會報錯卡死js，而是會進到這個catch方法中。請看下面的程式碼：

1. getNumber()
2. .then(function(data){
3. console.log('resolved');
4. console.log(data);
5. console.log(somedata); //此處的somedata未定義
6. })
7. .catch(function(reason){
8. console.log('rejected');
9. console.log(reason);
10. });

在resolve的回撥中，我們console.log(somedata);而somedata這個變數是沒有被定義的。如果我們不用Promise，程式碼執行到這裡就直接在控制檯報錯了，不往下運行了。但是在這裡，會得到這樣的結果：

也就是說進到catch方法裡面去了，而且把錯誤原因傳到了reason引數中。即便是有錯誤的程式碼也不會報錯了，這與我們的try/catch語句有相同的功能。

all的用法

Promise的all方法提供了並行執行非同步操作的能力，並且在所有非同步操作執行完後才執行回撥。我們仍舊使用上面定義好的runAsync1、runAsync2、runAsync3這三個函式，看下面的例子：

1. Promise
2. .all([runAsync1(), runAsync2(), runAsync3()])
3. .then(function(results){
4. console.log(results);
5. });

用Promise.all來執行，all接收一個數組引數，裡面的值最終都算返回Promise物件。這樣，三個非同步操作的並行執行的，等到它們都執行完後才會進到then裡面。那麼，三個非同步操作返回的資料哪裡去了呢？都在then裡面呢，all會把所有非同步操作的結果放進一個數組中傳給then，就是上面的results。所以上面程式碼的輸出結果就是：

有了all，你就可以並行執行多個非同步操作，並且在一個回撥中處理所有的返回資料，是不是很酷？有一個場景是很適合用這個的，一些遊戲類的素材比較多的應用，開啟網頁時，預先載入需要用到的各種資源如圖片、flash以及各種靜態檔案。所有的都載入完後，我們再進行頁面的初始化。

race的用法

all方法的效果實際上是「誰跑的慢，以誰為準執行回撥」，那麼相對的就有另一個方法「誰跑的快，以誰為準執行回撥」，這就是race方法，這個詞本來就是賽跑的意思。race的用法與all一樣，我們把上面runAsync1的延時改為1秒來看一下：

1. Promise
2. .race([runAsync1(), runAsync2(), runAsync3()])
3. .then(function(results){
4. console.log(results);
5. });

這三個非同步操作同樣是並行執行的。結果你應該可以猜到，1秒後runAsync1已經執行完了，此時then裡面的就執行了。結果是這樣的：

你猜對了嗎？不完全，是吧。在then裡面的回撥開始執行時，runAsync2()和runAsync3()並沒有停止，仍舊再執行。於是再過1秒後，輸出了他們結束的標誌。

這個race有什麼用呢？使用場景還是很多的，比如我們可以用race給某個非同步請求設定超時時間，並且在超時後執行相應的操作，程式碼如下：

1. //請求某個圖片資源
2. function requestImg(){
3. var p = new Promise(function(resolve, reject){
4. var img = new Image();
5. img.onload = function(){
6. resolve(img);
7. }
8. img.src = 'xxxxxx';
9. });
10. return p;
11. }
13. //延時函式，用於給請求計時
14. function timeout(){
15. var p = new Promise(function(resolve, reject){
16. setTimeout(function(){
17. reject('圖片請求超時');
18. }, 5000);
19. });
20. return p;
21. }
23. Promise
24. .race([requestImg(), timeout()])
25. .then(function(results){
26. console.log(results);
27. })
28. .catch(function(reason){
29. console.log(reason);
30. });

requestImg函式會非同步請求一張圖片，我把地址寫為"xxxxxx"，所以肯定是無法成功請求到的。timeout函式是一個延時5秒的非同步操作。我們把這兩個返回Promise物件的函式放進race，於是他倆就會賽跑，如果5秒之內圖片請求成功了，那麼遍進入then方法，執行正常的流程。如果5秒鐘圖片還未成功返回，那麼timeout就跑贏了，則進入catch，報出“圖片請求超時”的資訊。執行結果如下：

總結

ES6 Promise的內容就這些嗎？是的，能用到的基本就這些。

我怎麼還見過done、finally、success、fail等，這些是啥？這些並不在Promise標準中，而是我們自己實現的語法糖。

本文中所有非同步操作均以setTimeout為例子，之所以不使用ajax是為了避免引起混淆，因為談起ajax，很多人的第一反應就是jquery的ajax，而jquery又有自己的Promise實現。如果你理解了原理，就知道使用setTimeout和使用ajax是一樣的意思。說起jquery，我不得不吐槽一句，jquery的Promise實現太過垃圾，各種語法糖把人都搞蒙了，我認為Promise之所以沒有全面普及和jquery有很大的關係。後面我們會細講jquery。

作者：呂大豹
連結：https://www.cnblogs.com/lvdabao/p/es6-promise-1.html