Backbone.js：比較一個集合中的模型屬性

Question

我有一個無限範圍的集合（可以是0，可以是1000，可以是一百萬）。我需要搜索集合中每個模型的屬性，並返回相同的屬性（及其值）。

舉例來說，如果我有收集以下三種模式：

modelOne: 
    color: "red" 
    age: 10 
    size: "large" 

modelTwo: 
    color: "red" 
    age: 11 
    size: "medium" 

modelThree: 
    color: "red" 
    age: 9 
    size: "large" 

我需要的應用程序返回color: "red"（或可以分析一些其他的推導），因爲它是唯一的屬性，在所有三種模型中都是相同的。

編輯 John Munsch的解決方案工作得很好，但現在需求發生了變化，因爲現在有些屬性可以是數組。有沒有辦法比較數組的常規屬性和屬性？

新的代碼示例：

modelOne: 
    color: "red" 
    age: 10 
    sizes: ["small", "large"] 

modelTwo: 
    color: "red" 
    age: 9 
    sizes: ["small", "large"] 

Answer 1

這裏有一個快速的jsfiddle與我的版本的答案：http://jsfiddle.net/JohnMunsch/3NMGD/

注：兩個的jsfiddle及以下已更新的代碼，以反映該變更的要求題。

var model = [ 
    { 
     color: "red", 
     age: 10, 
     size: [ "small", "large" ] 
    }, 
    { 
     color: "red", 
     age: 11, 
     size: [ "small", "large" ] 
    }, 
    { 
     color: "red", 
     age: 9, 
     size: [ "small", "large" ] 
    } 
]; 

function findCommonalities(data) { 
    if (data.length > 0) { 
     // It's safe enough to get the list of keys from the very first 
     // element. If the later ones differ, you know that the keys they 
     // had but the first element didn't are guaranteed not to be in 
     // the common set anyway because the first element didn't 
     // have them. 
     var keys = _.keys(data[0]); 
     var commonalities = { }; 

     _.each(keys, 
      function (key) { 
       var values = _.pluck(data, key); 

       if (values.length == data.length) { 
        // Sadly calling _.uniq() won't work when the values 
        // plucked out are arrays themselves. It calls === 
        // and that's not sufficient for arrays. 
        if (_.isArray(values[0])) { 
         // However, we can get a little tricky here. 
         // What if we _.zip() together all of the arrays 
         // (assuming the ordering for each array is the 
         // same) then we'll end up with an array of 
         // arrays where each one can again be tested 
         // with _.uniq() because each one will contain 
         // the same value taken from each array. 
         var zippedValues = _.zip(values); 
         console.log("zippedValues", zippedValues); 

         if (!_.find(zippedValues, 
          function (zippedValue) { 
           var uniqueValues = _.uniq(zippedValue); 

           // Note: This test is the inverse of the 
           // one below. We're trying to find any 
           // array that has more than one value in 
           // it. If we do then there's some 
           // variance. 
           return uniqueValues.length != 1; 
          })) { 
          // We didn't find any arrays that had any 
          // variance so we want this as well. 
          commonalities[key] = values[0]; 
         } 
        } else { 
         var uniqueValues = _.uniq(values); 

         if (uniqueValues.length == 1) { 
          commonalities[key] = uniqueValues[0]; 
         } 
        } 
       } 
      } 
     ); 

     return commonalities; 
    } else { 
     return { }; 
    } 
} 

console.log("commonalities: ", findCommonalities(model)); 

性能優良似乎一個小數字鍵和少量的物品，但你需要有一百萬條記錄和大量鍵來測試它。