Javascript嵌套数组转换

Question

我试图让我的头绕着Javascript数组函数。我有一个嵌套的数组像这样，在每一行覆盖相同时间段：

[{ 
    "category": "fruit", 
    "variety": "apple", 
    "data": [{ 
     "day": 1, 
     "units": 2 
    }, {"day": 2, 
     "units": 4 
    }] 
},{ 
    "category": "fruit", 
    "variety": "orange", 
    "data": [{ 
     "day": 1, 
     "units": 3 
    }, {"day": 2, 
     "units": 5 
    }] 
},{ 
    "category": "veg", 
    "variety": "tomato", 
    "data": [{ 
     "day": 1, 
     "units": 4 
    }, {"day": 2, 
     "units": 2 
    }] 
}] 

我想白天按类别进行总结的单位，要得到这样的数组：

[{ 
    "category": "fruit", 
    "data": [{ 
     "day": 1, 
     "units": 5 
    }, {"day": 2, 
     "units": 9 
    }] 
},{ 
    "category": "veg", 
    "data": [{ 
     "day": 1, 
     "units": 4 
    }, {"day": 2, 
     "units": 2 
    }] 
}] 

我一直在通过长循环if语句来解决这个问题，并对它做了一些散列。你能看到一个优雅的方式来解决这个问题吗？

非常感谢！

Answer 1

解决方案非常明显：循环访问数组，并将数据存储在键值对中。然后，循环访问has，并使用Array.prototype.map构造得到的数组。最后，如果您想要一个格式良好的JSON字符串，请使用JSON.stringify(result, null, 4);，其中4是相当格式化的间隔数。

演示：http://jsfiddle.net/jde6S/

var list = [ ... ]; 
var hash = {}; 
for (var i=0; i<list.length; i++) { 
    var obj = list[i]; 

    // This part makes sure that hash looks like {fruit:[], veg: []} 
    var hashObjCat = hash[obj.category]; 
    if (!hashObjCat) { 
     hashObjCat = hash[obj.category] = {}; 
    } 

    // This part populates the hash hashObjCat with day-unit pairs 
    for (var j=0; j<obj.data.length; j++) { 
     var data = obj.data[j]; 
     if (hashObjCat[data.day]) hashObjCat[data.day] += data.units; 
     else hashObjCat[data.day] = data.units; 
    } 
} 
// Now, we hash looks like {fruit: {1:5, 2:9} } 
// Construct desired object 
var result = Object.keys(hash).map(function(category) { 
    // Initial object 
    var obj = {category: category, data:[]}; 
    var dayData = Object.keys(hash[category]); 
    // This part adds day+units dicts to the data array 
    for (var i=0; i<dayData.length; i++) { 
     var day = dayData[i]; 
     var units = hash[category][day]; 
     obj.data.push({day: day, units: units}); 
    } 
    return obj; 
}); 
// Test: 
console.log(JSON.stringify(result, null, 4)); 

Answer 2

如果您愿意获取一些外部代码并使用它来实质性地重新索引您的结构，那么您可能会做一些事情。我知道旧的dojo数据API是一团糟的工作，但可能允许像你似乎要求的东西。

就我个人而言，我会坚持循环，只是保持您的变量名称可读。还要记住，对象文字可以作为数组/哈希语法x [y]或点语法x.y

Answer 3

reduce数组对象（见@ RobW的答案如何做到这一点与循环）：

var data = [...] // your input 

// Iterate the data with reduce... 
var sumsbycategory = data.reduce(function(map, fruit) { 
    var cat = fruit.category; 
    // set an property to an object, iterating the days array... 
    map[cat] = fruit.data.reduce(function(sums, day) { 
     var d = day.day; 
     // set or update the units for this day 
     sums[d] = (sums[d] || 0) + day.units; 
     return sums; // into the next iteration 
    }, map[cat] || {}) // ...passing in the already existing map for this cat or a new one 
    return map; // into the next iteration 
}, {}); // ...passing in an empty object 

现在，我们有以下格式：

{"fruit":{"1":5,"2":9},"veg":{"1":4,"2":2}} 

......我认为这样更容易处理，但让我们建立y我们的阵列：

var result = []; // init array 
for (var cat in sumsbycategory) { // loop over categories 
    var data = []; // init array 
    // add category object: 
    result.push({category:cat, data:data}); 
    for (var day in sumsbycategory[cat]) // loop over days in category 
     // add day object 
     data.push({day:day, units:sumsbycategory[cat][day]}); 
} 

但是，等等！一个对象没有顺序，并且可能发生day2在结果数组中出现days1之前（这可能会破坏您的应用程序？）因此，您可以在该对象的keys上使用10，该对象也可以是sorted，以生成数组在一个干净的前瞻性表达：

var result = Object.keys(sumsbycategory).map(function(cat) { 
    return { 
     category: cat, 
     data: Object.keys(sumsbycategory[cat]) 
     .sort(function numbercompare(a,b){ return a-b; }) 
     .map(function(day) { 
      return { 
       day: day, 
       units: sumsbycategory[cat][day] 
      }; 
     }) 
    }; 
}); 

结果：

[{ 
    "category": "fruit", 
    "data": [{"day":"1","units":5},{"day":"2","units":9}] 
},{ 
    "category": "veg", 
    "data": [{"day":"1","units":4},{"day":"2","units":2}] 
}] 

（Demo at jsfiddle.net）