JavaScript Promise對象

目錄

Promise 是 JavaScript 異步操作解決方案。介紹 Promise 之前，先對異步操作做一個詳細介紹。

概述

Javascript 語言的執(zhí)行環(huán)境是“單線程”（single thread）。所謂“單線程”，就是指一次只能完成一件任務。如果有多個任務，就必須排隊，前面一個任務完成，再執(zhí)行后面一個任務。

這種模式的好處是實現(xiàn)起來比較簡單，執(zhí)行環(huán)境相對單純；壞處是只要有一個任務耗時很長，后面的任務都必須排隊等著，會拖延整個程序的執(zhí)行。常見的瀏覽器無響應（假死），往往就是因為某一段 JavaScript 代碼長時間運行（比如死循環(huán)），導致整個頁面卡在這個地方，其他任務無法執(zhí)行。

JavaScript 語言本身并不慢，慢的是讀寫外部數(shù)據(jù)，比如等待 Ajax 請求返回結果。這個時候，如果對方服務器遲遲沒有響應，或者網(wǎng)絡不通暢，就會導致腳本的長時間停滯。

為了解決這個問題，Javascript 語言將任務的執(zhí)行模式分成兩種：同步（Synchronous）和異步（Asynchronous）。“同步模式”就是傳統(tǒng)做法，后一個任務等待前一個任務結束，然后再執(zhí)行，程序的執(zhí)行順序與任務的排列順序是一致的、同步的。這往往用于一些簡單的、快速的、不涉及 IO 讀寫的操作。

“異步模式”則完全不同，每一個任務分成兩段，第一段代碼包含對外部數(shù)據(jù)的請求，第二段代碼被寫成一個回調函數(shù)，包含了對外部數(shù)據(jù)的處理。第一段代碼執(zhí)行完，不是立刻執(zhí)行第二段代碼，而是將程序的執(zhí)行權交給第二個任務。等到外部數(shù)據(jù)返回了，再由系統(tǒng)通知執(zhí)行第二段代碼。所以，程序的執(zhí)行順序與任務的排列順序是不一致的、異步的。

以下總結了”異步模式”編程的幾種方法，理解它們可以讓你寫出結構更合理、性能更出色、維護更方便的 JavaScript 程序。

回調函數(shù)

回調函數(shù)是異步編程最基本的方法。

假定有兩個函數(shù)f1和f2，后者必須等到前者執(zhí)行完成，才能執(zhí)行。這時，可以考慮改寫f1，把f2寫成f1的回調函數(shù)。

function f1(callback) {
  // f1 的代碼

  // f1 執(zhí)行完成后，調用回調函數(shù)
  callback();
}

執(zhí)行代碼就變成下面這樣。

f1(f2);

回調函數(shù)的優(yōu)點是簡單、容易理解和部署，缺點是不利于代碼的閱讀和維護，各個部分之間高度耦合（Coupling），使得程序結構混亂、流程難以追蹤（尤其是回調函數(shù)嵌套的情況），而且每個任務只能指定一個回調函數(shù)。

事件監(jiān)聽

另一種思路是采用事件驅動模式。任務的執(zhí)行不取決于代碼的順序，而取決于某個事件是否發(fā)生。

還是以f1和f2為例。首先，為f1綁定一個事件（這里采用的jQuery的寫法）。

f1.on('done', f2);

上面這行代碼的意思是，當f1發(fā)生done事件，就執(zhí)行f2。然后，對f1進行改寫：

function f1(){
  setTimeout(function () {
    // f1的任務代碼
    f1.trigger('done');
  }, 1000);
}

上面代碼中，f1.trigger('done')表示，執(zhí)行完成后，立即觸發(fā)done事件，從而開始執(zhí)行f2。

這種方法的優(yōu)點是比較容易理解，可以綁定多個事件，每個事件可以指定多個回調函數(shù)，而且可以”去耦合“（Decoupling），有利于實現(xiàn)模塊化。缺點是整個程序都要變成事件驅動型，運行流程會變得很不清晰。

