在NodeJS中优化比较大量数据

Question

我在nodejs中有一个大的多维对象，比如50 MB JSON。它包含生物数据的变化。我想我可以充分简化它：

{
    lads : {
        // a lad
        lad4515643 : {
            brains  : {
                // a brain
                brain1256251 : {
                    var01 : 'lala',
                    var02 : 'jaja',
                    var99 : 'haha',
                },
                // another brain
                brain3567432 : {},
                brain4867321 : {},
                brain5145621 : {} // etc
            },
            var01 : 'foo',
            var02 : 'bar',
            var99 : 'baz'
        },
        // another lad
        lad4555672 : {},
        lad5625627 : {},
        lad7457255 : {} // etc
    }
}

我需要将lads与brains的所有组合与所有lads与brains进行比较，以查看哪些是＆＃34;更好＆＃34;，按顺序制作某种层次结构。一些父lads个密钥会对brains比较产生影响。

我认为，使用引用对对象进行迭代，我们可以轻松地分配更好的ID。快速浏览代码（评论），你就明白了我的意思：

// Iterate over lads
for (var ladId in obj.lads) {
    if (obj.lads.hasOwnProperty(ladId)) {
        var lad = obj.lads[ladId];

        // Iterate over brains
        for (var brainId in lad.brains) {
            if (lad.brains.hasOwnProperty(brainId)) {
                var brain = lad.brains[brainId];

                // Iterate over lads again
                for (var lad2Id in obj.lads) {
                    if (obj.lads.hasOwnProperty(lad2Id)) {
                        var lad2 = obj.lads[lad2Id];

                        // Iterate over this lads' brains
                        for (var brain2Id in lad2.brains) {
                            if (lad2.brains.hasOwnProperty(brain2Id)) {
                                var brain2 = lad2.brains[brain2Id];

                                // One lad+brain combination
                                var drone1 = {
                                    lad : lad,
                                    brain : brain
                                };

                                // Another lad+brain combination
                                var drone2 = {
                                    lad : lad2,
                                    brain : brain2
                                    ladId : lad2Id, // Required to store the reference if better
                                    brainId : brain2Id // Required to store the reference if better
                                };

                                // Do the comparison unless we are comparing ourselves
                                if (brain != brain2) {
                                    // Objects are passed as reference, so this is convenient:
                                    judge(drone1, drone2);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

// Judge who is better
function judge(drone1, drone2) {
    // some magic that compares lad+brain combos
    if (magic) {
        // Add list of better versions
        drone1.brain.better = drone1.brain.better || [];

        // Everything is passed by reference - I can modify the original brain object directly
        drone1.brain.better.push({
            ladId : drone2.ladId,
            brainId : drone2.brainId
        });
    }
}

当然，当数据集增加时，迭代次数会增加指数。总共有3000 brains，已经有900万次迭代，其中魔法加起来的执行时间超过10秒。

除了使用多个线程之外，在这样的场景中，哪些优化（非常）有益？

由于judge()纯粹是数学，如果我将迭代的每一步转换为回调样式，它真的会有所不同吗？ （在我的想象中，这只会造成匿名函数和内存使用的巨大开销。）