有效地加入兩個集合？

Question

我遇到了在那裏我試圖加入類似下面的那些兩個數組的一個問題：

var participants = [ 
         {id: 1, name: "abe"}, 
         {id:2, name:"joe"} 
        ]; 
var results = [ 
        [ 
         {question: 6, participantId: 1, answer:"test1"}, 
         {question: 6, participantId: 2, answer:"test2"} 
        ], 
        [ 
         {question: 7, participantId: 1, answer:"test1"}, 
         {question: 7, participantId: 2, answer:"test2"} 
        ] 
       ]; 

使用嵌套循環：

_.each(participants, function(participant) { 
    var row, rowIndex; 
    row = []; 
    var rowIndex = 2 
    return _.each(results, function(result) { 
    return _.each(result, function(subResult) { 
     var data; 
     data = _.find(subResult, function(part) { 
     return part.participantId === participant.id; 
     }); 
     row[rowIndex] = data.answer; 
     return rowIndex++; 
    }); 
    }); 
}); 

這隻要陣列小工程確定，但是一旦它們變大，我就會遇到巨大的性能問題。以這種方式組合兩個數組有沒有更快的方法？

這是我的真實數據集/代碼的瘦身版本。請讓我知道是否有任何意義。

FYI

我的最終目標是創建行的集合包含他們的回答每一個參與者。喜歡的東西：

[ 
    ["abe","test1","test1"], 
    ["joe","test2","test2"] 
] 

Answer 1

的PERF *是不是從for循環，所以你可以改變他們_迭代，如果他們總值你出去

var o = Object.create(null); 

for(var i = 0, len = participants.length; i < len; ++i) { 
    o[participants[i].id] = [participants[i].name]; 
} 

for(var i = 0, len = results.length; i < len; ++i) { 
    var innerResult = results[i]; 
    for(var j = 0, len2 = innerResult.length; j < len2; ++j) { 
     o[innerResult[j].participantId].push(innerResult[j].answer); 
    } 

} 

//The rows are in o but you can get an array of course if you want: 

var result = []; 

for(var key in o) { 
    result.push(o[key]); 
} 

*好吧，如果_使用本地.forEach那麼這很容易數量級比循環要慢，但你現在的問題仍然是4個嵌套循環，所以你可能在修復之後甚至不需要額外的10倍。

Answer 2

還沒有大量數據的測試，但這裏有一個辦法：

var groups = _.groupBy(_.flatten(results),'participantId'); 
var result =_.reduce(groups,function(memo,group) { 
    var user = _.find(participants,function(p) { return p.id === group[0].participantId; }); 
    var arr = _.pluck(group,'answer'); 
    arr.unshift(user.name); 
    memo.push(arr); 
    return memo ; 
},[]); 

組的量將是你有這麼然後再遍歷與不成倍增長陣列的數量就好像你打電話_.each(_.each(_.each這可能是相當昂貴的。

再次，應該測試。

Answer 3

下面是使用ECMA5方法

的Javascript

var makeRows1 = (function() { 
    "use strict"; 

    function reduceParticipants(previous, participant) { 
     previous[participant.id] = [participant.name]; 

     return previous; 
    } 

    function reduceResult(previous, subResult) { 
     previous[subResult.participantId].push(subResult.answer); 

     return previous; 
    } 

    function filterParticipants(participant) { 
     return participant; 
    } 

    return function (participants, results) { 
     var row = participants.reduce(reduceParticipants, []); 

     results.forEach(function (result) { 
      result.reduce(reduceResult, row); 
     }); 

     return row.filter(filterParticipants); 
    }; 
}()); 

這會不會是一樣快，使用原始for循環，像@Esailija答案的解決方案，但它並不像你想象的那麼慢。這肯定比使用Underscore快，比如你的例子或@Maroshii給出的答案

無論如何，這三個答案中的一個jsFiddle表明它們都給出了相同的結果。它使用了相當大的數據集，我不知道它與您使用的大小相比。該數據與以下產生：

的Javascript

function makeName() { 
    var text = "", 
     possible = "abcdefghijklmnopqrstuvwxy", 
     i; 

    for (i = 0; i < 5; i += 1) { 
     text += possible.charAt(Math.floor(Math.random() * possible.length)); 
    } 

    return text; 
} 

var count, 
    count2, 
    index, 
    index2, 
    participants = [], 
    results = []; 

for (index = 0, count = 1000; index < count; index += 4) { 
    participants.push({ 
     id: index, 
     name: makeName() 
    }); 
} 

for (index = 0, count = 1000; index < count; index += 1) { 
    results[index] = []; 
    for (index2 = 0, count2 = participants.length; index2 < count2; index2 += 1) { 
     results[index].push({ 
      question: index, 
      participantId: participants[index2].id, 
      answer: "test" + index 
     }); 
    } 
} 

最後，我們有一個jsperf這三種方法，對所生成的數據集運行進行比較。