Supprimer les doublons d'un tableau d'objets en JavaScript

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

things = new Object();

things.thing = new Array();

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

Je me demande quelle est la meilleure méthode pour supprimer les objets en double d'un tableau. Ainsi, par exemple, les choses deviendraient ...

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

Une méthode primitive serait:

var obj = {};

for ( var i=0, len=things.thing.length; i < len; i++ )
    obj[things.thing[i]['place']] = things.thing[i];

things.thing = new Array();
for ( var key in obj )
    things.thing.push(obj[key]);

Et la es6magie?

things.thing = things.thing.filter((thing, index, self) =>
  index === self.findIndex((t) => (
    t.place === thing.place && t.name === thing.name
  ))
)

URL de référence

Une solution plus générique serait:

const uniqueArray = things.thing.filter((thing, index) => {
  const _thing = JSON.stringify(thing);
  return index === things.thing.findIndex(obj => {
    return JSON.stringify(obj) === _thing;
  });
});

Exemple de Stackblitz

Si vous pouvez utiliser des bibliothèques Javascript telles que le soulignement ou le lodash, je vous recommande de jeter un œil à la _.uniqfonction dans leurs bibliothèques. De lodash:

_.uniq(array, [isSorted=false], [callback=_.identity], [thisArg])

Fondamentalement, vous passez dans le tableau qui est ici un littéral objet et vous passez l'attribut avec lequel vous souhaitez supprimer les doublons dans le tableau de données d'origine, comme ceci:

var data = [{'name': 'Amir', 'surname': 'Rahnama'}, {'name': 'Amir', 'surname': 'Stevens'}];
var non_duplidated_data = _.uniq(data, 'name'); 

MISE À JOUR : Lodash a maintenant introduit un .uniqByégalement.

J'avais exactement la même exigence, pour supprimer les objets en double dans un tableau, basé sur des doublons sur un seul champ. J'ai trouvé le code ici: Javascript: Supprimer les doublons du tableau d'objets

Donc, dans mon exemple, je supprime tout objet du tableau qui a une valeur de chaîne licenseNum en double.

var arrayWithDuplicates = [
    {"type":"LICENSE", "licenseNum": "12345", state:"NV"},
    {"type":"LICENSE", "licenseNum": "A7846", state:"CA"},
    {"type":"LICENSE", "licenseNum": "12345", state:"OR"},
    {"type":"LICENSE", "licenseNum": "10849", state:"CA"},
    {"type":"LICENSE", "licenseNum": "B7037", state:"WA"},
    {"type":"LICENSE", "licenseNum": "12345", state:"NM"}
];

function removeDuplicates(originalArray, prop) {
     var newArray = [];
     var lookupObject  = {};

     for(var i in originalArray) {
        lookupObject[originalArray[i][prop]] = originalArray[i];
     }

     for(i in lookupObject) {
         newArray.push(lookupObject[i]);
     }
      return newArray;
 }

var uniqueArray = removeDuplicates(arrayWithDuplicates, "licenseNum");
console.log("uniqueArray is: " + JSON.stringify(uniqueArray));

Les resultats:

uniqueArray est:

[{"type":"LICENSE","licenseNum":"10849","state":"CA"},
{"type":"LICENSE","licenseNum":"12345","state":"NM"},
{"type":"LICENSE","licenseNum":"A7846","state":"CA"},
{"type":"LICENSE","licenseNum":"B7037","state":"WA"}]

Doublures les plus courtes pour ES6 +

Trouvez des pièces uniques iddans un tableau.

arr.filter((v,i,a)=>a.findIndex(t=>(t.id === v.id))===i)

Unique par plusieurs propriétés ( placeet name)

arr.filter((v,i,a)=>a.findIndex(t=>(t.place === v.place && t.name===v.name))===i)

Unique par toutes les propriétés (ce sera lent pour les grands tableaux)

arr.filter((v,i,a)=>a.findIndex(t=>(JSON.stringify(t) === JSON.stringify(v)))===i)

Gardez la dernière occurrence.