發(fā)布/訂閱

“事件”完全可以理解成”信號”，如果存在一個”信號中心”，某個任務執(zhí)行完成，就向信號中心”發(fā)布”（publish）一個信號，其他任務可以向信號中心”訂閱”（subscribe）這個信號，從而知道什么時候自己可以開始執(zhí)行。這就叫做”發(fā)布/訂閱模式“（publish-subscribe pattern），又稱”觀察者模式“（observer pattern）。

這個模式有多種實現(xiàn)，下面采用的是Ben Alman的Tiny Pub/Sub，這是jQuery的一個插件。

首先，f2向”信號中心”jQuery訂閱”done”信號。

jQuery.subscribe("done", f2);

然后，f1進行如下改寫：

function f1(){
	setTimeout(function () {
		// f1的任務代碼
		jQuery.publish("done");
	}, 1000);
}

jQuery.publish(“done”)的意思是，f1執(zhí)行完成后，向”信號中心”jQuery發(fā)布”done”信號，從而引發(fā)f2的執(zhí)行。

f2完成執(zhí)行后，也可以取消訂閱（unsubscribe）。

jQuery.unsubscribe("done", f2);

這種方法的性質與”事件監(jiān)聽”類似，但是明顯優(yōu)于后者。因為我們可以通過查看”消息中心”，了解存在多少信號、每個信號有多少訂閱者，從而監(jiān)控程序的運行。

如果有多個異步操作，就存在一個流程控制的問題：確定操作執(zhí)行的順序，以后如何保證遵守這種順序。

function async(arg, callback) {
  console.log('參數(shù)為 ' + arg +' , 1秒后返回結果');
  setTimeout(function() { callback(arg * 2); }, 1000);
}

上面代碼的async函數(shù)是一個異步任務，非常耗時，每次執(zhí)行需要1秒才能完成，然后再調用回調函數(shù)。

如果有6個這樣的異步任務，需要全部完成后，才能執(zhí)行下一步的final函數(shù)。

function final(value) {
  console.log('完成: ', value);
}

請問應該如何安排操作流程？

async(1, function(value){
  async(value, function(value){
    async(value, function(value){
      async(value, function(value){
        async(value, function(value){
          async(value, final);
        });
      });
    });
  });
});

上面代碼采用6個回調函數(shù)的嵌套，不僅寫起來麻煩，容易出錯，而且難以維護。

串行執(zhí)行

我們可以編寫一個流程控制函數(shù)，讓它來控制異步任務，一個任務完成以后，再執(zhí)行另一個。這就叫串行執(zhí)行。

var items = [ 1, 2, 3, 4, 5, 6 ];
var results = [];
function series(item) {
  if(item) {
    async( item, function(result) {
      results.push(result);
      return series(items.shift());
    });
  } else {
    return final(results);
  }
}
series(items.shift());

上面代碼中，函數(shù)series就是串行函數(shù)，它會依次執(zhí)行異步任務，所有任務都完成后，才會執(zhí)行final函數(shù)。items數(shù)組保存每一個異步任務的參數(shù)，results數(shù)組保存每一個異步任務的運行結果。

并行執(zhí)行

流程控制函數(shù)也可以是并行執(zhí)行，即所有異步任務同時執(zhí)行，等到全部完成以后，才執(zhí)行final函數(shù)。

var items = [ 1, 2, 3, 4, 5, 6 ];
var results = [];

items.forEach(function(item) {
  async(item, function(result){
    results.push(result);
    if(results.length == items.length) {
      final(results);
    }
  })
});

上面代碼中，forEach方法會同時發(fā)起6個異步任務，等到它們全部完成以后，才會執(zhí)行final函數(shù)。

并行執(zhí)行的好處是效率較高，比起串行執(zhí)行一次只能執(zhí)行一個任務，較為節(jié)約時間。但是問題在于如果并行的任務較多，很容易耗盡系統(tǒng)資源，拖慢運行速度。因此有了第三種流程控制方式。

