承诺在for循环中更改全局变量

Question

我正在尝试对不同风格的javascript代码进行一些基准测试，这是我所拥有的：

var Promise = require('bluebird');

var timer = function(name) {
    var start = new Date();
    return {
        stop: function() {
            var end  = new Date();
            var time = end.getTime() - start.getTime();
            console.log('Function:', name, 'finished in', time, 'ms');
        }
    };
};

function regular (a, cb) {
    if (a % 2 === 0) return cb(null, a);
    return cb(a);
}

function promise (a) {
    return new Promise (function (resolve, reject) {
        if (a % 2 === 0) resolve(a);
        else reject(a);
    });
}


var t = timer('regular');
var g = 0;
for (var i = 1; i < 10001; i++) {
    regular(i, function(odd, even) {
        if (odd) g = g + (odd * 2);
        else g = g + (even * 3);
    });
}
console.log('g:', g); // g: 125015000
t.stop();

var t2 = timer('promise');
var h = 0;
for (var i = 1; i < 10001; i++) {
    promise(i).then(function(x) {h = h + (x*3);}).catch(function(x) {h = h + (x*2);});
}
console.log('h:', h); // h: 0
t2.stop();

有意思的是，承诺不会改变全局变量'h'，我怎样才能使它返回与变量'g'相同的结果？

UPDATE

这里是更改的代码，试图获得最终结果，但承诺的非确定性给我们意想不到的结果。

for (var i = 1; i < 10001; i++) {
    promise(i).then(function(x) {
        h = h + (x*3); if (x===10000) console.log('h:', h);
    }).catch(function(x) {h = h + (x*2);}); // h: 75015000 
}

目前我提供预期输出的代码甚至更奇怪。

for (var i = 1; i < 10001; i++) {
    promise(i).then(function(x) {
        h = h + (x*3);
    }).catch(function(x) {
        h = h + (x*2);
        if (x===9999) console.log('h:', h);  // <- attention here
    }); // h: 125015000
}

谁能告诉我更好的代码并解释上面的代码？ （上面的代码显示当i为9999而非10000时的确定性正确结果）

Answer 1

承诺随时拨打他们.then()或.catch()处理程序异步。 即使他们立刻解决，他们将让JS执行完毕的当前线程并调用.then()或.catch()异步处理“下一步打勾”。

因此你的console.log('h:', h); 在调用循环之前的任何.then()处理程序之前执行。 如果将console.log()语句放在.catch() .then()和.catch()处理程序中，你会发现它们被调用，但在你的console.log('h:', h); 叫做。

Promise被设计为异步接口。 而且，它是非常重要的异步接口始终是一致的所以即使承诺是同步解决，他们仍然称自己的.then()和.catch()处理程序异步的下一个节拍，使他们始终保持一致和开发利用他们不需要担心有时会得到异步响应，有时会得到同步响应。 相反，它们始终是异步响应。

正如我在评论中所说，任何现实世界的编码情况都应该只对至少有时异步的操作使用promises。 如果你的操作总是同步的（如上面的例子那样），那么它们就不应该使用promises，因为promises只是使同步操作比使用直接同步函数调用更复杂。

此外，您的循环中的多个承诺操作不会以任何给定的方式排序或协调。 如果这些是真正的异步操作，它们可以按任何顺序完成，并且你对h变量的更新将具有不确定的顺序（这通常是一个问题，因此通常是一个糟糕的设计模式）。

Answer 2

为了解决与承诺你的问题你可以用所有的then用方法reduce和听取各方承诺完成，这是连续运行的承诺。

如果你喜欢你也可以使用Promise.all()并行运行所有的promises。

 function promise (a) { return new Promise (function (resolve, reject) { if (a % 2 === 0) resolve(a); else reject(a); }); }; var timer = function(name) { var start = new Date(); return { stop: function() { var end = new Date(); var time = end.getTime() - start.getTime(); console.log('Function:', name, 'finished in', time, 'ms'); } }; }; console.log('Right result', Array.from({length : 10000}, (el, i)=> (i + 1) % 2 === 0 ? (i+1)*3 : (i+1)*2).reduce((a,b)=> a + b)); var t2 = timer('promise'); var h = 0; Promise.all(Array.from({length : 10000}, (el, i)=> promise(i + 1).then(x =>{ h += x*3}).catch(x =>{ h += x*2 }) )) .then(()=>{ console.log('h:', h); t2.stop(); });