arr.slice().reverse().filter((v,i,a)=>a.findIndex(t=>(t.id === v.id))===i).reverse()

Un liner avec Set

var things = new Object();

things.thing = new Array();

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

// assign things.thing to myData for brevity
var myData = things.thing;

things.thing = Array.from(new Set(myData.map(JSON.stringify))).map(JSON.parse);

console.log(things.thing)

Explication:

1. new Set(myData.map(JSON.stringify))crée un objet Set à l'aide des éléments myData stringifiés.
2. Définir l'objet garantira que chaque élément est unique.
3. Ensuite, je crée un tableau basé sur les éléments de l'ensemble créé en utilisant Array.from.
4. Enfin, j'utilise JSON.parse pour reconvertir l'élément stringifié en objet.

En utilisant ES6 + sur une seule ligne, vous pouvez obtenir une liste unique d'objets par clé:

const unique = [...new Map(arr.map(item => [item[key], item])).values()]

Il peut être mis dans une fonction:

function getUniqueListBy(arr, key) {
    return [...new Map(arr.map(item => [item[key], item])).values()]
}

Voici un exemple de travail:

const arr = [
    {place: "here",  name: "x", other: "other stuff1" },
    {place: "there", name: "x", other: "other stuff2" },
    {place: "here",  name: "y", other: "other stuff4" },
    {place: "here",  name: "z", other: "other stuff5" }
]

function getUniqueListBy(arr, key) {
    return [...new Map(arr.map(item => [item[key], item])).values()]
}

const arr1 = getUniqueListBy(arr, 'place')

console.log("Unique by place")
console.log(JSON.stringify(arr1))

console.log("\nUnique by name")
const arr2 = getUniqueListBy(arr, 'name')

console.log(JSON.stringify(arr2))

Comment ça marche

Tout d'abord, le tableau est remappé de manière à pouvoir être utilisé comme entrée pour une carte.

arr.map (item => [item [clé], item]);

ce qui signifie que chaque élément du tableau sera transformé en un autre tableau avec 2 éléments; la touche sélectionnée en tant que premier élément et l'ensemble de l' article initial en tant que deuxième élément, ce qu'on appelle une entrée (ex. entrées de tableau , les entrées de la carte ). Et voici le document officiel avec un exemple montrant comment ajouter des entrées de tableau dans le constructeur Map.

Exemple lorsque la clé est en place :

[["here", {place: "here",  name: "x", other: "other stuff1" }], ...]

Deuxièmement, nous passons ce tableau modifié au constructeur Map et voici la magie qui se produit. La carte éliminera les valeurs des clés en double, en ne conservant que la dernière valeur insérée de la même clé. Remarque : la carte conserve l'ordre d'insertion. ( vérifier la différence entre la carte et l'objet )

nouvelle carte (tableau d'entrée juste mappé ci-dessus)

Troisièmement, nous utilisons les valeurs de la carte pour récupérer les éléments d'origine, mais cette fois sans doublons.

nouvelle carte (mappedArr) .values ​​()

Et la dernière consiste à ajouter ces valeurs dans un nouveau tableau afin qu'il puisse ressembler à la structure initiale et retourner cela:

return [... new Map (mappedArr) .values ​​()]

Voici une autre option pour le faire en utilisant des méthodes d'itération de tableau si vous avez besoin d'une comparaison uniquement 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');

un paquebot est ici

let arr = [
  {id:1,name:"sravan ganji"},
  {id:2,name:"anu"},
  {id:4,name:"mammu"},
  {id:3,name:"sanju"},
  {id:3,name:"ram"},
];

console.log(Object.values(arr.reduce((acc,cur)=>Object.assign(acc,{[cur.id]:cur}),{})))

Si vous pouvez attendre pour éliminer les doublons après tous les ajouts, l'approche typique consiste d'abord à trier le tableau, puis à éliminer les doublons. Le tri évite l'approche N * N consistant à analyser le tableau pour chaque élément lorsque vous les parcourez.

La fonction "éliminer les doublons" est généralement appelée unique ou uniq . Certaines implémentations existantes peuvent combiner les deux étapes, par exemple, l'uniq du prototype

Ce post a quelques idées à essayer (et certaines à éviter :-)) si votre bibliothèque n'en a pas déjà ! Personnellement, je trouve celui-ci 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;
    }