并行與串行的結合

所謂并行與串行的結合，就是設置一個門檻，每次最多只能并行執(zhí)行n個異步任務。這樣就避免了過分占用系統(tǒng)資源。

var items = [ 1, 2, 3, 4, 5, 6 ];
var results = [];
var running = 0;
var limit = 2;

function launcher() {
  while(running < limit && items.length > 0) {
    var item = items.shift();
    async(item, function(result) {
      results.push(result);
      running--;
      if(items.length > 0) {
        launcher();
      } else if(running == 0) {
        final();
      }
    });
    running++;
  }
}

launcher();

上面代碼中，最多只能同時運行兩個異步任務。變量running記錄當前正在運行的任務數(shù)，只要低于門檻值，就再啟動一個新的任務，如果等于0，就表示所有任務都執(zhí)行完了，這時就執(zhí)行final函數(shù)。

簡介

Promise對象是CommonJS工作組提出的一種規(guī)范，目的是為異步操作提供統(tǒng)一接口。

那么，什么是Promises？

首先，它是一個對象，也就是說與其他JavaScript對象的用法，沒有什么兩樣；其次，它起到代理作用（proxy），充當異步操作與回調函數(shù)之間的中介。它使得異步操作具備同步操作的接口，使得程序具備正常的同步運行的流程，回調函數(shù)不必再一層層嵌套。

簡單說，它的思想是，每一個異步任務立刻返回一個Promise對象，由于是立刻返回，所以可以采用同步操作的流程。這個Promises對象有一個then方法，允許指定回調函數(shù)，在異步任務完成后調用。

比如，異步操作f1返回一個Promise對象，它的回調函數(shù)f2寫法如下。

(new Promise(f1)).then(f2);

這種寫法對于多層嵌套的回調函數(shù)尤其方便。

// 傳統(tǒng)寫法
step1(function (value1) {
  step2(value1, function(value2) {
    step3(value2, function(value3) {
      step4(value3, function(value4) {
        // ...
      });
    });
  });
});

// Promises的寫法
(new Promise(step1))
  .then(step2)
  .then(step3)
  .then(step4);

從上面代碼可以看到，采用Promises接口以后，程序流程變得非常清楚，十分易讀。

注意，為了便于理解，上面代碼的Promise對象的生成格式，做了簡化，真正的語法請參照下文。

總的來說，傳統(tǒng)的回調函數(shù)寫法使得代碼混成一團，變得橫向發(fā)展而不是向下發(fā)展。Promises規(guī)范就是為了解決這個問題而提出的，目標是使用正常的程序流程（同步），來處理異步操作。它先返回一個Promise對象，后面的操作以同步的方式，寄存在這個對象上面。等到異步操作有了結果，再執(zhí)行前期寄放在它上面的其他操作。

Promises原本只是社區(qū)提出的一個構想，一些外部函數(shù)庫率先實現(xiàn)了這個功能。ECMAScript 6將其寫入語言標準，因此目前JavaScript語言原生支持Promise對象。

Promise接口

前面說過，Promise接口的基本思想是，異步任務返回一個Promise對象。

Promise對象只有三種狀態(tài)。

• 異步操作“未完成”（pending）
• 異步操作“已完成”（resolved，又稱fulfilled）
• 異步操作“失敗”（rejected）

這三種的狀態(tài)的變化途徑只有兩種。

• 異步操作從“未完成”到“已完成”
• 異步操作從“未完成”到“失敗”。

這種變化只能發(fā)生一次，一旦當前狀態(tài)變?yōu)椤耙淹瓿伞被颉笆　?，就意味著不會再有新的狀態(tài)變化了。因此，Promise對象的最終結果只有兩種。

• 異步操作成功，Promise對象傳回一個值，狀態(tài)變?yōu)?code class="highlighter-rouge">resolved。
• 異步操作失敗，Promise對象拋出一個錯誤，狀態(tài)變?yōu)?code class="highlighter-rouge">rejected。

