Wie entfernt man alle Duplikate aus einem Array von Objekten?

Question

Ich habe ein Objekt, das ein Array von Objekten enthält.

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

Ich frage mich, was ist die beste Methode zum Entfernen von doppelten Objekten aus einem Array. Also zum Beispiel, obj.arr werden würde...

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

Answer 1

Eine TypeScript-Lösung

Dadurch werden doppelte Objekte entfernt und die Typen der Objekte bleiben erhalten.

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)

Lösung über Set Objekt | Entsprechend dem Datentyp

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 Objekt-Merkmal

Jeder Wert im Set-Objekt muss eindeutig sein, die Gleichheit der Werte wird geprüft

Der Zweck des Set-Objekts ist es, eindeutige Werte entsprechend dem Datentyp zu speichern, unabhängig davon, ob es sich um primitive Werte oder Objektreferenzen handelt. Es hat vier sehr nützliche Instanzmethoden add , clear , has & delete .

Einzigartige & Daten Typ Merkmal:..

add Methode

Es ist Push eindeutige Daten in die Sammlung standardmäßig auch bewahren Datentyp ... das heißt, es zu verhindern, um doppelte Element in die Sammlung zu schieben auch wird es Datentyp standardmäßig überprüfen ...

has Methode

irgendwann muss Datenelement in der Sammlung vorhanden und zu überprüfen. es ist praktisch Methode für die Sammlung, um eindeutige ID oder Element und Datentyp Wange.

delete Methode

Es wird ein bestimmtes Element aus der Sammlung entfernt, indem der Datentyp identifiziert wird.

clear Methode

werden alle Sammlungselemente aus einer bestimmten Variablen entfernt und als leeres Objekt gesetzt

Set Objekt hat auch Iterationsmethoden & mehr Funktionen

Lesen Sie besser von hier aus: Setzen - JavaScript | MDN

Answer 3

removeDuplicates() nimmt ein Array von Objekten auf und gibt ein neues Array ohne doppelte Objekte zurück (basierend auf der Eigenschaft 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);

Erwartetes Ergebnis:

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

Zunächst setzen wir den Wert der Variablen uniq auf ein leeres Objekt.

Als Nächstes filtern wir durch das Array von Objekten. Filter erstellt ein neues Array mit allen Elementen, die den von der angegebenen Funktion implementierten Test bestehen.

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

Oben haben wir die Kurzschlussfunktion von && verwendet. Wenn die linke Seite von && den Wert true ergibt, wird der Wert rechts von && zurückgegeben. Wenn die linke Seite falsch ist, wird der Wert auf der linken Seite von && zurückgegeben.

Für jedes Objekt (obj) überprüfen wir uniq auf eine Eigenschaft, die den Wert von obj.id hat (in diesem Fall würde es bei der ersten Iteration nach der Eigenschaft '1' suchen). Wir wollen das Gegenteil von dem, was es zurückgibt (entweder wahr oder falsch), weshalb wir das ! in !uniq[obj.id] . Wenn uniq die id-Eigenschaft bereits hat, gibt sie true zurück, was zu false (!) ausgewertet wird und der Filterfunktion mitteilt, dass sie dieses Objekt NICHT hinzufügen soll. Findet sie jedoch die Eigenschaft obj.id nicht, gibt sie false zurück, was dann zu true (!) ausgewertet wird und alles rechts vom && zurückgibt, oder (uniq[obj.id] = true). Dies ist ein wahrheitsgemäßer Wert, der der Filtermethode mitteilt, dass sie dieses Objekt zum zurückgegebenen Array hinzufügen soll, und sie fügt auch die Eigenschaft {1: true} zu uniq hinzu. Dadurch wird sichergestellt, dass kein anderes Objekt mit der gleichen ID mehr hinzugefügt wird.

Answer 4

Schnelle (weniger Laufzeit) und typsichere Antwort für faule Typoskript Entwickler:

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

Dieser Weg funktioniert für mich gut:

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

ausdrucken

 (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
    }
  })
}

Diese beiden Wege sind einfacher und verständlicher.