Entfernen Sie Duplikate aus einem Array

Ich habe eine Reihe von Objekten, die so aussehen:

var array = [
    {id:123, value:"value1", name:"Name1"},
    {id:124, value:"value2", name:"Name1"},
    {id:125, value:"value3", name:"Name2"},
    {id:126, value:"value4", name:"Name2"}
    ...
];

Wie Sie sehen können, werden einige Namen wiederholt. Ich möchte ein neues Array nur mit Namen erhalten, aber wenn sich ein Name wiederholt, möchte ich ihn nicht erneut hinzufügen. Ich möchte dieses Array:

var newArray = ["Name1", "Name2"];

Ich versuche das mit map:

var newArray = array.map((a) => {
    return a.name;
});

Das Problem ist jedoch, dass dies zurückkehrt:

newArray = ["Name1", "Name1", "Name2", "Name2"];

Wie kann ich eine Bedingung festlegen map, damit kein bereits vorhandenes Element zurückgegeben wird? Ich möchte dies mit mapoder einer anderen ECMAScript 5- oder ECMAScript 6-Funktion tun .

Mit ES6 können Sie Seteindeutige Werte verwenden, nachdem Sie nur die Namen der Objekte zugeordnet haben.

Dieser Vorschlag verwendet eine Spread-Syntax... zum Sammeln der Elemente in einem neuen Array.

const array = [{ id: 123, value: "value1", name:"Name1" }, { id: 124, value: "value2", name: "Name1" }, { id: 125, value: "value3", name: "Name2" }, { id: 126, value: "value4", name: "Name2" }],
      names = [...new Set(array.map(a => a.name))];

console.log(names);

Wenn Sie nach einer JavaScript-Lösung suchen, die nicht ES 6 (no Set) ist, können Sie die reduceMethode des Arrays verwenden :

var array=[
  {id:123, value:"value1", name:"Name1"},
  {id:124, value:"value2", name:"Name1"},
  {id:125, value:"value3", name:"Name2"},
  {id:126, value:"value4", name:"Name2"}
];
var names = array.reduce(function (a, b) {
  if (a.indexOf(b.name) == -1) {
    a.push(b.name)
  }
  return a;
}, []);

console.log(names);

Persönlich verstehe ich nicht, warum alle Lust auf ES 6 haben. Wenn es mein Code wäre, würde ich es vorziehen, so viele Browser wie möglich zu unterstützen.

var array=[
{id:123, value:"value1", name:"Name1"},
{id:124, value:"value2", name:"Name1"},
{id:125, value:"value3", name:"Name2"},
{id:126, value:"value4", name:"Name2"}
];

   // Create array of unique names
var a = (function(a){
  for (var i = array.length; i--;)
    if (a.indexOf(array[i].name) < 0) a.push(array[i].name);
  return a;
})([]);

console.log(a);

Sie könnten auch einfach kombinieren mapmitfilter

var array = [
  {id:123, value:"value1", name:"Name1"},
  {id:124, value:"value2", name:"Name1"},
  {id:125, value:"value3", name:"Name2"},
  {id:126, value:"value4", name:"Name2"}
];

var unique = array
  .map( item => item.name )
  .filter( ( item, idx, arr ) => arr.indexOf( item ) == idx ) 

console.log(unique)

Sie können Object.keys () verwenden , um das Array der eigenen aufzählbaren Eigenschaftsnamen eines bestimmten Objekts aus dem Objektergebnis der iterierenden arrayVariablen mit Array.prototype.reduce () abzurufen, wobei die Schlüssel die zerstörten Namen sind

Code:

const array = [{id:123, value:"value1", name:"Name1"}, {id:124, value:"value2", name:"Name1"}, {id:125, value:"value3", name:"Name2"}, {id:126, value:"value4", name:"Name2"}],
      names = Object.keys(array.reduce((a, { name }) => (a[name] = 1, a), {}))

console.log(names)

Viele gute Antworten hier. Ich möchte nur mit etwas Abwechslung dazu beitragen, Ihnen eine andere Perspektive zu geben.

Arrays sind in JavaScript vom Objekttyp, sodass sie gleichzeitig als Hash verwendet werden können. Durch die Verwendung dieser Funktionalität können wir die Arbeit in einem einzigen Reduktionsvorgang mit O (n) -Zeitkomplexität erheblich vereinfachen.

Wenn Sie nicht zufrieden sind, dass Ihr Array andere Eigenschaften als die Array-Schlüssel enthält, können Sie auch ein separates Hash-Objekt behalten.

var array = [{id:123, value:"value1", name:"Name1"},
             {id:124, value:"value2", name:"Name1"},
             {id:125, value:"value3", name:"Name2"},
             {id:126, value:"value4", name:"Name2"}
            ],
result = array.reduce((p,c) => p[c.name] ? p : (p[c.name] = true, p.push(c.name), p), []);
console.log(result);

Ich bin damit einverstanden, dass a der namerichtige SetWeg ist , wenn Sie nur die Werte benötigen .

Allerdings , wenn Sie wollen auf der eine Reihe von einzigartigen Objekten erhalten basierte nameEigenschaft, würde ich vorschlagen , eine verwenden Map. Eine schnelle Möglichkeit zum Erstellen einer Karte besteht in einer Reihe von [key, value]Arrays:

const array = [{ id: 123, value: "value1", name:"Name1" }, { id: 124, value: "value2", name: "Name1" }, { id: 125, value: "value3", name: "Name2" }, { id: 126, value: "value4", name: "Name2" }],
      unique = new Map(array.map(obj => [obj.name, obj]));

// To get the unique objects
const uniques = Array.from(unique.values());

// Get the names like you already did:
console.log("Names:", uniques.map(obj => obj.name));

// If you ever need the complete array of unique objects, you got a ref:
console.log(JSON.stringify(uniques));

.as-console-wrapper { min-height: 100%; }

Ein zusätzlicher Vorteil von Mapist, dass Sie beide filterFunktionen erhalten, die die Nicht-Unikate ausschneiden, ohne die Verbindung mit den Quellobjekten zu verlieren. Natürlich ist es nur erforderlich, wenn Sie mehrmals auf den eindeutigen Satz von Objekten verweisen müssen.

Wenn Sie auf ES5 beschränkt sind, würde ich Lodashs verwenden_.uniq

var newArray = _.uniq(array.map(function(a) {
  return a.name;
}));

Mit ES6 sollte dies den Job machen.

var array=[
    {id:123, value:"value1", name:"Name1"},
    {id:124, value:"value2", name:"Name1"},
    {id:125, value:"value3", name:"Name2"},
    {id:126, value:"value4", name:"Name2"}
];

var set = new Set();

array.forEach((a)=>{
    set.add(a.name);
}); 

console.log(Array.from(set));

Verwenden von UnderscoreJS,

array = [{id:123, value:"value1", name:"Name1"}, {id:124, value:"value2", name:"Name1"}, {id:125, value:"value3", name:"Name2"}, {id:126, value:"value4", name:"Name2"}];
get_names =  _.pluck(_.uniq(array, 'name'), 'name')
console.log(get_names)

<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>

`

Verwenden Sie in ES5 ein Objekt als Wörterbuch für die O ( n ) -Leistung.

Dies funktioniert nur, wenn alle Schlüssel Strings sind.

var array = [
    {id: 123, value: "value1", name: "Name1"},
    {id: 124, value: "value2", name: "Name1"},
    {id: 125, value: "value3", name: "Name2"},
    {id: 126, value: "value4", name: "Name2"}
];

var allNames = array.map(item => item.name);

var map = {};
allNames.forEach(name => {
  map[name] = true;
});
var uniqueNames = Object.keys(map);

console.log(uniqueNames);

Sie können dasselbe in einem Ausdruck tun, wenn Sie möchten:

var uniqueNames = Object.keys(allNames.reduce((m, n) => (m[n] = true, m), {}));

aber ich finde die imperative Form leichter zu lesen.

Versuche dies:

nArr = [];
array.forEach((a) => {
    if (nArr.indexOf(a.name) < 0) { 
        nArr.push(a.name); 
    }
}); 

Verwenden Sie array#forEach()und array#indexOf()Methoden wie diese, wenn Sie noch maximale Kompatibilität wünschen , prägnante Syntax:

const array = [{ id: 123, value: "value1", name:"Name1" }, { id: 124, value: "value2", name: "Name1" }, { id: 125, value: "value3", name: "Name2" }, { id: 126, value: "value4", name: "Name2" }]

// initialize an empty array named names
let names = [];

// iterate through every element of `array` & check if it's 'name' key's value already in names array if not ADD it 
array.forEach(function(element) { if (names.indexOf(element.name) === -1) names.push(element.name) });
// or use tilde like this:
//array.forEach(function(element) { if (~names.indexOf(element.name)) names.push(element.name) });

console.log(names);

Wenn die Kompatibilität jedoch kein Problem darstellt, verwenden Sie das Objekt von ECMAScript 6 und folgende Methoden: Setarray#mapArray.from()

const array = [{ id: 123, value: "value1", name:"Name1" }, { id: 124, value: "value2", name: "Name1" }, { id: 125, value: "value3", name: "Name2" }, { id: 126, value: "value4", name: "Name2" }];

// iterate through every element from array using map and store it in Set(a Set won't have duplicates) then convert the Set back to Array(using Array.from)
let names = Array.from(new Set(array.map(element => element.name)));

console.log(names);

So habe ich es gemacht, indem ich ein separates leeres Array verwendet habe.

var array = [
   {id:123, value:"value1", name:"Name1"},
   {id:124, value:"value2", name:"Name1"},
   {id:125, value:"value3", name:"Name2"},
   {id:126, value:"value4", name:"Name2"}	    
];

var array2 = []		
		
for (i=0; i<array.length;i++){						
   if (array2.indexOf(array[i].name) == -1){				
     array2.push(array[i].name);
    }
}			

console.log(array2)	

Für diejenigen, die einen 1 Liner suchen

const names = array.reduce((acc, {name}) => acc.includes(name) ? acc : [name, ...acc], []);

oder ohne Verwendung von Methoden für den Prototyp des Arrays

const { reduce, includes } = Array;
const names = reduce(array, (acc, {name}) => includes(acc, name) ? acc : [name, ...acc], []);

könnte nützlich sein, um einige reine Funktionen zu schreiben, um damit umzugehen

const get_uniq_values = (key, arr) => reduce(arr, (a, o) => includes(a, o[key]) ? a : [o[key], ...a], []);

var __array=[{id:123, value:"value1", name:"Name1"},{id:124, value:"value2", name:"Name1"},{id:125, value:"value3", name:"Name2"},{id:126, value:"value4", name:"Name2"}];

function __checkArray(__obj){
    var flag = true;
    for(let i=0; i < __array.length; i++){
        if(__obj.id == __array.id){
            flag = false;
            break;
        }
    }

    return flag;
}

var __valToPush = {id: 127, value: "value5", name: "Name3"};
if(__checkArray(__valToPush)){
    __array.push(__valToPush)
}