并行承诺的流畅构造

Question

我的问题是关于 BlueBird 中优雅的 promise 并行化，当您需要将上下文和参数传递给构建 promise 的函数时。

为了让我的问题易于理解和测试，我做了一个不依赖的例子。

假设我进行涉及异步“计算机”（必须释放其资源）的计算（ 1/(xxx) + 1/(x*x) ）。正方形和立方体是异步独立计算的。

我可以这样计算：

InitComputer(2) // returns a promise
.then(invert)
.then(function(arg){
    return Promise.all([
        proto.square(arg),
        proto.cube(arg)
    ]);
}).spread(function(sq, cu){
    this.set(sq + cu);
}).catch(function(err){
    console.log('err:', err);
}).finally(endComputer);

但我发现 all 的这种用法与理论上可能的用法相比太重了。当您将函数作为参数传递给then 时，它会被执行。当您将函数传递给all 时，它们不是，有一个错误。我怀疑我缺少实用程序或模式...

有没有办法把它改成这种风格的更简单的东西：

InitComputer(2)
.then(invert)
.all([
    proto.square,
    proto.cube
]).spread(function(sq, cu){
    this.set(sq + cu);
}).catch(function(err){
    console.log('err:', err);
}).finally(endComputer);

?

我可能会破解 Promise.prototype.all 或定义一个新函数以避免增加多态性，但我只对不涉及修改我不拥有的对象的解决方案感兴趣。

---

附件：

以下是我的测试“计算机”的定义方式：

var Promise = require("bluebird");

function Computer(){}
function InitComputer(v){
    // initializing a computer is asynchronous and may fail hence the promise
    var c = new Computer(), resolver = Promise.defer();
    setTimeout(function(){
        if (v>1) resolver.resolve(v);
        else resolver.reject(new Error("bad value: "+v));
    },100);
    return resolver.promise.bind(c);
}
var proto = Computer.prototype;
proto.square = function(x){
    // imagine this really uses the computer and is asynchronous
    if (!this instanceof Computer) throw new Error('not a computer');
    return x*x
}
proto.cube = function(x){ return x*x*x }
proto.set = function(v){ this.value = v }

function endComputer(){
    // releases resources here
    console.log('value:', this.value);
}

// this asynchronous function doesn't involve or know the computer
function invert(v){ return 1/v }

Answer 1

您不必在那里使用Promise.all。而不是这样做：

.then(function(arg){
    return Promise.all([
        proto.square(arg),
        proto.cube(arg)
    ]);
}).spread(...

你可以简单地使用：

.then(function(arg){
    return [proto.square(arg), proto.cube(arg)];
}).spread(...

如果我们在 node.js 中有箭头函数，它会很简单：

.then(arg => [proto.square(arg), proto.cube(arg)]).spread(...

Promise.all 用于当您需要开始至少有 2 个承诺的承诺链。例如：

var promise1 = somePromise();
var promise2 = somePromise2();

// Start the chain here
Promise.all([promise1, promise2])
.spread(function(value1, value2) {
    // ...
});

Answer 2

对于您提到的资源用例管理，bluebird 有Promise.using()。 Promise.using() 让您设置 disposer() 函数，以便在您完成使用后自动关闭异步检索的资源

Promise.join() 也有助于结合 cube 和 square 异步方法的结果

在这里，我稍微重写了您的 InitComputer 示例以说明其工作原理 - 它现在返回 Computer 实例，并将 val 添加为属性，而不是 val，我还将 endComputer 放在原型上

注意：您始终可以像这样使用Promise.method() 而不是返回延迟：

var invert = Promise.method(function invert(v){ return 1/v })

新的 initComputer：

function InitComputer(v){
    var c = new Computer(), resolver = Promise.defer();
    setTimeout(function(){
        if (v>1) {
            c.val = v;
            resolver.resolve(c);
        }
        else resolver.reject(new Error("bad value: "+v));
    },100); /** notice resource disposer function added below **/
    return resolver.promise.bind(c).disposer(function(compu){compu.endComputer()});
}

新代码：

Promise.using(InitComputer(1.2), function(computer){
    return invert(computer.val)
    .then(function(inverted){
        return Promise.join(computer.square(inverted), computer.cube(inverted), 
            function(sq, cu){
                computer.set(sq + cu)
            }
        )
    })
    .catch(function(err){
        console.log('err:', err);
    });
})