(JavaScript) 将 forEach 循环与内部回调同步

Question

我在双 forEach 循环中进行一些计算，如下所示：

array.forEach(function(element){
    Object.keys(element).forEach(function(key){

        /* some complex computations with asynchronous callbacks  */        

    });
});

someFunctionHere();

有没有办法让循环在执行someFunctionHere( ) 函数之前先完成？或者程序在继续someFunctionHere( )之前知道循环是否完成的任何方式...

我可能错过了一些论坛，但我发现的那些并没有帮助我实现我想要实现的目标，顺便说一下我在 NodeJS 中这样做的方式，我也在问是否有现有的库可以实现这一点。

我忘了添加这个还是应该是另一个问题？

有没有办法同步进行迭代，只有在当前迭代完成后才会进行下一次迭代？ （对不起）

感谢您的帮助...

Answer 1

let dataObject = {};
Promise.all(objectArray.map(object => {
        return new Promise(resolve => {
            yourFunction(object, anotherParameter).then(returnValue => {
                dataObject[object] = returnValue;
                resolve();
            });
        });
    })).then(() => {
        return dataObject;
    });

Answer 2

对于支持 Promise（或使用 polyfill）/nodejs 的浏览器，我自己实现了一个带有回调的 forEach 的同步版本，所以我将在这里分享..

回调必须返回一个承诺..

function forEachSync(array, callback) {
    let lastIndex = array.length - 1;
    let startIndex = 0;

    return new Promise((resolve, reject) => { // Finish all
        let functionToIterateWith = (currIndex) => {
            if (currIndex > lastIndex) {
                return resolve();
            } else {
                callback(array[currIndex]).then(() => {
                    functionToIterateWith(currIndex + 1);
                }).catch(err => reject(err));
            }
        }

        functionToIterateWith(startIndex);
    });
}

Answer 3

高性能解决方案：

在某些情况下，您可能希望/允许异步/并行处理数组，但希望在处理完所有 forEach 成员后调用函数。 示例：

var async = require('async');

async.forEach(array,function(elementOfArray, callback){
    //process each element of array in parallel 
    // ..
    // ..
    // .. 
    callback(); //notify that this iteration is complete
}, function(err){
 if(err){throw err;}
 console.log("processing all elements completed");
});

因此，您可以通过这种方式执行非阻塞 CPU 密集型操作。

注意：当您将 eachSeries 用于大型数组时，如此多的迭代回调可能会溢出堆栈。

在这里阅读： https://github.com/caolan/async#control-flow

Answer 4

看看 async.js，尤其是它的 control flow 语句，例如 each whilst 和 until。

使用 async.js 你可以得到你想要的。

在您的实际情况下，您需要的是 each 函数（以前称为 forEach），分别是 eachSeries 函数，它不是并行运行单次迭代，而是串行运行（参见documentation for eachSeries了解详情）。

举个例子：

async.eachSeries([ 2, 3, 5, 7, 11 ], function (prime, callback) {
  console.log(prime);
  callback(); // Alternatively: callback(new Error());
}, function (err) {
  if (err) { throw err; }
  console.log('Well done :-)!');
});

这将遍历素数数组并以正确的顺序打印它们，一个接一个，最后打印出Well done :-)!。

Answer 5

您可以将回调包装在倒计时闭包中：

var len = array.length;

function countdownWrapper(callback, callbackArgs) {
    callback(callbackArgs);
    if (--len == 0) {
        someFunctionHere();
    }
}

array.forEach(function(element){
    Object.keys(element).forEach(function(key){

        var wrappedCallback = countdownWrapper.bind(callback);
        /* some complex computations with asynchronous WRAPPED callbacks  */

    });
});

如果回调有不同数量的参数，您可以对arguments 做一些小手术，而不是使用显式的callbackArgs 参数。

编辑您的编辑阐明了您希望在前一个计算完成回调后开始每个复杂计算。这也可以通过闭包轻松安排：

function complexOp(key, callback) { /* . . . */ }

function originalCallback(...) { /* . . . */ }

function doSomethingElse() { /* . . . */ }

var iteratorCallback = (function (body, callback, completion) {
    var i = 0, len = array.length;
    return function iterator() {
        callback.apply(null, arguments);
        if (++i < len) {
            body(array[i], iterator);
        } else {
            completion();
        }
    };
}(complexOp, originalCallback, doSomethingElse)); 

// kick everything off:
complexOp(array[0], iteratorCallback);