Supprimer les doublons dans un tableau d'objets Javascript

J'ai un tableau d'objets

list = [{x:1,y:2}, {x:3,y:4}, {x:5,y:6}, {x:1,y:2}]

Et je suis à la recherche d'un moyen efficace (si possible O(log(n))) pour supprimer les doublons et, pour finir, avec

list = [{x:1,y:2}, {x:3,y:4}, {x:5,y:6}]

J'ai essayé _.uniq ou même _.contains mais ne pouvais pas trouver une solution satisfaisante.

Merci!

Edit : La question a été identifié comme un double de l'autre. J'ai vu cette question avant de poster, mais il n'a pas répondu à ma question, puisque c'est un tableau d'objet (et non 2-dim tableau, merci Aaron), ou au moins les solutions sur la question n'ont pas de travail dans mon cas.

source d'informationauteur kwn

  1. 10

    Vanille JS version:

    function dedupe(arr) {
  return arr.reduce(function (p, c) {

    //create an identifying id from the object values
    var id = [c.x, c.y].join('|');

    //if the id is not found in the temp array
    //add the object to the output array
    //and add the key to the temp array
    if (p.temp.indexOf(id) === -1) {
      p.out.push(c);
      p.temp.push(id);
    }
    return p;

  //return the deduped array
  }, { temp: [], out: [] }).out;
}

dedupe(list);

    DÉMO

  2. 10

    Essayez d'utiliser les éléments suivants:

    list = list.filter((elem, index, self) => self.findIndex(
    (t) => {return (t.x === elem.x && t.y === elem.y)}) === index)
  3. 3

    Je voudrais utiliser une combinaison de Arrayr.prototype.reduce et Arrayr.prototype.some méthodes avec la propagation de l'opérateur.

    1. Explicite de la solution. Basé sur une connaissance complète de l'objet array contient.

    list = list.reduce((r, i) => 
  !r.some(j => i.x === j.x && i.y === j.y) ? [...r, i] : r
, [])

    Ici, nous avons une stricte limitation des objets comparés structure: {x: N, y: M}.

    2. Solution générique, JSON.stringify(). La comparaison des objets pourrait avoir n'importe quel nombre de propriétés.

    list = list.reduce((r, i) => 
  !r.some(j => JSON.stringify(i) === JSON.stringify(j)) ? [...r, i] : r
, [])

    Cette approche a une limitation sur les propriétés de la commande, de sorte [{x:1, y:2}, {y:2, x:1}] ne sera pas filtré.

    3. Solution générique, Object.keys(). L'ordre n'a pas d'importance.

    list = list.reduce((r, i) => 
  !r.some(j => !Object.keys(i).some(k => i[k] !== j[k])) ? [...r, i] : r
, [])

    Cette approche a une autre limitation: par rapport les objets doivent avoir la même liste de clés.
    Donc [{x:1, y:2}, {x:1}] serait filtré malgré la différence évidente.

    4. Solution générique, Object.keys() + .length. 

    list = list.reduce((r, i) => 
  !r.some(j => Object.keys(i).length === Object.keys(j).length 
    && !Object.keys(i).some(k => i[k] !== j[k])) ? [...r, i] : r
, [])

    Avec la dernière approche objets sont comparés par le nombre de touches, par des touches de lui-même et par les valeurs de la clé.

    J'ai créé un Plunker à jouer avec elle.

  4. 1

    Suivantes:

    var a = [{x:1,y:2}, {x:3,y:4}, {x:5,y:6}, {x:1,y:2}];

var b = _.uniq(a, function(v) { 
    return v.x && v.y;
})

console.log(b);  //[ { x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 } ]