promise 承諾

概念

ES6 原生提供了 Promise 對象。

所謂 Promise，就是一個對象，用來傳遞異步操做的消息。它表明了某個將來纔會知道結果的事件（一般是一個異步操做），而且這個事件提供統一的 API，可供進一步處理。

Promise 對象有如下兩個特色。

（1）對象的狀態不受外界影響。Promise 對象表明一個異步操做，有三種狀態：Pending（進行中）、Resolved（已完成，又稱 Fulfilled）和 Rejected（已失敗）。只有異步操做的結果，能夠決定當前是哪種狀態，任何其餘操做都沒法改變這個狀態。這也是 Promise 這個名字的由來，它的英語意思就是「承諾」，表示其餘手段沒法改變。

（2）一旦狀態改變，就不會再變，任什麼時候候均可以獲得這個結果。Promise 對象的狀態改變，只有兩種可能：從 Pending 變爲 Resolved 和從 Pending 變爲 Rejected。只要這兩種狀況發生，狀態就凝固了，不會再變了，會一直保持這個結果。就算改變已經發生了，你再對 Promise 對象添加回調函數，也會當即獲得這個結果。這與事件（Event）徹底不一樣，事件的特色是，若是你錯過了它，再去監聽，是得不到結果的。

有了 Promise 對象，就能夠將異步操做以同步操做的流程表達出來，避免了層層嵌套的回調函數。此外，Promise 對象提供統一的接口，使得控制異步操做更加容易。

Promise 也有一些缺點。首先，沒法取消 Promise，一旦新建它就會當即執行，沒法中途取消。其次，若是不設置回調函數，Promise 內部拋出的錯誤，不會反應到外部。第三，當處於 Pending 狀態時，沒法得知目前進展到哪個階段（剛剛開始仍是即將完成）。