Promise對象使用then方法添加回調函數(shù)。then方法可以接受兩個回調函數(shù)，第一個是異步操作成功時（變?yōu)?code class="highlighter-rouge">resolved狀態(tài)）時的回調函數(shù)，第二個是異步操作失?。ㄗ?yōu)?code class="highlighter-rouge">rejected）時的回調函數(shù)（可以省略）。一旦狀態(tài)改變，就調用相應的回調函數(shù)。

// po是一個Promise對象
po.then(
  console.log,
  console.error
);

上面代碼中，Promise對象po使用then方法綁定兩個回調函數(shù)：操作成功時的回調函數(shù)console.log，操作失敗時的回調函數(shù)console.error（可以省略）。這兩個函數(shù)都接受異步操作傳回的值作為參數(shù)。

then方法可以鏈式使用。

po
  .then(step1)
  .then(step2)
  .then(step3)
  .then(
    console.log,
    console.error
  );

上面代碼中，po的狀態(tài)一旦變?yōu)?code class="highlighter-rouge">resolved，就依次調用后面每一個then指定的回調函數(shù)，每一步都必須等到前一步完成，才會執(zhí)行。最后一個then方法的回調函數(shù)console.log和console.error，用法上有一點重要的區(qū)別。console.log只顯示回調函數(shù)step3的返回值，而console.error可以顯示step1、step2、step3之中任意一個發(fā)生的錯誤。也就是說，假定step1操作失敗，拋出一個錯誤，這時step2和step3都不會再執(zhí)行了（因為它們是操作成功的回調函數(shù)，而不是操作失敗的回調函數(shù)）。Promises對象開始尋找，接下來第一個操作失敗時的回調函數(shù)，在上面代碼中是console.error。這就是說，Promises對象的錯誤有傳遞性。

從同步的角度看，上面的代碼大致等同于下面的形式。

try {
  var v1 = step1(po);
  var v2 = step2(v1);
  var v3 = step3(v2);
  console.log(v3);
} catch (error) {
  console.error(error);
}

Promise對象的生成

ES6提供了原生的Promise構造函數(shù)，用來生成Promise實例。

下面代碼創(chuàng)造了一個Promise實例。

