Javascript 在节点中将循环转换为异步

我有以下同步功能：

               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);
                                        }
                                    }
                                }
                            }
                        }
                    }

for（var i=0；i

我可以将所有4个循环都更改为异步吗？我不确定前两个循环是否可以同步！我可以吗？我曾尝试将最后两个循环更改为async，但它没有给出正确的结果？你能帮我把同步循环改成异步循环吗

我的尝试：

             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);
                            }
                        })
                    }
                }
            }

for（var i=0；i

完整算法：

        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);
            });
        }

async.map（模型、获取数据、函数（错误、结果）{
如果（错误）{
res.json（400，err）；
}否则{
对于（var i=0；i

根据您的代码，我发现了一个问题。看起来您正在迭代一组模型，并根据类型获取它们的所有数据。然后，如果类型相同，则需要合并数组。但是，如果传入相同的类型，则

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中的数据，则只能从该model.type中获取该数据。那么就没有什么可合并的了，您只需返回数据。

将原始代码更改为异步不会给您带来任何好处。如果有什么区别的话，将其更改为异步可能会引入更多的延迟。如果你的目的是让你的代码变得更“扁平”，这样你就可以把循环分解成函数，根据需要在它们之间传递参数。这将有助于减轻一些缩进/深度嵌套，这取决于迭代的项目数量，异步将为您带来很多好处。除了您自己的代码之外，节点中没有任何内容阻塞。像这样的深度嵌套循环会在相当长的时间内阻塞，这将阻止应用程序中发生任何其他事情。我忍不住认为有更好的方法来解决您的实际问题。数据从哪里来？它实际上是什么样子的？你能在得到这个结果之前修改数据吗？例如，如果您可以聚合项目，以便将具有相同_键的所有对象分组在一起，则可以删除其中一个循环和比较。感谢您的帮助：）我现在将完整的算法放在问题中！它在async.map中。。。数据（async.map的结果）是一个数组数组“如果类型相同，则需要合并数组。”不，如果它们的键相同，则不需要类型！您将从model.type中获得第一次比较的键<代码>数据['''u_-key']=db.getKey（model.type）.toString（）。