obiektów grupa posesją w javascript

Question

Jak przekonwertować to:

[ 
    {food: 'apple', type: 'fruit'}, 
    {food: 'potato', type: 'vegetable'}, 
    {food: 'banana', type: 'fruit'}, 
] 

w tym:

[ 
    {type: 'fruit', foods: ['apple', 'banana']}, 
    {type: 'vegetable', foods: ['potato']} 
] 

użyciu JavaScript lub podkreślenia

Answer 1

Zakładając oryginalny wykaz jest zawarty w zmienna o nazwie list:

_ 
.chain(list) 
.groupBy('type') 
.map(function(value, key) { 
    return { 
     type: key, 
     foods: _.pluck(value, 'food') 
    } 
}) 
.value(); 

Answer 2

Bez użycia podkreślenia:

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/

zasługa @ErikE na poprawę/zmniejszenie mój oryginalny kod, aby pomóc z redundancją miałem :)

Answer 3

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(); 

http://jsbin.com/etaxih/2/edit

Answer 4

Możesz grupować tablice obiektów według jednego z pól z biblioteką Alasql. Ten przykład kompaktowe tablice dokładnie tak, jak w przykładzie:

var res = alasql('SELECT type, ARRAY(food) AS foods FROM ? GROUP BY type',[food]); 

wypróbować ten przykład at jsFiddle.

Answer 5

Tu jest nieco inna, ale bardziej ogólny wersja @ odpowiedź Iana

Zastrzeżenie: wynik jest nieco inny od wymogu PO, ale inni, jak ja, którzy potykają się na to pytanie może korzystać z bardziej rodzajowy oDPOWIEDŹ 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')); 

można znaleźć jsfiddle here

Answer 6

ES6 rozwiązanie tego stare pytanie:

Powtórz iterację za pomocą Array#reduce i odbierz elementy według grup do numeru Map. Użyj spread do konwersji Map#values powrotem do tablicy:

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);

Answer 7

Można również korzystać z innych funkcji, takich jak ES6:

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');