Comment convertir ceci:
[
{food: 'Apple', type: 'fruit'},
{food: 'potato', type: 'vegetable'},
{food: 'banana', type: 'fruit'},
]
dans ceci:
[
{type: 'fruit', foods: ['Apple', 'banana']},
{type: 'vegetable', foods: ['potato']}
]
en utilisant javascript ou underscore
En supposant que la liste d'origine est contenue dans une variable nommée list
:
_
.chain(list)
.groupBy('type')
.map(function(value, key) {
return {
type: key,
foods: _.pluck(value, 'food')
}
})
.value();
Sans utiliser le trait de soulignement:
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/
Le mérite revient à @ErikE pour l'amélioration/la réduction de mon code d'origine afin de faciliter la redondance :)
Voici une version légèrement différente mais plus générique de la réponse de @ Ian
Caveat: le résultat est légèrement différent de l'exigence OP, mais d'autres, comme moi, qui tombent sur cette question pourraient bénéficier d'une réponse plus générique à mon humble avis
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'));
Vous pouvez trouver un jsfiddle ici
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();
Une solution ES6 à cette vieille question:
Itérez à l'aide de Array#reduce
et rassemblez les éléments par groupe dans une Map
. Utilisez spread pour convertir le Map#values
back en tableau:
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);
Vous pouvez également utiliser d'autres fonctionnalités ES6 telles que:
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');
Vous pouvez grouper un tableau d'objets par l'un des champs avec la bibliothèque Alasql. Cet exemple compacte des tableaux exactement comme dans votre exemple:
var res = alasql('SELECT type, ARRAY(food) AS foods FROM ? GROUP BY type',[food]);
Essayez cet exemple à jsFiddle .