ECMAscript 6 原生提供了 Promise 物件。Promise 物件代表了未來將要發生的事件，用來傳遞非同步操作的訊息，是非同步程式設計的一種解決方案。

Promise 物件有以下兩個特點:

1、物件的狀態不受外界影響。Promise 物件代表一個非同步操作，有三種狀態：

• pending: 初始狀態，不是成功或失敗狀態。
• fulfilled: 意味著操作成功完成。
• rejected: 意味著操作失敗。

只有非同步操作的結果，可以決定當前是哪一種狀態，任何其他操作都無法改變這個狀態。這也是 Promise 這個名字的由來，它的英語意思就是「承諾」，表示其他手段無法改變。

2、一旦狀態改變，就不會再變，任何時候都可以得到這個結果。Promise 物件的狀態改變，只有兩種可能：從 Pending 變為 Resolved 和從 Pending 變為 Rejected。只要這兩種情況發生，狀態就凝固了，不會再變了，會一直保持這個結果。就算改變已經發生了，你再對 Promise 物件添加回調函式，也會立即得到這個結果。這與事件（Event）完全不同，事件的特點是，如果你錯過了它，再去監聽，是得不到結果的。

Promise 優缺點

有了 Promise 物件，就可以將非同步操作以同步操作的流程表達出來，避免了層層巢狀的回撥函式。此外，Promise 物件提供統一的介面，使得控制非同步操作更加容易。

Promise 也有一些缺點。首先，無法取消 Promise，一旦新建它就會立即執行，無法中途取消。其次，如果不設定回撥函式，Promise 內部丟擲的錯誤，不會反應到外部。第三，當處於 Pending 狀態時，無法得知目前進展到哪一個階段（剛剛開始還是即將完成）。

Promise 建立

要想建立一個 promise 物件、可以使用 new 來呼叫 Promise 的構造器來進行例項化。

下面是建立 promise 的步驟：

var promise = new Promise(function(resolve, reject) {
    // 非同步處理
    // 處理結束後、呼叫resolve 或 reject
});

Promise 建構函式包含一個引數和一個帶有 resolve（解析）和 reject（拒絕）兩個引數的回撥。在回撥中執行一些操作（例如非同步），如果一切都正常，則呼叫 resolve，否則呼叫 reject。

var myFirstPromise = new Promise(function(resolve, reject){
    //當非同步程式碼執行成功時，我們才會呼叫resolve(...), 當非同步程式碼失敗時就會呼叫reject(...)
 

    //在本例中，我們使用setTimeout(...)來模擬非同步程式碼，實際編碼時可能是XHR請求或是HTML5的一些API方法.
    setTimeout(function(){
        resolve("成功!"); //程式碼正常執行！
    }, 250);
});
 
myFirstPromise.then(function(successMessage){
    //successMessage的值是上面呼叫resolve(...)方法傳入的值.
    //successMessage引數不一定非要是字串型別，這裡只是舉個例子
    document.write("Yay! " + successMessage);
});

對於已經例項化過的 promise 物件可以呼叫 promise.then() 方法，傳遞 resolve 和 reject 方法作為回撥。

promise.then() 是 promise 最為常用的方法。

promise.then(onFulfilled, onRejected)

promise簡化了對error的處理，上面的程式碼我們也可以這樣寫：

promise.then(onFulfilled).catch(onRejected)

Promise Ajax

下面是一個用 Promise 物件實現的 Ajax 操作的例子。

function ajax(URL) {
    return new Promise(function (resolve, reject) {
        var req = new XMLHttpRequest(); 
        req.open('GET', URL, true);
        req.onload = function () {
        if (req.status === 200) { 
                resolve(req.responseText);
            } else {
                reject(new Error(req.statusText));
            } 
        };
        req.onerror = function () {
            reject(new Error(req.statusText));
        };
        req.send(); 
    });
}
var URL = "/try/ajax/testpromise.do"; 
ajax(URL).then(function onFulfilled(value){
    document.write('內容是：' + value); 
}).catch(function onRejected(error){
    document.write('錯誤：' + error); 
});

上面程式碼中，resolve 方法和 reject 方法呼叫時，都帶有引數。它們的引數會被傳遞給回撥函式。reject 方法的引數通常是 Error 物件的例項，而 resolve 方法的引數除了正常的值以外，還可能是另一個 Promise 例項，比如像下面這樣。

var p1 = new Promise(function(resolve, reject){
  // ... some code
});
 
var p2 = new Promise(function(resolve, reject){
  // ... some code
  resolve(p1);
})

上面程式碼中，p1 和 p2 都是 Promise 的例項，但是 p2 的 resolve 方法將 p1 作為引數，這時 p1 的狀態就會傳遞給 p2。如果呼叫的時候，p1 的狀態是 pending，那麼 p2 的回撥函式就會等待 p1 的狀態改變；如果 p1 的狀態已經是 fulfilled 或者 rejected，那麼 p2 的回撥函式將會立刻執行。

