JavaScript - Подсчет и удаление дубликатов из массива объектов ES6

Question

Я в основном ищу аккуратное и лаконичное решение (возможно, с использованием ES6) для сокращения массива дубликатов объектов и подсчета количества дубликатов.

Так, например,

const items = [
   {
     id: 1,
     type: 'PEPSI',
   },
  {
     id: 1,
     type: 'PEPSI',
   },
  {
     id: 1,
     type: '7UP',
   },
  {
     id: 1,
     type: 'FANTA',
   },
  {
     id: 2,
     type: 'FANTA',
   },
  {
     id: 2,
     type: '7UP',
   },
  {
     id: 2,
     type: '7UP',
   }
];

function getItems(data, id) {
      return data.filter(x => x.id === id).map((item) => {
        const obj = {};
        obj.quantity = **I want the quantity to go here**
        obj.type = item.type;
        return obj;
      });
    }

Поэтому запуск функции getItems(items, 1) даст мне:

[
 { quantity: 2, type: 'PEPSI' },
 { quantity: 1, type: '7UP' },
 { quantity: 1, type: 'FANTA' }
]

Заранее спасибо!

Answer 1

Сначала вам нужно будет уменьшить, а затем перечислить элементы

const items  = [
   {
     id: 1,
     type: 'PEPSI',
   },
  {
     id: 1,
     type: 'PEPSI',
   },
  {
     id: 1,
     type: '7UP',
   },
  {
     id: 1,
     type: 'FANTA',
   },
  {
     id: 2,
     type: 'FANTA',
   },
  {
     id: 2,
     type: '7UP',
   },
  {
     id: 2,
     type: '7UP',
   }
];
let reducer = items.reduce(function (accumulator, currentElement) { let index = accumulator.findIndex(item=>item.id==currentElement.id && item.type==currentElement.type)
     if(index>=0){        
       accumulator[index].quantity+=1
       return [...accumulator]   
     }else{
       return [...accumulator,{...currentElement,quantity:1}]   
     }
    return accumulator
}, [])


let getItems = (items, id) => items.filter(item => item.id == id).map(item=>{return { type:item.type,quantity:item.quantity   }})

console.log(getItems(reducer,1))

Answer 2

Вот один из них вернет то, что вы хотите, вы можете поместить это в функцию, если вы хотите сделать то же самое для многих массивов, в противном случае я думаю, что все в порядке

const items = [
    {
      id: 1,
      type: 'PEPSI',
    },
   {
      id: 1,
      type: 'PEPSI',
    },
   {
      id: 1,
      type: '7UP',
    },
   {
      id: 1,
      type: 'FANTA',
    },
   {
      id: 2,
      type: 'FANTA',
    },
   {
      id: 2,
      type: '7UP',
    },
   {
      id: 2,
      type: '7UP',
    }
 ];
 
let tempObj = {};

for (const item of items) {
    if (tempObj[item.type] == undefined) {
        tempObj[item.type] = 1;
    }else{
        tempObj[item.type] += 1;
    }
}

//console.log(tempObj)

// And if you want to formet in a different way then 
let newTemp = [];
for (const key in tempObj) {
    let objNew = {
        quantity : tempObj[key],
        type : key
    }
    newTemp.push(objNew);
}

console.log(newTemp)

Answer 3

1. без уменьшения.

const items = [
          {
            id: 1,
            type: 'PEPSI',
          },
         {
            id: 1,
            type: 'PEPSI',
          },
         {
            id: 1,
            type: '7UP',
          },
         {
            id: 1,
            type: 'FANTA',
          },
         {
            id: 2,
            type: 'FANTA',
          },
         {
            id: 2,
            type: '7UP',
          },
         {
            id: 2,
            type: '7UP',
          }
       ];

const groupBy = (objectArray, property) => {
    return objectArray.reduce(function (total, obj) {
        let key = obj[property];
        if (!total[key]) {
            total[key] = 0;
        }
        total[key]+=1;
        return total;
    }, {});
 }

 let groupedArray = groupBy(items, 'type');

 console.log(groupedArray);

2. без уменьшения.

const items = [
      {
        id: 1,
        type: 'PEPSI',
      },
     {
        id: 1,
        type: 'PEPSI',
      },
     {
        id: 1,
        type: '7UP',
      },
     {
        id: 1,
        type: 'FANTA',
      },
     {
        id: 2,
        type: 'FANTA',
      },
     {
        id: 2,
        type: '7UP',
      },
     {
        id: 2,
        type: '7UP',
      }
   ];

