How to convert this:
[
{food: 'apple', type: 'fruit'},
{food: 'potato', type: 'vegetable'},
{food: 'banana', type: 'fruit'},
]
into this:
[
{type: 'fruit', foods: ['apple', 'banana']},
{type: 'vegetable', foods: ['potato']}
]
using javascript or underscore
Assuming the original list is contained in a variable named list:
_
.chain(list)
.groupBy('type')
.map(function(value, key) {
return {
type: key,
foods: _.pluck(value, 'food')
}
})
.value();
Without using underscore:
var origArr = [
{food: 'apple', type: 'fruit'},
{food: 'potato', type: 'vegetable'},
{food: 'banana', type: 'fruit'}
];
/*[
{type: 'fruit', foods: ['apple', 'banana']},
{type: 'vegetable', foods: ['potato']}
]*/
function transformArr(orig) {
var newArr = [],
types = {},
i, j, cur;
for (i = 0, j = orig.length; i < j; i++) {
cur = orig[i];
if (!(cur.type in types)) {
types[cur.type] = {type: cur.type, foods: []};
newArr.push(types[cur.type]);
}
types[cur.type].foods.push(cur.food);
}
return newArr;
}
console.log(transformArr(origArr));
DEMO: http://jsfiddle.net/ErikE/nSLua/3/
Credit goes to @ErikE for improving/reducing my original code to help with redundancy I had :)
newArr.push(types[cur.type]); inside your if block and remove the second for loop entirely.
types) and it will be reflected in newArr. Thanks for pointing that out! Though I'd hardly call my old code awkward...it made sense as a "lookup" to me at least :)Here is a slightly different but more generic version of @Ian's answer
Caveat: the result is slightly different from the OP requirement, but others like me who stumble on this question might benefit from a more generic answer IMHO
var origArr = [
{food: 'apple', type: 'fruit'},
{food: 'potato', type: 'vegetable'},
{food: 'banana', type: 'fruit'}
];
function groupBy(arr, key) {
var newArr = [],
types = {},
newItem, i, j, cur;
for (i = 0, j = arr.length; i < j; i++) {
cur = arr[i];
if (!(cur[key] in types)) {
types[cur[key]] = { type: cur[key], data: [] };
newArr.push(types[cur[key]]);
}
types[cur[key]].data.push(cur);
}
return newArr;
}
console.log(groupBy(origArr, 'type'));
You can find a jsfiddle here
An ES6 solution to this old question:
Iterate using Array#reduce, and collect the items by group into a Map. Use spread to convert the Map#values back into array:
const data = [
{food: 'apple', type: 'fruit'},
{food: 'potato', type: 'vegetable'},
{food: 'banana', type: 'fruit'},
];
const result = [...data.reduce((hash, { food, type }) => {
const current = hash.get(type) || { type, foods: [] };
current.foods.push({ food });
return hash.set(type, current);
}, new Map).values()];
console.log(result);
var foods = [
{food: 'apple', type: 'fruit'},
{food: 'potato', type: 'vegetable'},
{food: 'banana', type: 'fruit'}
];
var newFoods = _.chain( foods ).reduce(function( memo, food ) {
memo[ food.type ] = memo[ food.type ] || [];
memo[ food.type ].push( food.food );
return memo;
}, {}).map(function( foods, type ) {
return {
type: type,
foods: foods
};
}).value();
You can group array of objects by one of fields with Alasql library. This example compact arrays exactly as in your example:
var res = alasql('SELECT type, ARRAY(food) AS foods FROM ? GROUP BY type',[food]);
Try this example at jsFiddle.
You could also use other ES6 Features such as:
function groupArray(arr, groupBy, keepProperty) {
let rArr = [], i;
arr.forEach(item => {
if((i = rArr.findIndex(obj => obj[groupBy] === item[groupBy])) !== -1)
rArr[i][`${keepProperty}s`].push(item[keepProperty]);
else rArr.push({
[groupBy]: item[groupBy],
[`${keepProperty}s`]: [item[keepProperty]]
});
});
return rArr;
}
groupArray(yourArray, 'type', 'food');
You can achieve this by using Array.group() method along with Array.forEach() which is currently in Experimental stage. I will suggest you to Check the Browser compatibility table carefully before using this in production.
Below code snippet will only work in Firefox Nightly as currently Array.group() does not have support for any other browsers.
// Input array
const inventory = [
{food: 'apple', type: 'fruit'},
{food: 'potato', type: 'vegetable'},
{food: 'banana', type: 'fruit'},
];
// Return the object grouped with type property.
const result = inventory.group(({ type }) => type);
// declaring an empty array to store the final results.
const arr = [];
// Iterating the group object to structure the final result.
Object.keys(result).forEach((item, index) => {
result[item] = result[item].map(({ food }) => food);
arr.push({
type: item,
foods: result[item]
})
});
// Output
console.log(arr);