La manière la plus simple est d'utiliser filter:

var uniq = {}
var arr  = [{"id":"1"},{"id":"1"},{"id":"2"}]
var arrFiltered = arr.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true));
console.log('arrFiltered', arrFiltered)

C'est une façon générique de le faire: vous passez une fonction qui teste si deux éléments d'un tableau sont considérés comme égaux. Dans ce cas, il compare les valeurs des propriétés nameet placedes deux objets à comparer.

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

Pour en ajouter un de plus à la liste. Utilisation d'ES6 et Array.reduceavec Array.find.
Dans cet exemple, filtrer les objets en fonction d'une guidpropriété.

let filtered = array.reduce((accumulator, current) => {
  if (! accumulator.find(({guid}) => guid === current.guid)) {
    accumulator.push(current);
  }
  return accumulator;
}, []);

Extension de celui-ci pour permettre la sélection d'une propriété et la compresser en une seule doublure:

const uniqify = (array, key) => array.reduce((prev, curr) => prev.find(a => a[key] === curr[key]) ? prev : prev.push(curr) && prev, []);

Pour l'utiliser, passez un tableau d'objets et le nom de la clé que vous souhaitez déduper comme valeur de chaîne:

const result = uniqify(myArrayOfObjects, 'guid')

Vous pouvez également utiliser Map:

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

Échantillon complet:

const things = new Object();

things.thing = new Array();

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

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

console.log(JSON.stringify(dedupThings, null, 4));

Résultat:

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

Dang, les enfants, écrasons cette chose, pourquoi pas nous?

let uniqIds = {}, source = [{id:'a'},{id:'b'},{id:'c'},{id:'b'},{id:'a'},{id:'d'}];
let filtered = source.filter(obj => !uniqIds[obj.id] && (uniqIds[obj.id] = true));
console.log(filtered);
// EXPECTED: [{id:'a'},{id:'b'},{id:'c'},{id:'d'}];

Une solution TypeScript

Cela supprimera les objets en double et préservera également les types des objets.

function removeDuplicateObjects(array: any[]) {
  return [...new Set(array.map(s => JSON.stringify(s)))]
    .map(s => JSON.parse(s));
}

Considérant lodash.uniqWith

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];

_.uniqWith(objects, _.isEqual);
// => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]

Une autre option serait de créer une fonction indexOf personnalisée, qui compare les valeurs de la propriété que vous avez choisie pour chaque objet et envelopper cela 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;
    },[]);

let myData = [{place:"here",name:"stuff"}, 
 {place:"there",name:"morestuff"},
 {place:"there",name:"morestuff"}];


let q = [...new Map(myData.map(obj => [JSON.stringify(obj), obj])).values()];

console.log(q)

One-liner utilisant ES6 et new Map().

// assign things.thing to myData
let myData = things.thing;

[...new Map(myData.map(obj => [JSON.stringify(obj), obj])).values()];

Détails:-

1. En faisant .map()sur la liste de données et en convertissant chaque objet individuel en un [key, value]tableau de paires (longueur = 2), le premier élément (clé) serait lestringified version de l'objet et le second (valeur) serait un objectlui-même.
2. L'ajout de la liste de tableaux créée ci-dessus new Map()aurait la clé commestringified objet et tout ajout de clé entraînerait la substitution de la clé déjà existante.
3. L'utilisation .values()donnerait MapIterator avec toutes les valeurs d'une carte (obj dans notre cas)
4. Enfin, spread ...opérateur pour donner un nouveau tableau avec les valeurs de l'étape ci-dessus.

Voici une solution pour es6 où vous ne souhaitez conserver que 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' }]

removeDuplicates () prend un tableau d'objets et retourne un nouveau tableau sans aucun objet en double (basé sur la propriété id).

