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

One liners avec carte ( Haute performance, ne préserve pas l'ordre )

Trouver une solution unique id dans le tableau arr .

const arrUniq = [...new Map(arr.map(v => [v.id, v])).values()]

Si l'ordre est important, consultez la solution avec filtre : Solution avec filtre

---

Unique par de multiples propriétés ( place y name ) dans le tableau arr

const arrUniq = [...new Map(arr.map(v => [JSON.stringify([v.place,v.name]), v])).values()]

Unique par toutes les propriétés du tableau arr

const arrUniq = [...new Map(arr.map(v => [JSON.stringify(v), v])).values()]

Conserver la première occurrence dans le tableau arr

const arrUniq = [...new Map(arr.slice().reverse().map(v => [v.id, v])).values()].reverse()

Answer 2

Voici une autre option pour le faire en utilisant les méthodes itératives de Array si vous avez besoin de comparer seulement par un champ d'un objet :

    function uniq(a, param){
        return a.filter(function(item, pos, array){
            return array.map(function(mapItem){ return mapItem[param]; }).indexOf(item[param]) === pos;
        })
    }

    uniq(things.thing, 'place');

Answer 3

Il s'agit d'une manière générique de procéder : vous passez une fonction qui teste si deux éléments d'un tableau sont considérés comme égaux. Dans ce cas, elle compare les valeurs de la fonction name y place les propriétés des deux objets comparés.

Réponse ES5

function removeDuplicates(arr, equals) {
    var originalArr = arr.slice(0);
    var i, len, val;
    arr.length = 0;

    for (i = 0, len = originalArr.length; i < len; ++i) {
        val = originalArr[i];
        if (!arr.some(function(item) { return equals(item, val); })) {
            arr.push(val);
        }
    }
}

function thingsEqual(thing1, thing2) {
    return thing1.place === thing2.place
        && thing1.name === thing2.name;
}

var things = [
  {place:"here",name:"stuff"},
  {place:"there",name:"morestuff"},
  {place:"there",name:"morestuff"}
];

removeDuplicates(things, thingsEqual);
console.log(things);

Réponse originale ES3

function arrayContains(arr, val, equals) {
    var i = arr.length;
    while (i--) {
        if ( equals(arr[i], val) ) {
            return true;
        }
    }
    return false;
}

function removeDuplicates(arr, equals) {
    var originalArr = arr.slice(0);
    var i, len, j, val;
    arr.length = 0;

    for (i = 0, len = originalArr.length; i < len; ++i) {
        val = originalArr[i];
        if (!arrayContains(arr, val, equals)) {
            arr.push(val);
        }
    }
}

function thingsEqual(thing1, thing2) {
    return thing1.place === thing2.place
        && thing1.name === thing2.name;
}

removeDuplicates(things.thing, thingsEqual);

Answer 4

Si vous pouvez attendre d'éliminer les doublons après tous les ajouts, l'approche typique consiste à trier d'abord le tableau, puis à éliminer les doublons. Le tri permet d'éviter l'approche N * N qui consiste à balayer le tableau pour chaque élément au fur et à mesure que vous le parcourez.

La fonction "éliminer les doublons" est généralement appelée unique o uniq . Certaines mises en œuvre existantes peuvent combiner les deux étapes, par exemple, uniq du prototype

Ce poste si votre bibliothèque n'en a pas déjà un ! Personnellement, je trouve que c'est le plus simple :

    function unique(a){
        a.sort();
        for(var i = 1; i < a.length; ){
            if(a[i-1] == a[i]){
                a.splice(i, 1);
            } else {
                i++;
            }
        }
        return a;
    }  

    // Provide your own comparison
    function unique(a, compareFunc){
        a.sort( compareFunc );
        for(var i = 1; i < a.length; ){
            if( compareFunc(a[i-1], a[i]) === 0){
                a.splice(i, 1);
            } else {
                i++;
            }
        }
        return a;
    }

Answer 5

Je pense que la meilleure approche consiste à utiliser réduire le site y Objet de la carte . Il s'agit d'une solution à ligne unique.

const data = [
  {id: 1, name: 'David'},
  {id: 2, name: 'Mark'},
  {id: 2, name: 'Lora'},
  {id: 4, name: 'Tyler'},
  {id: 4, name: 'Donald'},
  {id: 5, name: 'Adrian'},
  {id: 6, name: 'Michael'}
]

const uniqueData = [...data.reduce((map, obj) => map.set(obj.id, obj), new Map()).values()];

console.log(uniqueData)

/*
  in `map.set(obj.id, obj)`

  'obj.id' is key. (don't worry. we'll get only values using the .values() method)
  'obj' is whole object.
*/