javascript - 在 Node 中将循环转换为异步

Question

我有以下同步功能:

               for (var i = 0; i < results.length; i++) {
                        var key1 = results[i]['__key'];
                        for (var j = i + 1; j < results.length; j++) {
                            var key2 = results[j]['__key'];
                            if (key1 == key2) {
                                for (var k = 0; k < results[i].length; k++) {
                                    for (var z = 0; z < results[j].length; z++) {
                                        if (results[i][k][key1] == results[j][z][key2]) {
                                            results[i][k] = lodash.extend(results[j][z], results[i][k]);
                                            results[j].splice(z, 1);
                                        }
                                    }
                                }
                            }
                        }
                    }

我可以将所有 4 个循环更改为异步吗？我不确定前两个循环是否可以同步!我可以吗？我尝试将最后两个循环更改为异步，但它没有给我正确的结果？您能帮助我如何将同步循环更改为异步循环吗？

我的尝试:

             for (var i = 0; i < results.length; i++) {
                var key1 = results[i]['__key'];
                for (var j = i + 1; j < results.length; j++) {
                    var key2 = results[j]['__key'];
                    if (key1 == key2) {
                        async.each(results[i], function (resultA, callback) {

                            async.each(results[j], function (resultB, callback) {
                                if (resultA[key1] == resultB[key2]) {
                                    resultA = lodash.extend(resultB, resultA);
                                    results[j].splice(resultB, 1);
                                }
                                callback();
                            }, function (err) {
                                callback(err);
                            }), function (err) {
                                callback(err);
                            }
                        })
                    }
                }
            }

完整的算法:

        async.map(models, getData, function (err, results) {
            if (err) {
                res.json(400, err);
            } else {

                for (var i = 0; i < results.length; i++) {
                    var key1 = results[i]['__key'];
                    for (var j = i + 1; j < results.length; j++) {
                        var key2 = results[j]['__key'];
                        if (key1 == key2) {

                            for (var k = 0; k < results[i].length; k++) {
                                for (var z = 0; z < results[j].length; z++) {
                                    if (results[i][k][key1] == results[j][z][key2]) {
                                        results[i][k] = lodash.extend(results[j][z], results[i][k]);
                                        results[j].splice(z, 1);
                                    }
                                }
                            }
                        }
                    }
                }

                var mergedResult = [];
                mergedResult = mergedResult.concat.apply(mergedResult, results);
                res.json(200, mergedResult);
            }
        });


        function getData(model, next) {
            var data = db.getData(model.type, function (err, data) {
                data['__key'] = db.getKey(model.type).toString();
                next(err, data);
            });
        }

Answer 1

根据您的代码，我发现一个问题。看起来您正在迭代模型数组，并根据类型获取所有数据。然后，如果类型相同，则需要合并数组。但是，如果您传入相同的类型，db.getData() 应该返回相同的结果，因此以后不应合并任何内容。

根据我对您问题的理解，这样的事情会给您带来您正在寻找的结果，而不会出现所有循环困惑。

var results = {};

async.each(models, getData, function(err) {
  res.json(200, results);
});

function getData(model, next) {
  var key = db.getKey(model.type).toString();

  if(results[key]) {
    return next();
  }

  db.getData(model.type, function (err, data) {
    results[key] = data;
    next(err);
  });
}

如果您尚未检索数据，则只能从该 model.type 中获取数据。然后就不需要合并任何内容，您只需返回该数据即可。