Promise.prototype.then方法：鏈式操作

Promise.prototype.then 方法返回的是一個新的 Promise 物件，因此可以採用鏈式寫法。

getJSON("/posts.json").then(function(json) {
  return json.post;
}).then(function(post) {
  // proceed
});

上面的程式碼使用 then 方法，依次指定了兩個回撥函式。第一個回撥函式完成以後，會將返回結果作為引數，傳入第二個回撥函式。

如果前一個回撥函式返回的是Promise物件，這時後一個回撥函式就會等待該Promise物件有了執行結果，才會進一步呼叫。

getJSON("/post/1.json").then(function(post) {
  return getJSON(post.commentURL);
}).then(function(comments) {
  // 對comments進行處理
});

這種設計使得巢狀的非同步操作，可以被很容易得改寫，從回撥函式的"橫向發展"改為"向下發展"。

Promise.prototype.catch方法：捕捉錯誤

Promise.prototype.catch 方法是 Promise.prototype.then(null, rejection) 的別名，用於指定發生錯誤時的回撥函式。

getJSON("/posts.json").then(function(posts) {
  // some code
}).catch(function(error) {
  // 處理前一個回撥函式執行時發生的錯誤
  console.log('發生錯誤！', error);
});

Promise 物件的錯誤具有"冒泡"性質，會一直向後傳遞，直到被捕獲為止。也就是說，錯誤總是會被下一個 catch 語句捕獲。

getJSON("/post/1.json").then(function(post) {
  return getJSON(post.commentURL);
}).then(function(comments) {
  // some code
}).catch(function(error) {
  // 處理前兩個回撥函式的錯誤
});

Promise.all方法，Promise.race方法

Promise.all 方法用於將多個 Promise 例項，包裝成一個新的 Promise 例項。

var p = Promise.all([p1,p2,p3]);

上面程式碼中，Promise.all 方法接受一個數組作為引數，p1、p2、p3 都是 Promise 物件的例項。（Promise.all 方法的引數不一定是陣列，但是必須具有 iterator 介面，且返回的每個成員都是 Promise 例項。）

p 的狀態由 p1、p2、p3 決定，分成兩種情況。

• （1）只有p1、p2、p3的狀態都變成fulfilled，p的狀態才會變成fulfilled，此時p1、p2、p3的返回值組成一個數組，傳遞給p的回撥函式。
• （2）只要p1、p2、p3之中有一個被rejected，p的狀態就變成rejected，此時第一個被reject的例項的返回值，會傳遞給p的回撥函式。

下面是一個具體的例子。

// 生成一個Promise物件的陣列
var promises = [2, 3, 5, 7, 11, 13].map(function(id){
  return getJSON("/post/" + id + ".json");
});
 
Promise.all(promises).then(function(posts) {
  // ...  
}).catch(function(reason){
  // ...
});

Promise.race 方法同樣是將多個 Promise 例項，包裝成一個新的 Promise 例項。

var p = Promise.race([p1,p2,p3]);

上面程式碼中，只要p1、p2、p3之中有一個例項率先改變狀態，p的狀態就跟著改變。那個率先改變的Promise例項的返回值，就傳遞給p的返回值。

如果Promise.all方法和Promise.race方法的引數，不是Promise例項，就會先呼叫下面講到的Promise.resolve方法，將引數轉為Promise例項，再進一步處理。

Promise.resolve 方法，Promise.reject 方法

有時需要將現有物件轉為Promise物件，Promise.resolve方法就起到這個作用。

var jsPromise = Promise.resolve($.ajax('/whatever.json'));

上面程式碼將 jQuery 生成 deferred 物件，轉為一個新的 ES6 的 Promise 物件。

如果 Promise.resolve 方法的引數，不是具有 then 方法的物件（又稱 thenable 物件），則返回一個新的 Promise 物件，且它的狀態為fulfilled。

var p = Promise.resolve('Hello');
 
p.then(function (s){
  console.log(s)
});
// Hello

上面程式碼生成一個新的Promise物件的例項p，它的狀態為fulfilled，所以回撥函式會立即執行，Promise.resolve方法的引數就是回撥函式的引數。

如果Promise.resolve方法的引數是一個Promise物件的例項，則會被原封不動地返回。

Promise.reject(reason)方法也會返回一個新的Promise例項，該例項的狀態為rejected。Promise.reject方法的引數reason，會被傳遞給例項的回撥函式。

var p = Promise.reject('出錯了');
 
p.then(null, function (s){
  console.log(s)
});
// 出錯了

上面程式碼生成一個Promise物件的例項，狀態為rejected，回撥函式會立即執行。