一、背景
1、Node.js 异步控制
在之前写的 callback vs async.js vs promise vs async / await 里，我介绍了 ES6 的 promise 和 ES7 的 async / await 的基本用法。
可以肯定的是，node.js 的异步控制（asynchronous JavaScript），promise 就是未来的主流，诸如 async.js 等非 promise 库（ async.js 基于 callback ）终将被淘汰，而基于 promise 的第三方库（Q、when、WinJS、RSVP.js）也会被 async / await 写法取代。
延伸阅读：知乎 - nodejs异步控制「co、async、Q 、『es6原生promise』、then.js、bluebird」有何优缺点？最爱哪个？哪个简单？
2、已经有 ES6 Promise + async / await 了，为什么还要用 bluebird ？
但目前基于 async / await 的 promise 写法还不是很强大。这里可以考虑用 bluebird，它是一个第三方的 Promise 库，比 async / await 更早诞生，但是完全兼容，因为他们都是基于 Promises/A+ 的标准（下文会介绍）。
很多第三方的 promise 库都是兼容 ES6 promise 的，比如 Q 。
二、Promise 进阶
1、Promise 前世今生
（1）定义
They describe an object that acts as a proxy for a result that is initially unknown, usually because the computation of its value is not yet complete.
有道翻译：他们描述了一个对象，该对象充当最初未知的结果的代理，通常是因为其值的计算尚未完成。
“代理”这个词用的挺好的。
（2）历史
promise 一词由丹尼尔·福瑞得曼和 David Wise 在1976年提出。
后来演化出别称：future、delay 和 deferred，通常可以互换使用。
promise 起源于函数式编程和相关范例（如逻辑编程 ），目的是将值（future）与其计算方式（promise）分离，从而允许更灵活地进行计算。
应用场景：
并行化计算
分布式计算
编写异步程序，避免回调地狱
（3）各语言支持
现在主流的语言对 future/promise 都有支持。
Java 5 中的 FutureTask（2004年公布）
.NET 4.5 中的 async / await
Dart（2014）
Python（2015）
Hack（HHVM）
ECMAScript 7（JavaScript）
Scala
C++ 草案
……
2、Promises/A+
官方：https://promisesaplus.com/
介绍：An open standard for sound, interoperable JavaScript promises—by implementers, for implementers.
可以理解成 javascript 中 关于 promise 的实现标准。
3、 拓展 - jQuery 中的 Promise
（1）介绍
从 jQuery 1.5.0 版本开始引入的一个新功能 —— deferred 对象。
注意：Deferred 虽然也是一种 promise 的实现，但是跟 Promise/A+ 并不兼容。
但可以将其转为标准的 promise，例如：
var jsPromise = Promise.resolve($.ajax('/whatever.json'))
（2）用法
因为 jQuery 现如今很少用到了，仅简单介绍下 deferred 的用法吧。
1、以 ajax 操作为例：
$.ajax() 操作完成后，如果使用的是低于1.5.0版本的 jQuery，返回的是 XHR 对象，你没法进行链式操作；如果高于 1.5.0 版本，返回的是 deferred 对象，可以进行链式操作。
# old
$.ajax({
url: "test.html",
success: function(){
alert("哈哈，成功了！");
},
error:function(){
alert("出错啦！");
}
});
# new
$.ajax("test.html")
.done(function(){ alert("哈哈，成功了！"); })
.fail(function(){ alert("出错啦！"); });
2、其它
$.when() 类似 promise.all()
deferred.resolve()、deferred.reject() 类似 Promise.resolve()、Promise.reject()
……
三、bluebird
1、介绍
英文文档：
http://bluebirdjs.com/docs/api-reference.html
中文文档：
https://itbilu.com/nodejs/npm/VJHw6ScNb.html
2、安装
npm install bluebird
3、使用
const Promise = require('bluebird')
这样写会覆盖原生的 Promise 对象。
4、早期原生性能问题
早期 js 标准库里并没有包含 Promise，所以被迫只能用第三方的 Promise 库，例如 bluebird。
后来 ES6 和 ES7 相继推出了原生的 Promise 和 async/await ，但性能很差，大家还习惯用例如bluebird。
但到了 Node.js v8.x ，原生性能已经得到了很大的优化，可以不需要使用 bluebird 这样的第三方 Promise 库。（除非需要用到 bluebird 的更多 feature，而原生是不具备的。这个下面会详细介绍）
详情可以参考这篇文章：Node 8：迎接 async await 新时代
四、bluebird 用法
这一章，会结合 bluebird 用法 和 原生（主要以 ES7 的 async / wait） 探讨出最优写法。
1、回调形式 -> Promise 形式
大部分 NodeJS 的标准库 API 和不少第三方库的 API 都使用了回调方法的模式，也就是在执行异步操作时，需要传入一个回调方法来接受操作的执行结果和可能出现的错误。
例如 NodeJS 的标准库中的 fs 模块：
const fs = require('fs'),
path = require('path');
fs.readFile(path.join(__dirname, 'sample.txt'), 'utf-8', (err, data) => {
if (err) {
console.error(err);
} else {
console.log(data);
}
});
（1）bluebird
对于这样的方法，bluebird 的 promisifyAll() 和 promisify() 可以很容易的将它们转换成使用 Promise 的形式。
// 覆盖了原生的Promise
const Promise = require('bluebird'),
fs = require('fs'),
path = require('path');
// 1、promisifyAll
// Promise.promisifyAll 方法可以为一个对象的属性中的所有方法创建一个对应的使用 Promise 的版本
Promise.promisifyAll(fs);
// 这些新创建方法的名称在已有方法的名称后加上"Async"后缀
// （除了 readFile 对应的 readFileAsync，fs 中的其他方法也都有了对应的 Async 版本，如 writeFileAsync 和 fstatAsync 等）
fs.readFileAsync(path.join(__dirname, 'sample.txt'), 'utf-8')
.then(data => console.log(data))
.catch(err => console.error(err));
// 2、promisify
// Promise.promisify 方法可以为单独的方法创建一个对应的使用 Promise 的版本
let readFileAsync = Promise.promisify(fs.readFile)
readFileAsync(path.join(__dirname, 'sample.txt'), 'utf-8')
.then(data => console.log(data))
.catch(err => console.error(err));
（2）原生
在 node.js 8.x版本中，可以用 util.promisify() 实现 promisify() 一样的功能。
在官方推出这个工具之前，民间已经有很多类似的工具了，除了bluebird.promisify，还有比如es6-promisify、thenify。
2、使用 promise —— .finally()
.finally() 可以避免同样的语句需要在 then() 和 catch() 中各写一次的情况。
（1）bluebird
Promise.reject(new TypeError('some error'))
.catch(TypeError, console.error)
.finally(() => console.log('done'));
（2）自己实现
Promise.prototype.finally = function (callback) {
return this.then(function (value) {
return Promise.resolve(callback()).then(function () {
return value;
});
}, function (err) {
return Promise.resolve(callback()).then(function () {
throw err;
});
});
};
（3）async / await
用 try...catch...finally 的 finally 即可实现。
（4）原生
.finally() 是ES2018（ES9）的新特性。
3、使用 promise —— .cancel()
（1）bluebird
当一个 Promise 对象被 .cancel() 之后，只是其回调方法都不会被调用，并不会取消正在进行的异步操作。
// 先修改全局配置，让 promise 可被撤销
Promise.config({
cancellation: true, // 默认为 false
});
// 构造一个 promise 对象，并设置 1000 ms 延迟
let promise = Promise.resolve("hello").then((value) => {
console.log("promise 的 async function 还是执行了……")
return value
}).delay(1000)
// promise 对象上绑定回调函数
promise.then(value => console.log(value))
// 取消这个 promise 对象的回调
setTimeout(() => {
promise.cancel();
}, 500);
输出：
promise 的 async function 还是执行了……
这里提到的 .delay() 方法下面会介绍。
（2）async / await
可以通过对 async / await 函数调用后的返回值，做 if 判断，决定要不要执行接下来的逻辑。
4、处理 promise 集合
之前的代码示例都针对单个 Promise。在实际中，经常会处理与多个 Promise 的关系。
（1）bluebird
以 fs 模块分别读取 sample1.txt、sample2.txt、sample3.txt 三个文件的内容为例。他们的文件内容分别为 “1”、“2”、“3”。
const Promise = require('bluebird'),
fs = require('fs'),
path = require('path');
Promise.promisifyAll(fs);
// 一、并行操作
// 1、Promise.all ，必须全部成功才通过 【保证返回顺序】
Promise.all([
fs.readFileAsync(path.join(__dirname, 'sample1.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample2.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample3.txt'), 'utf-8')
]).then(results => console.log(results.join(', '))).catch(console.error);
// 1.1、Promise.props ，约等于 Promise.all，但不同的在于: 返回的不是数组而是对象 ！
Promise.props({
app1: fs.readFileAsync(path.join(__dirname, 'sample1.txt'), 'utf-8'),
app2: fs.readFileAsync(path.join(__dirname, 'sample2.txt'), 'utf-8'),
app3: fs.readFileAsync(path.join(__dirname, 'sample3.txt'), 'utf-8'),
}).then(results => console.log(results)).catch(console.error);
// 1.2 Promise.join，约等于 Promise.all 【保证返回顺序】， 但不同的在于: 成功结果不是 array 而是多个参数 ！
Promise.join(
fs.readFileAsync(path.join(__dirname, 'sample1.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample2.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample3.txt'), 'utf-8'),
(a, b, c) => console.log(a, b, c));
// 1.3、Promise.filter ，约等于 Promise.all 之后对成功结果的 Array 进行 filter 过滤 【保证返回顺序】
Promise.filter([
fs.readFileAsync(path.join(__dirname, 'sample1.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample2.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample3.txt'), 'utf-8')
], value => value > 1).then(results => console.log(results.join(', '))).catch(console.error);
// ----------
// 2、Promise.map ，约等于 Promise.all 【保证返回顺序】
Promise.map(['sample1.txt', 'sample2.txt', 'sample3.txt'],
name => fs.readFileAsync(path.join(__dirname, name), 'utf-8')
).then(results => console.log(results.join(', '))).catch(console.error);
// 2.1 Promise.reduce，约等于 Promise.map
Promise.reduce(['sample1.txt', 'sample2.txt', 'sample3.txt'],
(total, name) => {
return fs.readFileAsync(path.join(__dirname, name), 'utf-8').then(data => total + parseInt(data));
}
, 0).then(result => console.log(`Total size: ${result}`)).catch(console.error);
// ----------
// 3、Promise.some 只要成功 N 个就通过 【不保证返回顺序】
Promise.some([
fs.readFileAsync(path.join(__dirname, 'sample1.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample2.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample3.txt'), 'utf-8')
], 3).then(results => console.log(results.join(', '))).catch(console.error);
// 3.1、Promise.any 只要成功 1 个就通过，约等于 Promise.some (N = 1)，但不同的在于:返回的不是数组而是单个值了！
Promise.any([
fs.readFileAsync(path.join(__dirname, 'sample1.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample2.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample3.txt'), 'utf-8')
]).then(results => console.log(results)).catch(console.error);
// 3.2、Promise.race 只要成功 1 个就通过，约等于 Promise.any (N = 1)，但不同的在于:如果成功返回前遇到了失败，则会不通过！
Promise.race([
fs.readFileAsync(path.join(__dirname, 'sample1.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample2.txt'), 'utf-8'),
fs.readFileAsync(path.join(__dirname, 'sample3.txt'), 'utf-8')
]).then(results => console.log(results)).catch(console.error);
// ----------
// 二、串行
// 4、Promise.mapSeries ，约等于 Promise.map 【保证返回顺序】，但不同的在于: 这是串行不是并行！
Promise.mapSeries(['sample1.txt', 'sample2.txt', 'sample3.txt'],
name => fs.readFileAsync(path.join(__dirname, name), 'utf-8').then(function(fileContents) {
return name + "!";
})
).then(results => console.log(results.join(', '))).catch(console.error);
// 'sample1.txt!, sample2.txt!, sample3.txt!'
// 4.1、Promise.each ，约等于 Promise.mapSeries 【保证返回顺序】， 但不同的在于: 只是单纯的遍历，每次循环的 return 毫无影响 ！
Promise.each(['sample1.txt', 'sample2.txt', 'sample3.txt'],
name => fs.readFileAsync(path.join(__dirname, name), 'utf-8').then(function(fileContents) {
return name + "!"; // 无效
})
).then(results => console.log(results.join(', '))).catch(console.error);
// 'sample1.txt, sample2.txt, sample3.txt'
1、大多数函数都是并行的。其中 map、filter 还有 Concurrency coordination （并发协调）功能。
注意：
1、因为 Node.js 是单线程，这里的并发只是针对 promise 而言，实际上底层还是串行。
2、并发数的多少，取决于你 promise 执行的具体功能，如网络请求、数据库连接等。需根据实际情况来设置。
以 map 为例：
// 控制并发数
Promise.map(['sample1.txt', 'sample2.txt', 'sample3.txt'],
name => fs.readFileAsync(path.join(__dirname, name), 'utf-8'),
{concurrency: 2}
).then(results => console.log(results.join(', '))).catch(console.error);
2、mapSeries、each 是串行，也可以看成是 {concurrency: 1} 的特例。
（2）拓展 - promiseAll 实现原理
function promiseAll(promises) {
return new Promise(function(resolve, reject) {
if (!isArray(promises)) {
return reject(new TypeError('arguments must be an array'));
}
var resolvedCounter = 0;
var promiseNum = promises.length;
var resolvedValues = new Array(promiseNum);
for (var i = 0; i < promiseNum; i++) {
(function(i) {
Promise.resolve(promises[i]).then(function(value) {
resolvedCounter++
resolvedValues[i] = value
if (resolvedCounter == promiseNum) {
return resolve(resolvedValues)
}
}, function(reason) {
return reject(reason)
})
})(i)
}
})
}
注意：Promise.resolve(promises[i])这段的意思，是防止 promises[i] 为非 promise 对象，而强制转成 promise 对象。
此源码地址为： promise-all-simple
（3）async / await
对于上面的并行操作，建议用 bluebird （原生貌似现在只支持 Promise.all() ，太少了）。
对于上面的串行操作，可以用 循环 搭配 async / await 即可。
5、资源使用与释放
如果在 Promise 中使用了需要释放的资源，如数据库连接，我们需要确保这些资源被应有的释放。
（1）bluebird
方法1：finally() 中添加资源释放的代码（上文有介绍）
方法2【推荐】：使用资源释放器（disposer）和 Promise.using()。
（2）async / await
利用 async / await 中的 try...catch...finally 中的 finally 。
6、定时器
（1）bluebird
async function test() {
try {
let readFilePromise = new Promise((resolve, reject) => {resolve('result')})
let result = await readFilePromise.delay(1000).timeout(2000, 'timed out')
console.log(result);
} catch (err) {
console.log("error", err);
}
}
test();
1、默认的， new Promise 会立即执行，但是加了 delay()，可以延迟执行。
2、timeout() 可以设置执行的 timeout 时间，超过即抛出 TimeoutError 错误。
（2）async / await
暂时没有方便的替代写法。
7、实用方法
（1）bluebird
bluebird 的 Promise 中还包含了一些实用方法。tap 和 tapCatch 分别用来查看 Promise 中的结果和出现的错误。这两个方法中的处理方法不会影响 Promise 的结果，适合用来执行日志记录。call 用来调用 Promise 结果对象中的方法。get 用来获取 Promise 结果对象中的属性值。return 用来改变 Promise 的结果。throw 用来抛出错误。catchReturn 用来在捕获错误之后，改变 Promise 的值。catchThrow 用来在捕获错误之后，抛出新的错误。
（2）async / await
上面 bluebird 的实用方法，在 async / await 的写法里，显得无足轻重了。
8、错误处理
（1）拓展 - then() 的多次指定与报错
对一个 resolve 的 promise ，指定多个 then：
let promiseObj = new Promise((resolve, reject) => {resolve()})
// 第一次指定 then
promiseObj.then(function (data) {
console.log("success1");
}, function (data) {
console.log("fail1");
})
// 第二次指定 then
promiseObj.then(function (data) {
console.log("success2");
}, function (data) {
console.log("fail2");
})
// 第三次指定 then
promiseObj.then(function (data) {
console.log("success3");
})
// 第四次指定 then(catch)
promiseObj.catch(function (data) {
console.log("fail4");
})
输出：
success1
success2
success3
对一个 reject 的 promise ，指定多个 then：
let promiseObj = new Promise((resolve, reject) => {reject()})
// 第一次指定 then
promiseObj.then(function (data) {
console.log("success1");
}, function (data) {
console.log("fail1");
})
// 第二次指定 then
promiseObj.then(function (data) {
console.log("success2");
}, function (data) {
console.log("fail2");
})
// 第三次指定 then
promiseObj.then(function (data) {
console.log("success3");
})
// 第四次指定 then(catch)
promiseObj.catch(function (data) {
console.log("fail4");
})
输出：
fail1
fail2
fail4
Unhandled rejection undefined
结论：
1、对于一个 promise 对象，我们可以多次指定它的 then()。
2、当此 promise 状态变为 resolve，即使没有 then() 或者 有 then() 但是没有 successCallback，也不会有问题。
3、当此 promise 状态变为 reject， 如果没有 then() 或者有 then() 但是没有 failureCallback ，则会报错（下面会介绍如何捕获这个错）。
（2）bluebird
1、本地错误处理
利用 then() 的 failureCallback（或 .catch() ）。不赘述了。
2、全局错误处理
bluebird 提供了 promise 被拒绝相关的两个全局事件，分别是 unhandledRejection 和 rejectionHandled ：
let promiseObj = new Promise((resolve, reject) => {reject('colin')})
setTimeout(() => {
promiseObj.catch(function (data) {
console.log("fail");
})
}, 2000);
process.on('unhandledRejection', (reason, promise) => console.error(`unhandledRejection ${reason}`));
process.on('rejectionHandled', (reason, promise) => console.error(`rejectionHandled ${reason}`));
输出：
unhandledRejection colin
rejectionHandled [object Promise]
fail
1、promise 的 reject 没有被处理（即上面所述），则会触发 unhandledRejection 事件
2、但可能 针对 reject 的处理延迟到了下一个事件循环才被执行，那就会触发 rejectionHandled 事件
所以我们得多等等 rejectionHandled 事件，防止误判，所以可以写成下面全局错误处理的代码：
let possiblyUnhandledRejections = new Map();
// 当一个拒绝未被处理，将其添加到 map
process.on("unhandledRejection", function(reason, promise) {
possiblyUnhandledRejections.set(promise, reason);
});
process.on("rejectionHandled", function(promise) {
possiblyUnhandledRejections.delete(promise);
});
setInterval(function() {
possiblyUnhandledRejections.forEach(function(reason, promise) {
// 做点事来处理这些拒绝
handleRejection(promise, reason);
});
possiblyUnhandledRejections.clear();
}, 60000);
（3）async / await 的错误处理
async / await 的 try..catch 并不能完全捕获到所有的错误。
1、本地错误处理
用 try...catch 即可。
注意：漏掉错误 情况：
run() 这个 promise 本身 reject 了
async function run() {
try {
// 注意这里没有 await
return Promise.reject();
} catch (error) {
console.log("error",error)
// 代码不会执行到这里
}
}
run().catch((error) => {
// 可以捕获
console.log("error2", error)
});
解决方法：针对 run() 函数 （顶层函数）做好 catch 捕获。
2、全局错误处理
漏掉错误 情况：
run() 这个 promise 内部存在 reject 但没有被处理的 promise
async function run() {
try {
// 注意这里 即没有 await 也没有 return
Promise.reject();
} catch (error) {
console.log("error", error)
// 代码不会执行到这里
}
}
run().catch((error) => {
// 不可以捕获
console.log("error2", error)
});
解决方法：
1、跟上面介绍的 bluebird 全局错误处理一样，用好unhandledRejection 和 rejectionHandled 全局事件。
2、ES6 原生也支持 unhandledRejection 和 rejectionHandled 全局事件。
参考资料
使用 bluebird 实现更强大的 Promise