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

Une solution TypeScript

Cela permet de supprimer les objets en double et de préserver les types d'objets.

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

Answer 2

 const things = [
  {place:"here",name:"stuff"},
  {place:"there",name:"morestuff"},
  {place:"there",name:"morestuff"}
];
const filteredArr = things.reduce((thing, current) => {
  const x = thing.find(item => item.place === current.place);
  if (!x) {
    return thing.concat([current]);
  } else {
    return thing;
  }
}, []);
console.log(filteredArr)

Solution via Set Objet | Selon le type de données

const seen = new Set();
 const things = [
  {place:"here",name:"stuff"},
  {place:"there",name:"morestuff"},
  {place:"there",name:"morestuff"}
];

const filteredArr = things.filter(el => {
  const duplicate = seen.has(el.place);
  seen.add(el.place);
  return !duplicate;
});
console.log(filteredArr)

Set Caractéristique de l'objet

Chaque valeur dans l'objet Set doit être unique, l'égalité des valeurs sera vérifiée.

L'objet Set a pour but de stocker des valeurs uniques en fonction du type de données, qu'il s'agisse de valeurs primitives ou de références d'objets. Il possède quatre méthodes d'instance très utiles. add , clear , has & delete .

Caractéristique unique et type de données :..

add méthode

il est pousser les données uniques dans la collection par défaut aussi préserver le type de données ... ce qui signifie qu'il empêche de pousser l'élément en double dans la collection aussi il va vérifier le type de données par défaut ....

has méthode

Il est parfois nécessaire de vérifier l'existence d'un élément de données dans la collection et c'est une méthode pratique pour que la collection puisse vérifier l'identité unique de l'élément et le type de données.

delete méthode

il retirera un élément spécifique de la collection en identifiant le type de données

clear méthode

cela supprimera tous les éléments de la collection d'une variable spécifique et la définira comme un objet vide.

Set L'objet a également Méthodes d'itération & plus de fonctionnalités

Mieux lire d'ici : Set - JavaScript | MDN

Answer 3

removeDuplicates() prend un tableau d'objets et renvoie 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 escompté :

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

Tout d'abord, nous fixons la valeur de la variable uniq à un objet vide.

Ensuite, nous filtrons le tableau d'objets. Filter 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-circuitage de &&. Si le côté gauche du && vaut true, il renvoie la valeur située à droite du &&. Si le côté gauche est faux, il renvoie ce qui se trouve du côté gauche du &&.

Pour chaque objet (obj), nous vérifions à l'uniq 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 l'opposé 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, il renvoie true qui est évalué à false ( !) indiquant à la fonction de filtre de NE PAS ajouter cet obj. Cependant, si elle ne trouve pas la propriété obj.id, elle renvoie false qui est évalué à true ( !) et renvoie tout ce qui se trouve à droite du &&, ou (uniq[obj.id] = true). Il s'agit d'une valeur vraie, qui indique à la méthode de filtrage d'ajouter cet objet au tableau retourné, et qui ajoute également la propriété {1 : true} à uniq. Cela garantit que toute autre instance d'obj avec ce même id ne sera pas ajoutée à nouveau.

Answer 4

Une réponse rapide (moins de temps d'exécution) et sûre pour les paresseux. Tapuscrit développeurs :

export const uniqueBy = <T>( uniqueKey: keyof T, objects: T[]): T[] => {
  const ids = objects.map(object => object[uniqueKey]);
  return objects.filter((object, index) => !ids.includes(object[uniqueKey], index + 1));
}

Answer 5

Cette méthode fonctionne bien pour moi :

function arrayUnique(arr, uniqueKey) {
  const flagList = new Set()
  return arr.filter(function(item) {
    if (!flagList.has(item[uniqueKey])) {
      flagList.add(item[uniqueKey])
      return true
    }
  })
}
const data = [
  {
    name: 'Kyle',
    occupation: 'Fashion Designer'
  },
  {
    name: 'Kyle',
    occupation: 'Fashion Designer'
  },
  {
    name: 'Emily',
    occupation: 'Web Designer'
  },
  {
    name: 'Melissa',
    occupation: 'Fashion Designer'
  },
  {
    name: 'Tom',
    occupation: 'Web Developer'
  },
  {
    name: 'Tom',
    occupation: 'Web Developer'
  }
]
console.table(arrayUnique(data, 'name'))// work well

impression

┌─────────┬───────────┬────────────────────┐
│ (index) │   name    │     occupation     │
├─────────┼───────────┼────────────────────┤
│    0    │  'Kyle'   │ 'Fashion Designer' │
│    1    │  'Emily'  │   'Web Designer'   │
│    2    │ 'Melissa' │ 'Fashion Designer' │
│    3    │   'Tom'   │  'Web Developer'   │
└─────────┴───────────┴────────────────────┘

ES5 :

function arrayUnique(arr, uniqueKey) {
  const flagList = []
  return arr.filter(function(item) {
    if (flagList.indexOf(item[uniqueKey]) === -1) {
      flagList.push(item[uniqueKey])
      return true
    }
  })
}

Ces deux manières sont plus simples et plus compréhensibles.