Comment supprimer tous les doublons d'un tableau d'objets ?

Question

J'ai un objet qui contient un tableau d'objets.

obj = {};

obj.arr = new Array();

obj.arr.push({place:"here",name:"stuff"});
obj.arr.push({place:"there",name:"morestuff"});
obj.arr.push({place:"there",name:"morestuff"});

Je me demande quelle est la meilleure méthode pour supprimer les objets en double d'un tableau. Par exemple, obj.arr deviendrait...

{place:"here",name:"stuff"},
{place:"there",name:"morestuff"}

Answer 1

Voici une solution pour ES6 où vous voulez seulement garder le dernier élément. Cette solution est fonctionnelle et conforme au style Airbnb.

const things = {
  thing: [
    { place: 'here', name: 'stuff' },
    { place: 'there', name: 'morestuff1' },
    { place: 'there', name: 'morestuff2' }, 
  ],
};

const removeDuplicates = (array, key) => {
  return array.reduce((arr, item) => {
    const removed = arr.filter(i => i[key] !== item[key]);
    return [...removed, item];
  }, []);
};

console.log(removeDuplicates(things.thing, 'place'));
// > [{ place: 'here', name: 'stuff' }, { place: 'there', name: 'morestuff2' }]

Answer 2

Je sais qu'il y a déjà une tonne de réponses à cette question, mais soyez indulgent avec moi...

Certains des objets de votre tableau peuvent avoir des propriétés supplémentaires qui ne vous intéressent pas, ou vous voulez simplement trouver les objets uniques. en ne considérant qu'un sous-ensemble des propriétés .

Considérons le tableau ci-dessous. Supposons que l'on veuille trouver les objets uniques de ce tableau en tenant compte uniquement des éléments suivants propOne y propTwo et ignore toute autre propriété qui pourrait s'y trouver.

Le résultat attendu ne devrait inclure que le premier et le dernier objet. Voici donc le code :

const array = [{
    propOne: 'a',
    propTwo: 'b',
    propThree: 'I have no part in this...'
},
{
    propOne: 'a',
    propTwo: 'b',
    someOtherProperty: 'no one cares about this...'
},
{
    propOne: 'x',
    propTwo: 'y',
    yetAnotherJunk: 'I am valueless really',
    noOneHasThis: 'I have something no one has'
}];

const uniques = [...new Set(
    array.map(x => JSON.stringify(((o) => ({
        propOne: o.propOne,
        propTwo: o.propTwo
    }))(x))))
].map(JSON.parse);

console.log(uniques);

Answer 3

Une autre option serait de créer une fonction indexOf personnalisée, qui compare les valeurs de la propriété choisie pour chaque objet et de l'intégrer dans une fonction de réduction.

var uniq = redundant_array.reduce(function(a,b){
      function indexOfProperty (a, b){
          for (var i=0;i<a.length;i++){
              if(a[i].property == b.property){
                   return i;
               }
          }
         return -1;
      }

      if (indexOfProperty(a,b) < 0 ) a.push(b);
        return a;
    },[]);

Answer 4

Cette solution a été la plus efficace pour moi, en utilisant la méthode Array.from, et elle est également plus courte et plus facile à lire.

let person = [
{name: "john"}, 
{name: "jane"}, 
{name: "imelda"}, 
{name: "john"},
{name: "jane"}
];

const data = Array.from(new Set(person.map(JSON.stringify))).map(JSON.parse);
console.log(data);

Answer 5

J'ai trouvé ici une solution simple pour supprimer les doublons d'un tableau d'objets en utilisant la méthode reduce. Je filtre les éléments en fonction de la clé de position d'un objet.

const med = [
  {name: 'name1', position: 'left'},
  {name: 'name2', position: 'right'},
  {name: 'name3', position: 'left'},
  {name: 'name4', position: 'right'},
  {name: 'name5', position: 'left'},
  {name: 'name6', position: 'left1'}
]

const arr = [];
med.reduce((acc, curr) => {
  if(acc.indexOf(curr.position) === -1) {
    acc.push(curr.position);
    arr.push(curr);
  }
  return acc;
}, [])

console.log(arr)