var promise = new Promise(function(resolve, reject) {
  if (/* 異步操做成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

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

Promise 構造函數接受一個函數做爲參數，該函數的兩個參數分別是 resolve 方法和 reject 方法。

若是異步操做成功，則用 resolve 方法將 Promise 對象的狀態，從「未完成」變爲「成功」（即從 pending 變爲 resolved）；

若是異步操做失敗，則用 reject 方法將 Promise 對象的狀態，從「未完成」變爲「失敗」（即從 pending 變爲 rejected）。

基本的 api

1.Promise.resolve()
2.Promise.reject()
3.Promise.prototype.then()
4.Promise.prototype.catch()
5.Promise.all() // 全部的完成

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

6.Promise.race() // 競速，完成一個便可

進階

promises 的奇妙在於給予咱們之前的 return 與 throw，每一個 Promise 都會提供一個 then() 函數，和一個 catch()，其實是 then(null, ...) 函數，

somePromise().then(functoin(){
  // do something
});

咱們能夠作三件事，

1. return 另外一個 promise 2. return 一個同步的值 (或者 undefined) 3. throw 一個同步異常 ` throw new Eror('');`

1. 封裝同步與異步代碼

```
new Promise(function (resolve, reject) {
  resolve(someValue);
});
```

寫成

```
Promise.resolve(someValue);
```

2. 捕獲同步異常

new Promise(function (resolve, reject) {
  throw new Error('悲劇了，又出 bug 了');
}).catch(function(err){
  console.log(err);
});

若是是同步代碼，能夠寫成

Promise.reject(new Error("什麼鬼"));

3. 多個異常捕獲，更加精準的捕獲

somePromise.then(function() {
  return a.b.c.d();
}).catch(TypeError, function(e) {
  //If a is defined, will end up here because
  //it is a type error to reference property of undefined
}).catch(ReferenceError, function(e) {
  //Will end up here if a wasn't defined at all
}).catch(function(e) {
  //Generic catch-the rest, error wasn't TypeError nor
  //ReferenceError
});

4. 獲取兩個 Promise 的返回值

1. .then 方式順序調用 2. 設定更高層的做用域 3. spread

5. finally

任何狀況下都會執行的，通常寫在 catch 以後

6. bind

somethingAsync().bind({})
.spread(function (aValue, bValue) {
  this.aValue = aValue;
  this.bValue = bValue;
  return somethingElseAsync(aValue, bValue);
})
.then(function (cValue) {
  return this.aValue + this.bValue + cValue;
});

或者 你也能夠這樣

var scope = {};
somethingAsync()
.spread(function (aValue, bValue) {
  scope.aValue = aValue;
  scope.bValue = bValue;
  return somethingElseAsync(aValue, bValue);
})
.then(function (cValue) {
  return scope.aValue + scope.bValue + cValue;
});

然而，這有很是多的區別，

1. 你必須先聲明，有浪費資源和內存泄露的風險
2. 不能用於放在一個表達式的上下文中
3. 效率更低

7. all。很是用於於處理一個動態大小均勻的 Promise 列表

8. join。很是適用於處理多個分離的 Promise

```
var join = Promise.join;
join(getPictures(), getComments(), getTweets(),
function(pictures, comments, tweets) {
  console.log("in total: " + pictures.length + comments.length + tweets.length);
});
```

9. props。處理一個 promise 的 map 集合。只有有一個失敗，全部的執行都結束

```
Promise.props({
  pictures: getPictures(),
  comments: getComments(),
  tweets: getTweets()
}).then(function(result) {
  console.log(result.tweets, result.pictures, result.comments);
});
```

10. any 、some、race

```
Promise.some([
  ping("ns1.example.com"),
  ping("ns2.example.com"),
  ping("ns3.example.com"),
  ping("ns4.example.com")
], 2).spread(function(first, second) {
  console.log(first, second);
}).catch(AggregateError, function(err) {
  err.forEach(function(e) {
    console.error(e.stack);
  });
});

```

有可能，失敗的 promise 比較多，致使，Promsie 永遠不會 fulfilled

11. .map(Function mapper [, Object options])

用於處理一個數組，或者 promise 數組，

Option: concurrency 並發現

map(..., {concurrency: 1});

如下爲不限制併發數量，讀書文件信息

var Promise = require("bluebird");
var join = Promise.join;
var fs = Promise.promisifyAll(require("fs"));
var concurrency = parseFloat(process.argv[2] || "Infinity");

var fileNames = ["file1.json", "file2.json"];
Promise.map(fileNames, function(fileName) {
  return fs.readFileAsync(fileName)
  .then(JSON.parse)
  .catch(SyntaxError, function(e) {
    e.fileName = fileName;
    throw e;
  })
}, {concurrency: concurrency}).then(function(parsedJSONs) {
  console.log(parsedJSONs);
}).catch(SyntaxError, function(e) {
  console.log("Invalid JSON in file " + e.fileName + ": " + e.message);
});

結果

$ sync && echo 3 > /proc/sys/vm/drop_caches $ node test.js 1 reading files 35ms $ sync && echo 3 > /proc/sys/vm/drop_caches $ node test.js Infinity reading files: 9ms

11. .reduce(Function reducer [, dynamic initialValue]) -> Promise

Promise.reduce(["file1.txt", "file2.txt", "file3.txt"], function(total, fileName) {
  return fs.readFileAsync(fileName, "utf8").then(function(contents) {
    return total + parseInt(contents, 10);
  });
}, 0).then(function(total) {
  //Total is 30
});

12. Time

1..delay(int ms) -> Promise
2..timeout(int ms [, String message]) -> Promise

Promie 的實現

1. q
2. bluebird
3. co
4. when

ASYNC

async 函數與 Promise、Generator 函數同樣，是用來取代回調函數、解決異步操做的一種方法。它本質上是 Generator 函數的語法糖。async 函數並不屬於 ES6，而是被列入了 ES7。