const allTests = [
  {name: 'Test1', id: '1'}, 
  {name: 'Test3', id: '3'},
  {name: 'Test2', id: '2'},
  {name: 'Test2', id: '2'},
  {name: 'Test3', id: '3'}
];

function removeDuplicates(array) {
  let uniq = {};
  return array.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true))
}

removeDuplicates(allTests);

Résultat attendu:

[
  {name: 'Test1', id: '1'}, 
  {name: 'Test3', id: '3'},
  {name: 'Test2', id: '2'}
];

Tout d'abord, nous définissons la valeur de la variable uniq sur un objet vide.

Ensuite, nous filtrons à travers le tableau d'objets. Le filtre crée un nouveau tableau avec tous les éléments qui réussissent le test implémenté par la fonction fournie.

return array.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true));

Ci-dessus, nous utilisons la fonctionnalité de court-circuitage de &&. Si le côté gauche du && prend la valeur true, il renvoie la valeur à droite du &&. Si le côté gauche est faux, il renvoie ce qui se trouve sur le côté gauche du &&.

Pour chaque objet (obj), nous vérifions uniq pour une propriété nommée la valeur de obj.id (dans ce cas, à la première itération, il vérifierait la propriété «1».) Nous voulons le contraire de ce qu'il retourne (soit vrai ou faux) c'est pourquoi nous utilisons le! dans! uniq [obj.id]. Si uniq a déjà la propriété id, elle renvoie true qui est évaluée à false (!) En disant à la fonction de filtre de ne PAS ajouter cet obj. Cependant, s'il ne trouve pas la propriété obj.id, il renvoie false qui est ensuite évalué à true (!) Et renvoie tout à droite du &&, ou (uniq [obj.id] = true). Il s'agit d'une valeur véridique, indiquant à la méthode de filtrage d'ajouter cet obj au tableau renvoyé, et elle ajoute également la propriété {1: true} à uniq. Cela garantit qu'aucune autre instance obj avec le même identifiant ne sera ajoutée à nouveau.

let data = [
  {
    'name': 'Amir',
    'surname': 'Rahnama'
  }, 
  {
    'name': 'Amir',
    'surname': 'Stevens'
  }
];
let non_duplicated_data = _.uniqBy(data, 'name');

Je crois qu'une combinaison de reduceavec JSON.stringifypour comparer parfaitement les objets et ajouter sélectivement ceux qui ne sont pas déjà dans l'accumulateur est une manière élégante.

Gardez à l'esprit que cela JSON.stringifypourrait devenir un problème de performances dans les cas extrêmes où le tableau a de nombreux objets et ils sont complexes, MAIS pour la majorité du temps , c'est le chemin le plus court pour aller à mon humble avis.

var collection= [{a:1},{a:2},{a:1},{a:3}]

var filtered = collection.reduce((filtered, item) => {
  if( !filtered.some(filteredItem => JSON.stringify(filteredItem) == JSON.stringify(item)) )
    filtered.push(item)
  return filtered
}, [])

console.log(filtered)

Une autre façon d'écrire la même chose (mais moins efficace):

collection.reduce((filtered, item) => 
  filtered.some(filteredItem => 
    JSON.stringify(filteredItem ) == JSON.stringify(item)) 
      ? filtered
      : [...filtered, item]
, [])

Continuer à explorer les moyens d'ES6 de supprimer les doublons du tableau d'objets: définir l' thisArgargument de Array.prototype.filterà new Setfournit une alternative décente:

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

const filtered = things.filter(function({place, name}) {

  const key =`${place}${name}`;

  return !this.has(key) && this.add(key);

}, new Set);

console.log(filtered);

Cependant, il ne fonctionnera pas avec les fonctions fléchées () =>, car il thisest lié à leur portée lexicale.

es6 magic in one line ... lisible à ça!