var promise = new Promise(function(resolve, reject) {
  // 異步操作的代碼

  if (/* 異步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

Promise構造函數(shù)接受一個函數(shù)作為參數(shù)，該函數(shù)的兩個參數(shù)分別是resolve和reject。它們是兩個函數(shù)，由JavaScript引擎提供，不用自己部署。

resolve函數(shù)的作用是，將Promise對象的狀態(tài)從“未完成”變?yōu)椤俺晒Α保磸?code class="highlighter-rouge">Pending變?yōu)?code class="highlighter-rouge">Resolved），在異步操作成功時調用，并將異步操作的結果，作為參數(shù)傳遞出去；reject函數(shù)的作用是，將Promise對象的狀態(tài)從“未完成”變?yōu)椤笆　保磸?code class="highlighter-rouge">Pending變?yōu)?code class="highlighter-rouge">Rejected），在異步操作失敗時調用，并將異步操作報出的錯誤，作為參數(shù)傳遞出去。

Promise實例生成以后，可以用then方法分別指定Resolved狀態(tài)和Reject狀態(tài)的回調函數(shù)。

po.then(function(value) {
  // success
}, function(value) {
  // failure
});

用法辨析

Promise的用法，簡單說就是一句話：使用then方法添加回調函數(shù)。但是，不同的寫法有一些細微的差別，請看下面四種寫法，它們的差別在哪里？

// 寫法一
doSomething().then(function () {
  return doSomethingElse();
});

// 寫法二
doSomething().then(function () {
  doSomethingElse();
});

// 寫法三
doSomething().then(doSomethingElse());

// 寫法四
doSomething().then(doSomethingElse);

為了便于講解，下面這四種寫法都再用then方法接一個回調函數(shù)finalHandler。寫法一的finalHandler回調函數(shù)的參數(shù)，是doSomethingElse函數(shù)的運行結果。

doSomething().then(function () {
  return doSomethingElse();
}).then(finalHandler);

寫法二的finalHandler回調函數(shù)的參數(shù)是undefined。

doSomething().then(function () {
  doSomethingElse();
  return;
}).then(finalHandler);

寫法三的finalHandler回調函數(shù)的參數(shù)，是doSomethingElse函數(shù)返回的回調函數(shù)的運行結果。

doSomething().then(doSomethingElse())
  .then(finalHandler);

寫法四與寫法一只有一個差別，那就是doSomethingElse會接收到doSomething()返回的結果。

doSomething().then(doSomethingElse)
  .then(finalHandler);

加載圖片

我們可以把圖片的加載寫成一個Promise對象。

var preloadImage = function (path) {
  return new Promise(function (resolve, reject) {
    var image = new Image();
    image.onload  = resolve;
    image.onerror = reject;
    image.src = path;
  });
};

Ajax操作

Ajax操作是典型的異步操作，傳統(tǒng)上往往寫成下面這樣。

function search(term, onload, onerror) {
  var xhr, results, url;
  url = 'http://example.com/search?q=' + term;

  xhr = new XMLHttpRequest();
  xhr.open('GET', url, true);

  xhr.onload = function (e) {
    if (this.status === 200) {
      results = JSON.parse(this.responseText);
      onload(results);
    }
  };
  xhr.onerror = function (e) {
    onerror(e);
  };

  xhr.send();
}

search("Hello World", console.log, console.error);

如果使用Promise對象，就可以寫成下面這樣。

function search(term) {
  var url = 'http://example.com/search?q=' + term;
  var xhr = new XMLHttpRequest();
  var result;

  var p = new Promise(function (resolve, reject) {
    xhr.open('GET', url, true);
    xhr.onload = function (e) {
      if (this.status === 200) {
        result = JSON.parse(this.responseText);
        resolve(result);
      }
    };
    xhr.onerror = function (e) {
      reject(e);
    };
    xhr.send();
  });

  return p;
}

search("Hello World").then(console.log, console.error);

加載圖片的例子，也可以用Ajax操作完成。

function imgLoad(url) {
  return new Promise(function(resolve, reject) {
    var request = new XMLHttpRequest();
    request.open('GET', url);
    request.responseType = 'blob';
    request.onload = function() {
      if (request.status === 200) {
        resolve(request.response);
      } else {
        reject(new Error('圖片加載失?。? + request.statusText));
      }
    };
    request.onerror = function() {
      reject(new Error('發(fā)生網(wǎng)絡錯誤'));
    };
    request.send();
  });
}

小結

Promise對象的優(yōu)點在于，讓回調函數(shù)變成了規(guī)范的鏈式寫法，程序流程可以看得很清楚。它的一整套接口，可以實現(xiàn)許多強大的功能，比如為多個異步操作部署一個回調函數(shù)、為多個回調函數(shù)中拋出的錯誤統(tǒng)一指定處理方法等等。

而且，它還有一個前面三種方法都沒有的好處：如果一個任務已經(jīng)完成，再添加回調函數(shù)，該回調函數(shù)會立即執(zhí)行。所以，你不用擔心是否錯過了某個事件或信號。這種方法的缺點就是，編寫和理解都相對比較難。

• Sebastian Porto, Asynchronous JS: Callbacks, Listeners, Control Flow Libs and Promises
• Rhys Brett-Bowen, Promises/A+ - understanding the spec through implementation
• Matt Podwysocki, Amanda Silver, Asynchronous Programming in JavaScript with “Promises”
• Marc Harter, Promise A+ Implementation
• Bryan Klimt, What’s so great about JavaScript Promises?
• Jake Archibald, JavaScript Promises There and back again
• Mikito Takada, 7. Control flow, Mixu’s Node book