promise 进阶 —— async / await 结合 bluebird

时间:2019-12-14 小蒋不素小蒋人气:0

一、背景

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+

官方：http://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.comhttps://img.qb5200.com/download-x/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

加载全部内容

promise 进阶 —— async / await 结合 bluebird

一、背景

1、Node.js 异步控制

2、已经有 ES6 Promise + async / await 了，为什么还要用 bluebird ？

二、Promise 进阶

1、Promise 前世今生

（1）定义

（2）历史

（3）各语言支持

2、Promises/A+

3、 拓展 - jQuery 中的 Promise

（1）介绍

（2）用法

三、bluebird

1、介绍

2、安装

3、使用

4、早期原生性能问题

四、bluebird 用法

1、回调形式 -> Promise 形式

（1）bluebird

（2）原生

2、使用 promise —— .finally()

（1）bluebird

（2）自己实现

（3）async / await

（4）原生

3、使用 promise —— .cancel()

（1）bluebird

（2）async / await

4、处理 promise 集合

（1）bluebird

（2）拓展 - promiseAll 实现原理

（3）async / await

5、资源使用与释放

（1）bluebird

（2）async / await

6、定时器

（1）bluebird

（2）async / await

7、实用方法

（1）bluebird

（2）async / await

8、错误处理

（1）拓展 - then() 的多次指定与报错

（2）bluebird

（3）async / await 的错误处理

参考资料

3、拓展 - jQuery 中的 Promise