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中获取数据。然后没有什么可以合并，你可以返回那些数据。

在Node中将循环转换为异步

1 个答案: