it-swarm.com.de

Entfernen Sie Duplikate aus einem Array von Objekten in JavaScript

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

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

Ich frage mich, was die beste Methode ist, um doppelte Objekte aus einem Array zu entfernen. So zum Beispiel würden Dinge ... alles werden ...

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

Mal sehen ... ein primitiver wäre:

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, ich denke, das sollte den Trick tun. Schau es dir an, Travis.

EDIT
Der Code wurde so bearbeitet, dass er korrekt auf die place (frühere id) -Eigenschaft verweist.

122
aefxx

Wie wäre es mit etwas es6 Magie?

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

Referenz-URL

Für Frontends ist dies möglicherweise zu früh, da viele verwendete Browser die es6-Funktionen noch nicht unterstützen

249
Eydrian

Wenn Sie Javascript-Bibliotheken wie unterstrichen oder lodash verwenden können, empfehle ich einen Blick auf die Funktion _.uniq in ihren Bibliotheken. Von lodash:

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

Grundsätzlich übergeben Sie im Array, dass es sich hier um ein Objektliteral handelt, und Sie übergeben das Attribut, mit dem Duplikate im ursprünglichen Datenarray entfernt werden sollen, wie folgt:

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

UPDATE: Lodash hat jetzt auch einen .uniqBy eingeführt. 

73
ambodi

Ich hatte genau diese Anforderung, doppelte Objekte in einem Array zu entfernen, basierend auf Duplikaten in einem einzelnen Feld. Ich habe den Code hier gefunden: Javascript: Duplikate aus Objektarray entfernen

In meinem Beispiel entferne ich also jedes Objekt aus dem Array, das einen doppelten Zeichenfolgenwert für licenseNum enthält.

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

Die Ergebnisse:

uniqueArray ist: 

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

Wenn Sie mit dem Beseitigen der Duplikate bis nach all den Hinzufügungen warten können, besteht die typische Vorgehensweise darin, zuerst das Array zu sortieren und dann die Duplikate zu entfernen. Die Sortierung vermeidet den N * N-Ansatz, das Array für jedes Element zu scannen, während Sie durchlaufen.

Die Funktion zum Entfernen von Duplikaten wird normalerweise als unique oder uniq bezeichnet. Einige vorhandene Implementierungen können die zwei Schritte kombinieren, z. B. uniq des Prototyps

Dieser Beitrag hat einige Ideen, die Sie ausprobieren können (und einige, die Sie meiden sollten :-)) wenn Ihre Bibliothek noch keine hat! Ich persönlich finde das am einfachsten:

    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;
    }
21
maccullt

Hier eine weitere Option, um dies mit Array-Iterationsmethoden zu tun, wenn Sie nur einen Vergleich mit einem Feld eines Objekts benötigen:

    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');
18
Alex Kobylinski

Ein Liner mit 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)

Erläuterung:

  1. new Set(myData.map(JSON.stringify)) erstellt ein Set - Objekt unter Verwendung der stringifizierten myData-Elemente. 
  2. Set-Objekt stellt sicher, dass jedes Element eindeutig ist. 
  3. Dann erstelle ich ein Array basierend auf den Elementen des erstellten Sets mit Array.from. 
  4. Schließlich verwende ich JSON.parse, um das stringifizierte Element zurück in ein Objekt zu konvertieren.
18
Mμ.

AKTUALISIERTE

Ich habe die Frage jetzt richtig gelesen. Dies ist eine generische Methode: Sie übergeben eine Funktion, die prüft, ob zwei Elemente eines Arrays als gleich betrachtet werden. In diesem Fall werden die Werte der Eigenschaften name und place der beiden zu vergleichenden Objekte verglichen.

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);
14
Tim Down

ein Liner ist hier

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}),{})))

13

Hinzufügen eines weiteren zur Liste. Verwendung von ES6 und Array.reduce mit Array.find.
In diesem Beispiel werden Objekte basierend auf einer guid-Eigenschaft gefiltert. 

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

Erweitern Sie diese Option, um die Auswahl einer Eigenschaft zu ermöglichen und sie zu einem Einzeiler zu komprimieren:

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

Um es zu verwenden, übergeben Sie ein Array von Objekten und den Namen des Schlüssels, für den Sie die Dupe machen möchten, als String-Wert:

const result = uniqify(myArrayOfObjects, 'guid')
10
Pete B

Dang, Kinder, lasst uns das Ding zerquetschen, warum nicht?

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'}];

8
Cliff Hall

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)

7
аlex dykyі

Betrachten von 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 }]
7
Justin

Eine andere Option wäre, eine benutzerdefinierte indexOf-Funktion zu erstellen, die die Werte der von Ihnen gewählten Eigenschaft für jedes Objekt vergleicht und diese in eine reduzierte Funktion einschließt. 

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;
    },[]);
7
ZeroSum

Sie können auch eine Map verwenden:

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

Vollständige probe:

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

Ergebnis:

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

Mit ES6 können Sie in einer einzelnen Zeile eine eindeutige Liste von Objekten nach Schlüssel erhalten:

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

Es kann wie im folgenden Beispiel in eine Funktion eingefügt und verwendet werden:

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)
6
V. Sambor
let data = [
  {
    'name': 'Amir',
    'surname': 'Rahnama'
  }, 
  {
    'name': 'Amir',
    'surname': 'Stevens'
  }
];
let non_duplicated_data = _.uniqBy(data, 'name');
5
qzttt

Hier ist eine Lösung für es6, wo Sie nur den letzten Artikel behalten möchten. Diese Lösung ist funktional und entspricht dem Airbnb-Stil.

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' }]
4
Micah

KURZESTER LINER

Finden Sie eindeutige IDs in einem Array.

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

Einzigartig durch mehrere Eigenschaften (ID und Name)

arr.filter((v,i,a)=>a.findIndex((t)=>(t.id === v.id && t.name===v.name))===i)
4
rturkek

Eine TypeScript-Lösung

Dadurch werden doppelte Objekte entfernt und die Objekttypen beibehalten.

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

removeDuplicates () übernimmt ein Array von Objekten und gibt ein neues Array ohne doppelte Objekte zurück (basierend auf der id-Eigenschaft).

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'}
];

Zuerst setzen wir den Wert der Variablen uniq auf ein leeres Objekt.

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

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

Oben verwenden wir die Kurzschlussfunktionalität von &&. Wenn die linke Seite von && als wahr ausgewertet wird, wird der Wert rechts von && zurückgegeben. Wenn die linke Seite falsch ist, wird das zurückgegeben, was sich auf der linken Seite von && befindet.

Für jedes Objekt (obj) prüfen wir uniq auf eine Eigenschaft mit dem Namen obj.id (In diesem Fall würde bei der ersten Iteration nach der Eigenschaft '1' gesucht.) Wir wollen das Gegenteil von dem, was es zurückgibt (entweder wahr) oder falsch), weshalb wir das verwenden! in! uniq [obj.id]. Wenn uniq bereits die id -Eigenschaft hat, wird true zurückgegeben, was zu false (!) Führt und die Filterfunktion NICHT dazu auffordert, das obj hinzuzufügen. Wenn die obj.id -Eigenschaft jedoch nicht gefunden wird, wird false zurückgegeben, was als wahr (!) Ausgewertet wird und alles rechts von && oder (uniq [obj.id] = true) zurückgibt. Dies ist ein wahrer Wert, der der Filtermethode mitteilt, das obj zum zurückgegebenen Array hinzuzufügen, und fügt außerdem die Eigenschaft {1: true} zu uniq hinzu. Dadurch wird sichergestellt, dass keine anderen obj-Instanzen mit derselben ID erneut hinzugefügt werden.

3
MarkN

Die Suche nach ES6-Methoden zum Entfernen von Duplikaten aus dem Array von Objekten wird fortgesetzt: Das Setzen des thisArg-Arguments von Array.prototype.filter auf new Set bietet eine anständige Alternative:

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

Es funktioniert jedoch nicht mit den Pfeilfunktionen () =>, da this an ihren lexikalischen Geltungsbereich gebunden ist.

2
Leonid Pyrlia

Wenn Sie keine Liste mit Eigenschaften angeben möchten:

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! Nicht kompatibel mit IE11.

2
stoatoffear

Haben Sie von Lodash Bibliothek gehört? Ich empfehle Ihnen dieses Dienstprogramm, wenn Sie Ihre Logik nicht wirklich auf den Code anwenden möchten und bereits vorhandenen Code verwenden möchten, der optimiert und zuverlässig ist. 

Erwägen Sie, ein Array wie dieses zu erstellen

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

Wenn Sie ein Attribut eindeutig halten möchten, können Sie dies sehr gut tun, indem Sie die lodash-Bibliothek verwenden. Hier können Sie _.uniqBy verwenden.

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

Diese Methode ist wie _.uniq (gibt eine duplikatfreie Version eines Arrays zurück, in der nur das erste Vorkommen jedes Elements aufbewahrt wird), mit der Ausnahme, dass Iteratee akzeptiert wird, die für jedes zu generierende Element im Array aufgerufen wird das Kriterium, nach dem die Eindeutigkeit berechnet wird.

Wenn Sie z. B. ein Array mit dem eindeutigen Attribut 'place' zurückgeben möchten,

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

Wenn Sie ein eindeutiges Attribut als "Name" haben möchten

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

Hoffe das hilft.

Prost!

2
Mayank Gangwal

Wenn Sie nichts dagegen haben, dass Ihr einzigartiges Array anschließend sortiert wird, wäre dies eine effiziente Lösung:

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

Auf diese Weise müssen Sie nur das aktuelle Element mit dem vorherigen Element im Array vergleichen. Ein einmaliges Sortieren vor dem Filtern (O(n*log(n))) ist billiger als das Suchen nach einem Duplikat im gesamten Array für jedes Arrayelement (O(n²)).

2
Clemens Helm
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)

Einzeiler mit ES6 und new Map().

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

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

Einzelheiten:-

  1. Wenn Sie .map() in der Datenliste ausführen und jedes einzelne Objekt in ein [key, value]-Paar-Array konvertieren (Länge = 2), ist das erste Element (Schlüssel) die stringified-Version des Objekts und das zweite (Wert) ist eine object selbst.
  2. Wenn Sie die oben erstellte Array-Liste zu new Map() hinzufügen, wird der Schlüssel als stringified -Objekt angezeigt. Wenn Sie denselben Schlüssel hinzufügen, wird der bereits vorhandene Schlüssel überschrieben.
  3. Durch die Verwendung von .values() erhält MapIterator alle Werte in einer Map (in unserem Fall obj).
  4. Schließlich spread ... operator, um ein neues Array mit den Werten aus dem obigen Schritt zu erstellen.
1
Savan Akbari
 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' ]
1
shubham verma

Wenn Sie Duplikate basierend auf einer Eigenschaft unbedingt entfernen möchten, können Sie reduce das Array in und das Objekt basierend auf der place -Eigenschaft values entfernen, da das Objekt nur eindeutige Schlüssel haben kann.

const unique = Object.values(things.thing.reduce((o, t) => ({ ...o, [t.place]: t }), {}))
0
crmackey

Wenn Sie feststellen, dass Sie häufig doppelte Objekte aus Arrays entfernen müssen, die auf bestimmten Feldern basieren, empfiehlt es sich möglicherweise, eine distinct(array, predicate) -Funktion zu erstellen, die Sie von überall in Ihrem Projekt importieren können. Das würde so aussehen

const things = [{place:"here",name:"stuff"}, ...];
const distinctThings = distinct(things, thing => thing.place);

Die eindeutige Funktion kann jede der Implementierungen verwenden, die in den vielen guten Antworten oben angegeben sind. Am einfachsten verwendet man findIndex:

const distinct = (items, predicate) => items.filter((uniqueItem, index) =>
    items.findIndex(item =>
        predicate(item) === predicate(uniqueItem)) === index);
0
Elphas

Sie können Object.values ​​() in Kombination mit Array.prototype.reduce () verwenden:

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; }
0
Yosvel Quintero
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 ist ein Array von Objekten. Es gibt Objekte mit demselben Wert (hier ein kleines Beispiel, es gibt zwei Objekte mit derselben item_id wie 2). check (id) ist eine Funktion, die prüft, ob ein Objekt mit derselben item_id existiert oder nicht. Wenn es existiert, geben Sie false zurück, andernfalls true. Entsprechend diesem Ergebnis verschieben Sie das Objekt in ein neues Array obj Die Ausgabe des obigen Codes ist [{"item_id":1},{"item_id":2}]

0
Bibin Jaimon

Generisch für ein beliebiges Array von Objekten:

/**
* 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;
}

Hoffe, es könnte jedem helfen.

0
aSoler

Einfache Lösung mit ES6 "Reduzieren" und "Finden" Array-Helfer-Methoden

Funktioniert effizient und einwandfrei!

"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));
0
KJ Sudarshan

Sie können die Array-Objekte in Zeichenfolgen konvertieren, damit sie verglichen werden können. Fügen Sie die Zeichenfolgen zu einem Set hinzu, damit die vergleichbaren Duplikate automatisch entfernt werden, und konvertieren Sie dann jede der Zeichenfolgen zurück in Objekte.

Es ist möglicherweise nicht so performant wie andere Antworten, aber lesbar.

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

hier ist meine Lösung. Es sucht nach Duplikaten basierend auf object.prop und wenn ein doppeltes Objekt gefunden wird, replaces its value in 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;
}
0
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)
        }
    });
0
ARUN ARUMUGAM
  • Diese Lösung ist für alle Arten von Objekten generisch und prüft für jeden (key, value) der Object im Array. 
  • Verwenden eines temporären Objekts als Hashtabelle, um festzustellen, ob die gesamte Object jemals als Schlüssel vorhanden war.
  • Wenn die Zeichenfolgendarstellung von Object gefunden wird, wird das Element aus dem Array entfernt.

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

0
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"
}]
0
wLc

es6 magie in einer zeile ... dazu lesbar!

// 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]);
0
Josiah Coad

Hier ist eine Lösung, die eine neue Filterfunktion von JavaScript verwendet, die recht einfach ist. Nehmen wir an, Sie haben so ein Array.

var duplicatesArray = ['AKASH','AKASH','NAVIN','HARISH','NAVIN','HARISH','AKASH','MANJULIKA','AKASH','TAPASWENI','MANJULIKA','HARISH','TAPASWENI','AKASH','MANISH','HARISH','TAPASWENI','MANJULIKA','MANISH'];

Mit der Filterfunktion können Sie ein neues Array erstellen, indem Sie einmal für jedes Element im Array eine Callback-Funktion verwenden. So können Sie das einzigartige Array so einrichten.

var uniqueArray = duplicatesArray.filter(function(elem, pos) {return duplicatesArray.indexOf(elem) == pos;});

In diesem Szenario führt Ihr eindeutiges Array alle Werte in dem doppelten Array durch. Die elem-Variable stellt den Wert des Elements im Array dar (mike, james, james, alex), die Position ist die 0-indizierte Position im Array (0,1,2,3 ...) und das DuplikateArray. Der indexOf (elem) -Wert ist nur der Index des ersten Vorkommens dieses Elements im ursprünglichen Array. Da also das Element 'james' dupliziert wird, wenn wir alle Elemente in den Duplikaten durchlaufen und sie in das uniqueArray verschieben, werden wir beim ersten Treffer von james 1 und unser indexOf (elem). ist auch 1, also wird James zum uniqueArray geschoben. Wenn wir James zum zweiten Mal treffen, ist unser "pos" -Wert 2, und unser indexOf (elem) ist immer noch 1 (da er nur die erste Instanz eines Array-Elements findet), sodass das Duplikat nicht gepusht wird. Unser uniqueArray enthält daher nur eindeutige Werte.

Hier ist die Demo der obigen Funktion. Hier klicken für das obige Funktionsbeispiel

0
HARISH TIWARY

Hier ist eine weitere Technik, um die Anzahl der Duplikate zu finden und sie leicht aus Ihrem Datenobjekt zu entfernen. "dupsCount" ist die Anzahl der doppelten Dateien. sortieren Sie zuerst Ihre Daten und entfernen Sie sie anschließend. es wird Ihnen schnellstes Duplizieren ermöglichen.

  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++;
            }
        }
0
HD..

Eine andere Möglichkeit wäre, die Reduktionsfunktion zu verwenden und ein neues Array als Akkumulator zu verwenden. Wenn es bereits ein thing mit demselben Namen im Akkumulator-Array gibt, fügen Sie es dort nicht hinzu.

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;

Ich füge diese Antwort hinzu, weil ich keine gute, lesbare es6-Lösung gefunden habe (ich verwende babel, um Pfeilfunktionen zu verarbeiten), die mit Internet Explorer 11 kompatibel ist. Das Problem ist, dass IE11 nicht über Map.values() oder _ verfügt Set.values() ohne Polyfill. Aus dem gleichen Grund habe ich filter()[0] verwendet, um das erste Element anstelle von find() zu erhalten.

0
Keammoort

Was ist damit:

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;
}
0
zipper

Dies ist eine einfache Methode zum Entfernen von Duplizität aus einem Array von Objekten.

Ich arbeite viel mit Daten und das ist für mich nützlich.

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

wird in die Konsole drucken:

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

Quelle

JSFiddle

Dadurch wird das doppelte Objekt entfernt, ohne dass ein Schlüssel übergeben wird.

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);
0
Suhail AKhtar

Wenn Sie ein eindeutiges Array benötigen, das auf mehreren Eigenschaften im Objekt basiert, können Sie dies mit der Zuordnung und Kombination der Eigenschaften des Objekts tun.

    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
    })
0
ykay

Mach etwas einfach. Phantasie ist gut, aber unlesbarer Code ist nutzlos. Genießen :-)

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