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, tout deviendrait ...
{place:"here",name:"stuff"},
{place:"there",name:"morestuff"}
Voyons voir ... un primitif 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]);
Ok, je pense que cela devrait faire l'affaire. Regarde ça, Travis.
MODIFIER
Edité le code pour référencer correctement la propriété place (former id).
Que diriez-vous de la magie es6?
things.thing = things.thing.filter((thing, index, self) =>
index === self.findIndex((t) => (
t.place === thing.place && t.name === thing.name
))
)
Pour les frontaux, cela peut être un peu trop tôt pour être implémenté car beaucoup de navigateurs utilisés ne supportent toujours pas les fonctionnalités es6
Si vous pouvez utiliser des bibliothèques Javascript telles que underscore ou lodash, je vous recommande de consulter la fonction _.uniq dans leurs bibliothèques. De lodash:
_.uniq(array, [isSorted=false], [callback=_.identity], [thisArg])
En gros, vous transmettez le tableau qui ici est un littéral d'objet et 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');
UPDATE: Lodash a maintenant introduit un .uniqBy.
J'ai eu exactement cette même exigence, pour supprimer les objets en double dans un tableau, basé sur les doublons sur un seul champ. J'ai trouvé le code ici: Javascript: Supprimer les doublons du tableau d'objets
Ainsi, dans mon exemple, je supprime tout objet du tableau qui contient 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"}]
Si vous pouvez attendre pour éliminer les doublons après tous les ajouts, l'approche habituelle consiste d'abord à trier le tableau, puis à éliminer les doublons. Le tri évite l’approche N * N consistant à numériser 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, uniq de prototype
Ce message 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;
}
Voici une autre option pour le faire en utilisant les méthodes itératives Array si vous avez besoin de comparer uniquement 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');
Une doublure à l'aide de 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:
new Set(myData.map(JSON.stringify))crée un objet Set en utilisant les éléments stringified myData.- Set object garantira que chaque élément est unique.
- Ensuite, je crée un tableau basé sur les éléments du jeu créé en utilisant Array.from.
- Enfin, j'utilise JSON.parse pour reconvertir un élément stringifié en objet.
MIS &AGRAVE; JOUR
J'ai maintenant lu la question correctement. C'est une manière générique de faire ceci: vous transmettez 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 name et place des deux objets comparés.
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);
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}),{})))Pour en ajouter un de plus à la liste. Utilisation de ES6 et Array.reduce avec Array.find.
Dans cet exemple, filtrer les objets en fonction d'une propriété guid.
let filtered = array.reduce((accumulator, current) => {
if (! accumulator.find(({guid}) => guid === current.guid)) {
accumulator.Push(current);
}
return accumulator;
}, []);
Extension de celle-ci pour permettre la sélection d'une propriété et la compresser dans un liner:
const uniqify = (array, key) => array.reduce((prev, curr) => prev.find(a => a[key] === curr[key]) ? prev : prev.Push(curr) && prev, []);
Pour l'utiliser, transmettez un tableau d'objets et le nom de la clé que vous souhaitez dupliquer en tant que valeur de chaîne:
const result = uniqify(myArrayOfObjects, 'guid')
Dang, les enfants, écrasons cette affaire, 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'}];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)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 l’emballe 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;
},[]);
Vous pouvez aussi utiliser une 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"
}
]
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 et utilisé comme dans l'exemple ci-dessous:
const arr = [
{place: "here", name: "stuff"},
{place: "there", name: "morestuff"},
{place: "a", name: "morestuff"},
{place: "b", name: "morestuff"},
{place: "c", name: "morestuff"},
{place: "here", name: "lol"},
{place: "there", name: "test"}
]
function getUniqueListBy(arr, key) {
return [...new Map(arr.map(item => [item[key], item])).values()]
}
const arr1 = getUniqueListBy(arr, 'place')
console.log(arr1)
const arr2 = getUniqueListBy(arr, 'name')
console.log(arr2)let data = [
{
'name': 'Amir',
'surname': 'Rahnama'
},
{
'name': 'Amir',
'surname': 'Stevens'
}
];
let non_duplicated_data = _.uniqBy(data, 'name');
Voici une solution pour es6 où vous ne voulez garder 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' }]
LE PLUS COURT UN DOUBLE
Trouver des identifiants uniques dans un tableau.
arr.filter((v,i,a)=>a.findIndex((t)=>(t.id === v.id))===i)
Unique par plusieurs propriétés (id et nom)
arr.filter((v,i,a)=>a.findIndex((t)=>(t.id === v.id && t.name===v.name))===i)
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));
}
removeDuplicates () prend un tableau d'objets et retourne un nouveau tableau sans objets 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'}
];
Premièrement, 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 passent 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-circuit de &&. Si le côté gauche de && est évalué à true, la valeur située à droite de && est alors renvoyée. Si le côté gauche est faux, il retourne ce qui se trouve du côté gauche de &&.
Pour chaque objet (obj), nous recherchons dans uniq une propriété nommée la valeur de obj.id (dans ce cas, lors de la première itération, la propriété '1' serait vérifiée.) Nous voulons l'inverse de ce qu'il retourne (soit true ou faux) c'est pourquoi nous utilisons le! dans! uniq [obj.id]. Si uniq a déjà la propriété id, il renvoie true, auquel cas False (!) Indique à 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 alors évalué à true (!) Et renvoie tout à droite du &&, ou (uniq [obj.id] = true). Il s’agit d’une valeur de vérité, indiquant à la méthode de filtrage d’ajouter cet obj au tableau renvoyé, ainsi qu’à la propriété {1: true} à uniq. Cela garantit que toute autre instance obj avec le même identifiant ne sera pas ajoutée à nouveau.
Continuer à explorer les moyens ES6 de supprimer les doublons d'un tableau d'objets: la définition de l'argument thisArg de Array.prototype.filter à new Set constitue une alternative intéressante:
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, cela ne fonctionnera pas avec les fonctions de flèche () =>, car this est lié à leur portée lexicale.
Si vous ne souhaitez pas spécifier une liste de propriétés:
function removeDuplicates(myArr) {
var props = Object.keys(myArr[0])
return myArr.filter((item, index, self) =>
index === self.findIndex((t) => (
props.every(prop => {
return t[prop] === item[prop]
})
))
)
}
OBS! Non compatible avec IE11.
Avez-vous entendu parler de la bibliothèque Lodash? Je vous recommande cet utilitaire, lorsque vous ne souhaitez pas appliquer votre logique au code, ni utiliser du code déjà présent, optimisé et fiable.
Pensez à faire 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 voulez garder 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 ressemble à _.uniq (qui retourne une version non dupliquée d’un tableau dans lequel seule la première occurrence de chaque élément est conservée), sauf qu’elle accepte iteratee qui est appelé pour chaque élément du tableau le critère selon lequel l'unicité est calculée.
Ainsi, par exemple, si vous voulez renvoyer un tableau ayant un attribut unique "place"
_.uniqBy (choses.que chose, 'lieu')
De même, si vous voulez un attribut unique en tant que "nom"
_.uniqBy (choses.tout, 'nom')
J'espère que cela t'aides.
À votre santé!
Si cela ne vous dérange pas que votre tableau unique soit trié ensuite, 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, il vous suffit de comparer l'élément actuel avec l'élément précédent du tableau. Trier une fois avant le filtrage (O(n*log(n))) est moins coûteux que de rechercher un doublon dans le tableau entier pour chaque élément du tableau (O(n²)).
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:-
- En faisant
.map()dans la liste de données et en convertissant chaque objet individuel en un tableau de paires[key, value](longueur = 2), le premier élément (clé) serait la versionstringifiedde l'objet et le second (valeur) serait unobject. - L'ajout de la liste de tableaux créée ci-dessus à
new Map()aurait la clé sous la forme d'un objetstringifiedet tout ajout de clé entraînerait le remplacement de la clé existante. - Utiliser
.values()donnerait à MapIterator toutes les valeurs d'une carte (objdans notre cas) - Enfin, l'opérateur
spread ...donne le nouveau tableau avec les valeurs de l'étape ci-dessus.
Une autre façon serait d'utiliser la fonction de réduction et d'avoir un nouveau tableau pour être l'accumulateur. S'il y a déjà une thing avec le même nom dans le tableau accumulateur, alors ne l'ajoutez pas là.
let list = things.thing;
list = list.reduce((accumulator, thing) => {
if (!accumulator.filter((duplicate) => thing.name === duplicate.name)[0]) {
accumulator.Push(thing);
}
return accumulator;
}, []);
thing.things = list;
J'ajoute cette réponse, car je ne trouvais pas de solution lisible agréable et lisible (j'utilise babel pour gérer les fonctions fléchées) compatible avec Internet Explorer 11. Le problème est que IE11 n'a pas Map.values() ou Set.values() sans polyfill. Pour la même raison, j’ai utilisé filter()[0] pour obtenir le premier élément au lieu de find().
var testArray= ['a','b','c','d','e','b','c','d'];
function removeDuplicatesFromArray(arr){
var obj={};
var uniqueArr=[];
for(var i=0;i<arr.length;i++){
if(!obj.hasOwnProperty(arr[i])){
obj[arr[i]] = arr[i];
uniqueArr.Push(arr[i]);
}
}
return uniqueArr;
}
var newArr = removeDuplicatesFromArray(testArray);
console.log(newArr);
Output:- [ 'a', 'b', 'c', 'd', 'e' ]
Si vous voulez strictement supprimer les doublons basés sur une propriété, vous pouvez reduce le tableau dans et un objet basé sur la propriété place, puisque l'objet ne peut avoir que des clés uniques, vous pouvez alors obtenir le values pour revenir à un tableau:
const unique = Object.values(things.thing.reduce((o, t) => ({ ...o, [t.place]: t }), {}))
Si vous devez fréquemment supprimer les objets en double des tableaux basés sur des champs particuliers, il peut être intéressant de créer une fonction distinct(array, predicate) que vous pouvez importer n'importe où dans votre projet. Cela ressemblerait à
const things = [{place:"here",name:"stuff"}, ...];
const distinctThings = distinct(things, thing => thing.place);
La fonction distincte peut utiliser n’importe laquelle des implémentations données dans les nombreuses bonnes réponses ci-dessus. Le plus simple utilise findIndex:
const distinct = (items, predicate) => items.filter((uniqueItem, index) =>
items.findIndex(item =>
predicate(item) === predicate(uniqueItem)) === index);
Vous pouvez utiliser Object.values () combiné avec Array.prototype.reduce () :
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 result = Object.values(things.thing.reduce((a, c) => (a[`${c.place}${c.name}`] = c, a), {}));
console.log(result);.as-console-wrapper { max-height: 100% !important; top: 0; }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, retourne false sinon retourne true. En fonction de ce résultat, insérez l'objet dans un nouveau tableau obj Le code ci-dessus est affiché [{"item_id":1},{"item_id":2}]
Générique pour tout tableau d'objets:
/**
* Remove duplicated values without losing information
*/
const removeValues = (items, key) => {
let tmp = {};
items.forEach(item => {
tmp[item[key]] = (!tmp[item[key]]) ? item : Object.assign(tmp[item[key]], item);
});
items = [];
Object.keys(tmp).forEach(key => items.Push(tmp[key]));
return items;
}
J'espère que cela pourrait aider n'importe qui.
Solution simple avec ES6 'méthodes d'assistance de tableau' 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));
Vous pouvez convertir les objets du tableau en chaînes afin de les comparer, ajouter les chaînes à un ensemble afin que les doublons comparables soient automatiquement supprimés, puis reconvertir chacune des chaînes en objets.
Ce n'est peut-être pas aussi performant que d'autres réponses, mais c'est lisible.
const things = {};
things.thing = [];
things.thing.Push({place:"here",name:"stuff"});
things.thing.Push({place:"there",name:"morestuff"});
things.thing.Push({place:"there",name:"morestuff"});
const uniqueArray = (arr) => {
const stringifiedArray = arr.map((item) => JSON.stringify(item));
const set = new Set(stringifiedArray);
return Array.from(set).map((item) => JSON.parse(item));
}
const uniqueThings = uniqueArray(things.thing);
console.log(uniqueThings);
voici ma solution, il recherche les doublons sur la base de object.prop et quand il trouve un objet en double, il le replaces its value dans array1 with array2 value
function mergeSecondArrayIntoFirstArrayByProperty(array1, array2) {
for (var i = 0; i < array2.length; i++) {
var found = false;
for (var j = 0; j < array1.length; j++) {
if (array2[i].prop === array1[j].prop) { // if item exist in array1
array1[j] = array2[i]; // replace it in array1 with array2 value
found = true;
}
}
if (!found) // if item in array2 not found in array1, add it to array1
array1.Push(array2[i]);
}
return array1;
}
function filterDuplicateQueries(queries){
let uniqueQueries = [];
queries.forEach((l, i)=>{
let alreadyExist = false;
if(uniqueQueries.length>0){
uniqueQueries.forEach((k, j)=>{
if(k.query == l.query){
alreadyExist = true;
}
});
}
if(!alreadyExist){
uniqueQueries.Push(l)
}
});
- Cette solution est générique pour tout type d'objet et vérifie chaque
(key, value)de laObjectdu tableau. - Utilisation d'un objet temporaire en tant que table de hachage pour voir si l'intégralité de la
Objecta déjà été présente en tant que clé. - Si la représentation sous forme de chaîne de
Objectest trouvée, cet élément est supprimé du tableau.
var arrOfDup = [{'id':123, 'name':'name', 'desc':'some desc'},
{'id':125, 'name':'another name', 'desc':'another desc'},
{'id':123, 'name':'name', 'desc':'some desc'},
{'id':125, 'name':'another name', 'desc':'another desc'},
{'id':125, 'name':'another name', 'desc':'another desc'}];
function removeDupes(dupeArray){
let temp = {};
let tempArray = JSON.parse(JSON.stringify(dupeArray));
dupeArray.forEach((item, pos) => {
if(temp[JSON.stringify(item)]){
tempArray.pop();
}else{
temp[JSON.stringify(item)] = item;
}
});
return tempArray;
}
arrOfDup = removeDupes(arrOfDup);
arrOfDup.forEach((item, pos) => {
console.log(`item in array at position ${pos} is ${JSON.stringify(item)}`);
});const uniqueElements = (arr, fn) => arr.reduce((acc, v) => {
if (!acc.some(x => fn(v, x))) { acc.Push(v); }
return acc;
}, []);
const stuff = [
{place:"here",name:"stuff"},
{place:"there",name:"morestuff"},
{place:"there",name:"morestuff"},
];
const unique = uniqueElements(stuff, (a,b) => a.place === b.place && a.name === b.name );
//console.log( unique );
[{
"place": "here",
"name": "stuff"
},
{
"place": "there",
"name": "morestuff"
}]
es6 magie en une ligne ... lisible!
// 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]);
Voici une solution utilisant la nouvelle fonction de filtrage de JavaScript qui est assez simple. Disons que vous avez un tableau comme celui-ci.
var duplicatesArray = ['AKASH','AKASH','NAVIN','HARISH','NAVIN','HARISH','AKASH','MANJULIKA','AKASH','TAPASWENI','MANJULIKA','HARISH','TAPASWENI','AKASH','MANISH','HARISH','TAPASWENI','MANJULIKA','MANISH'];
La fonction de filtrage vous permettra de créer un nouveau tableau en utilisant une fonction de rappel une fois pour chaque élément du tableau. Ainsi, vous pouvez configurer le tableau unique comme ceci.
var uniqueArray = duplicatesArray.filter(function(elem, pos) {return duplicatesArray.indexOf(elem) == pos;});
Dans ce scénario, votre tableau unique passera en revue toutes les valeurs du tableau en double. La variable elem représente la valeur de l'élément dans le tableau (mike, james, james, alex), la position correspond à sa position indexée 0 dans le tableau (0,1,2,3 ...) et le duplicatesArray. indexOf (elem) valeur n'est que l'index de la première occurrence de cet élément dans le tableau d'origine. Donc, parce que l'élément 'james' est dupliqué, lorsque nous parcourons tous les éléments de duplicatesArray et que nous les transmettons à uniqueArray, la première fois que nous frappons james, notre valeur "pos" est 1 et notre indexOf (elem) vaut 1 également, alors James est poussé vers l'unique Tableau. La deuxième fois que nous frappons James, notre valeur "pos" est 2 et notre indexOf (elem) est toujours 1 (car il ne trouve que la première instance d'un élément de tableau), le doublon n'est donc pas poussé. Par conséquent, notre unique tableau ne contient que des valeurs uniques.
Voici la démonstration de la fonction ci-dessus. Cliquez ici pour l'exemple de fonction ci-dessus
Voici une autre technique pour rechercher le nombre de doublons et le supprimer facilement de votre objet de données. "dupsCount" est le nombre de fichiers en double. triez d'abord vos données puis supprimez-les. il vous donnera la duplication la plus rapide supprimer.
dataArray.sort(function (a, b) {
var textA = a.name.toUpperCase();
var textB = b.name.toUpperCase();
return (textA < textB) ? -1 : (textA > textB) ? 1 : 0;
});
for (var i = 0; i < dataArray.length - 1; ) {
if (dataArray[i].name == dataArray[i + 1].name) {
dupsCount++;
dataArray.splice(i, 1);
} else {
i++;
}
}
Et ça:
function dedupe(arr, compFn){
let res = [];
if (!compFn) compFn = (a, b) => { return a === b };
arr.map(a => {if(!res.find(b => compFn(a, b))) res.Push(a)});
return res;
}
C'est un moyen simple de supprimer la duplicité d'un tableau d'objets.
Je travaille beaucoup avec des données, ce qui 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"
}]
Cela supprimera l'objet en double sans passer aucune clé.
uniqueArray = a => [...new Set(a.map(o => JSON.stringify(o)))].map(s => JSON.parse(s));
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
var unique = uniqueArray(objects);
console.log('Original Object',objects);
console.log('Unique',unique);uniqueArray = a => [...new Set(a.map(o => JSON.stringify(o)))].map(s => JSON.parse(s));
var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
var unique = uniqueArray(objects);
console.log(objects);
console.log(unique);
Si vous avez besoin d'un tableau unique basé sur plusieurs propriétés dans l'objet, vous pouvez le faire avec map et en combinant les propriétés de l'objet.
var hash = array.map(function(element){
var string = ''
for (var key in element){
string += element[key]
}
return string
})
array = array.filter(function(element, index){
var string = ''
for (var key in element){
string += element[key]
}
return hash.indexOf(string) == index
})
Faites quelque chose de simple. La fantaisie est bonne mais le code illisible est inutile. Prendre plaisir :-)
var a = [
{
executiveId: 6873702,
largePhotoCircle: null,
name: "John A. Cuomo",
photoURL: null,
primaryCompany: "VSE CORP",
primaryTitle: "Chief Executive Officer, President and Director"
},
{
executiveId: 6873702,
largePhotoCircle: null,
name: "John A. Cuomo",
photoURL: null,
primaryCompany: "VSE CORP",
primaryTitle: "Chief Executive Officer, President and Director"
},
{
executiveId: 6873703,
largePhotoCircle: null,
name: "John A. Cuomo",
photoURL: null,
primaryCompany: "VSE CORP",
primaryTitle: "Chief Executive Officer, President and Director",
}
];
function filterDuplicate(myArr, prop) {
// Format - (1)
// return myArr.filter((obj, pos, arr) => {
// return arr.map(mapObj => mapObj[prop]).indexOf(obj[prop]) === pos;
// });
// Format - (2)
var res = {};
var resArr = [];
for (var elem of myArr) {
res[elem.executiveId] = elem;
}
for (let [index, elem] of Object.entries(res)) {
resArr.Push(elem);
}
return resArr;
}
let finalRes = filterDuplicate(a,"executiveId");
console.log("finalResults : ",finalRes);