const compressArray = original =>{
      var compressed = [];
      var copy = original.slice(0);
      for (var i = 0; i < original.length; i++) {

        var myCount = 0;    
        // loop over every element in the copy and see if it's the same
        for (var w = 0; w < copy.length; w++) {
          if (copy[w] && original[i].type == copy[w].type) {
            // increase amount of times duplicate is found
            myCount++;
            // sets item to undefined
            delete copy[w];
          }
        }

        if (myCount > 0) {
          var a = new Object();
          a.value = original[i].type;
          a.count = myCount;
          compressed.push(a);
        }
      }

      return compressed;
};

var counter = compressArray(items);
console.log(counter);

Answer 4

Я бы сделал что-то вроде:

function similar(needle, haystack, exact){
  if(needle === haystack){
    return true;
  }
  if(needle instanceof Date && haystack instanceof Date){
    return needle.getTime() === haystack.getTime();
  }
  if(!needle || !haystack || (typeof needle !== 'object' && typeof haystack !== 'object')){
    return needle === haystack;
  }
  if(needle === null || needle === undefined || haystack === null || haystack === undefined || needle.prototype !== haystack.prototype){
    return false;
  }
  var keys = Object.keys(needle);
  if(exact && keys.length !== Object.keys(haystack).length){
    return false;
  }
  return keys.every(function(k){
    return similar(needle[k], haystack[k]);
  });
}
function Samer(array){
  this.get = (id = null, type = null)=>{
    const a = array.slice(), l = a.length, s = [], r = [];
    if(id !== null){
      a.splice(0, l, ...a.filter(o=>o.id===+id));
    }
    if(type !== null){
      a.splice(0, l, ...a.filter(o=>o.type.match(new RegExp('^'+type+'$', 'i'))));
    }
    for(let o of a){
      let m = false;
      for(let i=0,v,l=s.length; i<l; i++){
        m = false; v = s[i];
        if(similar(o, v, true)){
          r[i].quantity++; m = true;
          break;
        }
      }
      if(!m){
        s.push(o); r.push({...o, quantity:1});
      }
    }
    return r;
  }
}
const items = [
   {
     id: 1,
     type: 'PEPSI',
   },
  {
     id: 1,
     type: 'PEPSI',
   },
  {
     id: 1,
     type: '7UP',
   },
  {
     id: 1,
     type: 'FANTA',
   },
  {
     id: 2,
     type: 'FANTA',
   },
  {
     id: 2,
     type: '7UP',
   },
  {
     id: 2,
     type: '7UP',
   }
];
const samer = new Samer(items);
console.log(samer.get());
console.log(samer.get(1));
console.log(samer.get(2));
console.log(samer.get(null, '7up'));
console.log(samer.get(1, 'pepsi'));

Обратите внимание, что это будет работать на любых объектах с любыми ключами.

Answer 5

Другое решение, надеюсь, это поможет

    const items = [
   {
     id: 1,
     type: 'PEPSI',
   },
  {
     id: 1,
     type: 'PEPSI',
   },
  {
     id: 1,
     type: '7UP',
   },
  {
     id: 1,
     type: 'FANTA',
   },
  {
     id: 2,
     type: 'FANTA',
   },
  {
     id: 2,
     type: '7UP',
   },
  {
     id: 2,
     type: '7UP',
   }
];

function getItems(items, id){
  
      return Object.values(items.reduce((arr,curr) => {
        if(curr.id == id){
           if(arr[curr.type]){
              arr[curr.type] = {
                 ...arr[curr.type],
                 quantity: arr[curr.type].quantity + 1,
              }
           } else {
              arr[curr.type] = {
                 quantity: 1,
                 type: curr.type
           }
        }
      } else {
        arr[curr.type] = {
            quantity: 1,
            type: curr.type
        }
      }
      return arr;
     }, {}))
}
    const arr = getItems(items, 1);
    console.log(arr);

Answer 6

Вы можете использовать этот код:

const items = [
   {
     id: 1,
     type: 'PEPSI',
   },
  {
     id: 1,
     type: 'PEPSI',
   },
  {
     id: 1,
     type: '7UP',
   },
  {
     id: 1,
     type: 'FANTA',
   },
  {
     id: 2,
     type: 'FANTA',
   },
  {
     id: 2,
     type: '7UP',
   },
  {
     id: 2,
     type: '7UP',
   }
];

const getItems = (data) => {
    return data.reduce((a,b) => {
        const item = a.find(i => i.type === b.type);
        if(item){
            item.quantity = item.quantity + 1;
        }
        else {
            a.push({
                quantity: 0,
                type: b.type
            });
        }
        return a;
    }, []);
};
console.log(getItems(items));

const getItemsWithId = (data, id) => {
return data.reduce((a,b) => {
    if(b.id === id) {
        const item = a.find(i => i.type === b.type);
        if(item){
            item.quantity = item.quantity + 1;
        }
        else {
            a.push({
                quantity: 0,
                type: b.type
            });
        }   
    }
    return a;
}, []);
};

console.log(getItemsWithId(items, 1));