// returns the union of two arrays where duplicate objects with the same 'prop' are removed
const removeDuplicatesWith = (a, b, prop) => a.filter(x => !b.find(y => x[prop] === y[prop]);

Solution simple avec les méthodes d'assistance de tableau ES6 «réduire» et «trouver»

Fonctionne efficacement et parfaitement bien!

"use strict";

var things = new Object();
things.thing = new Array();
things.thing.push({
    place: "here",
    name: "stuff"
});
things.thing.push({
    place: "there",
    name: "morestuff"
});
things.thing.push({
    place: "there",
    name: "morestuff"
});

// the logic is here

function removeDup(something) {
    return something.thing.reduce(function (prev, ele) {
        var found = prev.find(function (fele) {
            return ele.place === fele.place && ele.name === fele.name;
        });
        if (!found) {
            prev.push(ele);
        }
        return prev;
    }, []);
}
console.log(removeDup(things));

Si cela ne vous dérange pas que votre tableau unique soit trié par la suite, ce serait une solution efficace:

things.thing
  .sort(((a, b) => a.place < b.place)
  .filter((current, index, array) =>
    index === 0 || current.place !== array[index - 1].place)

De cette façon, vous n'avez qu'à comparer l'élément actuel avec l'élément précédent dans le tableau. Trier une fois avant filtering ( O(n*log(n))) est moins cher que de rechercher un doublon dans le tableau entier pour chaque élément du tableau ( O(n²)).

C'est un moyen simple de supprimer la duplicité d'un tableau d'objets.

Je travaille beaucoup avec des données et cela m'est utile.

const data = [{name: 'AAA'}, {name: 'AAA'}, {name: 'BBB'}, {name: 'AAA'}];
function removeDuplicity(datas){
    return datas.filter((item, index,arr)=>{
    const c = arr.map(item=> item.name);
    return  index === c.indexOf(item.name)
  })
}

console.log(removeDuplicity(data))

imprimera dans la console:

[[object Object] {
name: "AAA"
}, [object Object] {
name: "BBB"
}]

str =[
{"item_id":1},
{"item_id":2},
{"item_id":2}
]

obj =[]
for (x in str){
    if(check(str[x].item_id)){
        obj.push(str[x])
    }   
}
function check(id){
    flag=0
    for (y in obj){
        if(obj[y].item_id === id){
            flag =1
        }
    }
    if(flag ==0) return true
    else return false

}
console.log(obj)

str est un tableau d'objets. Il existe des objets ayant la même valeur (ici un petit exemple, il y a deux objets ayant le même item_id que 2). check (id) est une fonction qui vérifie si un objet ayant le même item_id existe ou non. s'il existe, retournez false sinon retournez true. Selon ce résultat, poussez l'objet dans un nouveau tableau obj La sortie du code ci-dessus est [{"item_id":1},{"item_id":2}]

Avez-vous entendu parler de la bibliothèque Lodash? Je vous recommande cet utilitaire, lorsque vous ne voulez pas vraiment appliquer votre logique au code, et utiliser du code déjà présent qui est optimisé et fiable.

Pensez à créer un tableau comme celui-ci

things.thing.push({place:"utopia",name:"unicorn"});
things.thing.push({place:"jade_palace",name:"po"});
things.thing.push({place:"jade_palace",name:"tigress"});
things.thing.push({place:"utopia",name:"flying_reindeer"});
things.thing.push({place:"panda_village",name:"po"});

Notez que si vous souhaitez conserver un attribut unique, vous pouvez très bien le faire en utilisant la bibliothèque lodash. Ici, vous pouvez utiliser _.uniqBy

.uniqBy (tableau, [iteratee = .identity])

Cette méthode est similaire à _.uniq (qui renvoie une version sans doublon d'un tableau, dans laquelle seule la première occurrence de chaque élément est conservée), sauf qu'elle accepte l'itérate qui est invoquée pour chaque élément du tableau pour générer le critère par lequel l'unicité est calculée.

Ainsi, par exemple, si vous souhaitez renvoyer un tableau ayant un attribut unique de «place»

_.uniqBy (things.thing, 'place')

De même, si vous voulez un attribut unique comme «nom»

_.uniqBy (things.thing, 'name')

J'espère que cela t'aides.

À votre santé!