it-swarm.com.de

Entfernen Sie doppelte Werte aus dem JS-Array

Ich habe ein sehr einfaches JavaScript-Array, das möglicherweise Duplikate enthält oder nicht.

var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];

Ich muss die Duplikate entfernen und die eindeutigen Werte in ein neues Array einfügen.

Ich könnte auf alle Codes verweisen, die ich ausprobiert habe, aber ich denke, es ist nutzlos, weil sie nicht funktionieren. Ich akzeptiere auch jQuery-Lösungen.

Ähnliche Frage:

1175
kramden88

Schnell und versaut mit jQuery:

var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
var uniqueNames = [];
$.each(names, function(i, el){
    if($.inArray(el, uniqueNames) === -1) uniqueNames.Push(el);
});
421
Roman Bataev

TL; DR

Verwenden des Set -Konstruktors und der Spread-Syntax :

uniq = [...new Set(array)];

"Klug" aber naiv

uniqueArray = a.filter(function(item, pos) {
    return a.indexOf(item) == pos;
})

Grundsätzlich iterieren wir über das Array und prüfen für jedes Element, ob die erste Position dieses Elements im Array der aktuellen Position entspricht. Offensichtlich sind diese beiden Positionen für doppelte Elemente unterschiedlich.

Mit dem 3. Parameter ("this array") des Filter-Callbacks können wir ein Schließen der Array-Variablen vermeiden:

uniqueArray = a.filter(function(item, pos, self) {
    return self.indexOf(item) == pos;
})

Obwohl dieser Algorithmus kurz ist, ist er für große Arrays (quadratische Zeit) nicht besonders effizient.

Hashtables zur Rettung

function uniq(a) {
    var seen = {};
    return a.filter(function(item) {
        return seen.hasOwnProperty(item) ? false : (seen[item] = true);
    });
}

So wird es normalerweise gemacht. Die Idee ist, jedes Element in eine Hash-Tabelle zu platzieren und dann sofort auf seine Anwesenheit zu prüfen. Dies gibt uns lineare Zeit, hat aber mindestens zwei Nachteile:

  • da Hash-Schlüssel in JavaScript nur Zeichenfolgen sein können, unterscheidet dieser Code keine Zahlen und "numerischen Zeichenfolgen". Das heißt, uniq([1,"1"]) gibt nur [1] zurück
  • aus demselben Grund werden alle Objekte als gleich betrachtet: uniq([{foo:1},{foo:2}]) gibt nur [{foo:1}] zurück.

Wenn Ihre Arrays jedoch nur Primitive enthalten und Sie sich nicht für Typen interessieren (z. B. immer für Zahlen), ist diese Lösung optimal.

Das Beste aus zwei Welten

Eine universelle Lösung kombiniert beide Ansätze: Sie verwendet Hash-Lookups für Grundelemente und die lineare Suche nach Objekten.

function uniq(a) {
    var prims = {"boolean":{}, "number":{}, "string":{}}, objs = [];

    return a.filter(function(item) {
        var type = typeof item;
        if(type in prims)
            return prims[type].hasOwnProperty(item) ? false : (prims[type][item] = true);
        else
            return objs.indexOf(item) >= 0 ? false : objs.Push(item);
    });
}

sortieren | uniq

Eine andere Möglichkeit besteht darin, das Array zuerst zu sortieren und dann jedes Element zu entfernen, das dem vorhergehenden Element entspricht:

function uniq(a) {
    return a.sort().filter(function(item, pos, ary) {
        return !pos || item != ary[pos - 1];
    })
}

Auch dies funktioniert nicht mit Objekten (da alle Objekte für sort gleich sind). Zusätzlich ändern wir stillschweigend das ursprüngliche Array als Nebeneffekt - nicht gut! Wenn Ihre Eingabe jedoch bereits sortiert ist, ist dies der richtige Weg (entfernen Sie einfach sort von oben).

Einzigartig durch ...

Manchmal ist es wünschenswert, eine Liste basierend auf anderen Kriterien als nur der Gleichheit zu vereinheitlichen, um beispielsweise Objekte herauszufiltern, die unterschiedlich sind, aber eine bestimmte Eigenschaft gemeinsam haben. Dies kann elegant durch Übergabe eines Rückrufs erfolgen. Dieser "Schlüssel" -Rückruf wird auf jedes Element angewendet, und Elemente mit gleichen "Schlüsseln" werden entfernt. Da erwartet wird, dass key ein Primitiv zurückgibt, funktioniert die Hash-Tabelle hier einwandfrei:

function uniqBy(a, key) {
    var seen = {};
    return a.filter(function(item) {
        var k = key(item);
        return seen.hasOwnProperty(k) ? false : (seen[k] = true);
    })
}

Ein besonders nützliches key() ist JSON.stringify, das Objekte entfernt, die physikalisch unterschiedlich sind, aber gleich "aussehen":

a = [[1,2,3], [4,5,6], [1,2,3]]
b = uniqBy(a, JSON.stringify)
console.log(b) // [[1,2,3], [4,5,6]]

Wenn das key nicht primitiv ist, müssen Sie auf die lineare Suche zurückgreifen:

function uniqBy(a, key) {
    var index = [];
    return a.filter(function (item) {
        var k = key(item);
        return index.indexOf(k) >= 0 ? false : index.Push(k);
    });
}

In ES6 können Sie ein Set verwenden:

function uniqBy(a, key) {
    let seen = new Set();
    return a.filter(item => {
        let k = key(item);
        return seen.has(k) ? false : seen.add(k);
    });
}

oder ein Map:

function uniqBy(a, key) {
    return [
        ...new Map(
            a.map(x => [key(x), x])
        ).values()
    ]
}

die beide auch mit nicht-primitiven Schlüsseln arbeiten.

Zuerst oder zuletzt?

Wenn Sie Objekte mit einem Schlüssel entfernen, möchten Sie möglicherweise das erste von "gleichen" Objekten oder das letzte behalten.

Verwenden Sie die Set -Variante oben, um die erste und die Map, um die letzte zu behalten:

function uniqByKeepFirst(a, key) {
    let seen = new Set();
    return a.filter(item => {
        let k = key(item);
        return seen.has(k) ? false : seen.add(k);
    });
}


function uniqByKeepLast(a, key) {
    return [
        ...new Map(
            a.map(x => [key(x), x])
        ).values()
    ]
}

//

data = [
    {a:1, u:1},
    {a:2, u:2},
    {a:3, u:3},
    {a:4, u:1},
    {a:5, u:2},
    {a:6, u:3},
];

console.log(uniqByKeepFirst(data, it => it.u))
console.log(uniqByKeepLast(data, it => it.u))

Bibliotheken

Beide nterstrich und Lo-Dash bieten uniq Methoden. Ihre Algorithmen ähneln im Wesentlichen dem obigen ersten Snippet und lassen sich wie folgt zusammenfassen:

var result = [];
a.forEach(function(item) {
     if(result.indexOf(item) < 0) {
         result.Push(item);
     }
});

Das ist quadratisch, aber es gibt nette zusätzliche Extras, wie das Umschließen von nativem indexOf, die Fähigkeit, durch einen Schlüssel zu vereinheitlichen (iteratee in ihrer Sprache) und Optimierungen für bereits sortierte Arrays.

Wenn Sie jQuery verwenden und nichts ohne einen Dollar davor aushalten können, sieht das so aus:

  $.uniqArray = function(a) {
        return $.grep(a, function(item, pos) {
            return $.inArray(item, a) === pos;
        });
  }

dies ist wiederum eine Variation des ersten Snippets.

Performance

Funktionsaufrufe sind in JavaScript teuer, daher sind die obigen Lösungen, so kurz sie sind, nicht besonders effizient. Ersetzen Sie für eine maximale Leistung filter durch eine Schleife und entfernen Sie andere Funktionsaufrufe:

function uniq_fast(a) {
    var seen = {};
    var out = [];
    var len = a.length;
    var j = 0;
    for(var i = 0; i < len; i++) {
         var item = a[i];
         if(seen[item] !== 1) {
               seen[item] = 1;
               out[j++] = item;
         }
    }
    return out;
}

Dieser Teil des hässlichen Codes entspricht dem obigen Snippet Nr. 3. aber eine Größenordnung schneller (Ab 2017 ist es nur noch doppelt so schnell - JS Core-Leute machen einen tollen Job!)

function uniq(a) {
    var seen = {};
    return a.filter(function(item) {
        return seen.hasOwnProperty(item) ? false : (seen[item] = true);
    });
}

function uniq_fast(a) {
    var seen = {};
    var out = [];
    var len = a.length;
    var j = 0;
    for(var i = 0; i < len; i++) {
         var item = a[i];
         if(seen[item] !== 1) {
               seen[item] = 1;
               out[j++] = item;
         }
    }
    return out;
}

/////

var r = [0,1,2,3,4,5,6,7,8,9],
    a = [],
    LEN = 1000,
    LOOPS = 1000;

while(LEN--)
    a = a.concat(r);

var d = new Date();
for(var i = 0; i < LOOPS; i++)
    uniq(a);
document.write('<br>uniq, ms/loop: ' + (new Date() - d)/LOOPS)

var d = new Date();
for(var i = 0; i < LOOPS; i++)
    uniq_fast(a);
document.write('<br>uniq_fast, ms/loop: ' + (new Date() - d)/LOOPS)

ES6

ES6 stellt das Objekt Set zur Verfügung, mit dem die Dinge viel einfacher werden:

function uniq(a) {
   return Array.from(new Set(a));
}

oder

let uniq = a => [...new Set(a)];

Beachten Sie, dass ES6-Sets im Gegensatz zu Python in der Reihenfolge der Einfügung iteriert werden, sodass dieser Code die Reihenfolge des ursprünglichen Arrays beibehält.

Wenn Sie jedoch ein Array mit eindeutigen Elementen benötigen, können Sie Sets von Anfang an verwenden.

Generatoren

Eine "faule", generatorbasierte Version von uniq kann auf derselben Basis erstellt werden:

  • nimm den nächsten Wert aus dem Argument
  • wenn es schon gesehen wurde, überspringe es
  • andernfalls geben Sie es nach und fügen es zu den bereits gesehenen Werten hinzu
function* uniqIter(a) {
    let seen = new Set();

    for (let x of a) {
        if (!seen.has(x)) {
            seen.add(x);
            yield x;
        }
    }
}

// example:

function* randomsBelow(limit) {
    while (1)
        yield Math.floor(Math.random() * limit);
}

// note that randomsBelow is endless

count = 20;
limit = 30;

for (let r of uniqIter(randomsBelow(limit))) {
    console.log(r);
    if (--count === 0)
        break
}

// exercise for the reader: what happens if we set `limit` less than `count` and why
3024
georg

Ich habe es satt, alle schlechten Beispiele mit for-loops oder jQuery zu sehen. Heutzutage hat Javascript die perfekten Werkzeuge dafür: Sortieren, Zuordnen und Verkleinern.

Uniq reduzieren unter Beibehaltung der bestehenden Bestellung

var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];

var uniq = names.reduce(function(a,b){
    if (a.indexOf(b) < 0 ) a.Push(b);
    return a;
  },[]);

console.log(uniq, names) // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]

// one liner
return names.reduce(function(a,b){if(a.indexOf(b)<0)a.Push(b);return a;},[]);

Schneller und einfacher sortieren

Es gibt wahrscheinlich schnellere Wege, aber dieser ist ziemlich anständig.

var uniq = names.slice() // slice makes copy of array before sorting it
  .sort(function(a,b){
    return a > b;
  })
  .reduce(function(a,b){
    if (a.slice(-1)[0] !== b) a.Push(b); // slice(-1)[0] means last item in array without removing it (like .pop())
    return a;
  },[]); // this empty array becomes the starting value for a

// one liner
return names.slice().sort(function(a,b){return a > b}).reduce(function(a,b){if (a.slice(-1)[0] !== b) a.Push(b);return a;},[]);

Update 2015: ES6-Version:

In ES6 haben Sie Sets und Spread, wodurch es sehr einfach und performant ist, alle Duplikate zu entfernen:

var uniq = [ ...new Set(names) ]; // [ 'Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Carl' ]

Nach Vorkommen sortieren:

Jemand fragte nach der Reihenfolge der Ergebnisse anhand der Anzahl der eindeutigen Namen:

var names = ['Mike', 'Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl']

var uniq = names
  .map((name) => {
    return {count: 1, name: name}
  })
  .reduce((a, b) => {
    a[b.name] = (a[b.name] || 0) + b.count
    return a
  }, {})

var sorted = Object.keys(uniq).sort((a, b) => uniq[a] < uniq[b])

console.log(sorted)
306

Vanilla JS: Duplikate mit einem Objekt wie einem Set entfernen

Sie können jederzeit versuchen, es in ein Objekt einzufügen und dann die Schlüssel zu durchlaufen:

function remove_duplicates(arr) {
    var obj = {};
    var ret_arr = [];
    for (var i = 0; i < arr.length; i++) {
        obj[arr[i]] = true;
    }
    for (var key in obj) {
        ret_arr.Push(key);
    }
    return ret_arr;
}

Vanilla JS: Entfernen Sie Duplikate, indem Sie bereits gesehene Werte nachverfolgen (auftragssicher)

Oder verwenden Sie für eine auftragssichere Version ein Objekt, um alle zuvor angezeigten Werte zu speichern, und überprüfen Sie die Werte davor, bevor Sie sie einem Array hinzufügen.

function remove_duplicates_safe(arr) {
    var seen = {};
    var ret_arr = [];
    for (var i = 0; i < arr.length; i++) {
        if (!(arr[i] in seen)) {
            ret_arr.Push(arr[i]);
            seen[arr[i]] = true;
        }
    }
    return ret_arr;

}

ECMAScript 6: Verwenden Sie die neue Set-Datenstruktur (auftragssicher)

ECMAScript 6 fügt die neue Set -Datenstruktur hinzu, mit der Sie Werte beliebigen Typs speichern können. Set.values gibt Elemente in der Einfügereihenfolge zurück.

function remove_duplicates_es6(arr) {
    let s = new Set(arr);
    let it = s.values();
    return Array.from(it);
}

Beispielverwendung:

a = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];

b = remove_duplicates(a);
// b:
// ["Adam", "Carl", "Jenny", "Matt", "Mike", "Nancy"]

c = remove_duplicates_safe(a);
// c:
// ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Carl"]

d = remove_duplicates_es6(a);
// d:
// ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Carl"]
96
Casey Kuball

Verwenden Sie nderscore.js

Es ist eine Bibliothek mit einer Vielzahl von Funktionen zum Bearbeiten von Arrays.

Das passt zu jQueries Tux und den Hosenträgern von Backbone.js.

_. uniq

_.uniq(array, [isSorted], [iterator]) Alias: unique
Erstellt eine duplikatfreie Version des Arrays , wobei === zum Testen der Objektgleichheit verwendet wird. Wenn Sie im Voraus wissen, dass das Array sortiert ist, übergeben Sie true für isSorted führt einen viel schnelleren Algorithmus aus. Wenn Sie eindeutige Elemente basierend auf einer Transformation berechnen möchten, übergeben Sie eine Iteratorfunktion .

Beispiel

var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];

alert(_.uniq(names, false));

Hinweis: Lo-Dash (ein nterstrich Konkurrent) bietet ebenfalls eine vergleichbare .uniq Implementierung.

71
Brandon Boone

Eine einzeilige Version mit Array-Filter und indexOf-Funktionen:

arr = arr.filter (function (value, index, array) { 
    return array.indexOf (value) == index;
});
68
HBP

Sie können dies einfach in JavaScript mit Hilfe des zweiten Indexparameters der filter -Methode tun:

var a = [2,3,4,5,5,4];
a.filter(function(value, index){ return a.indexOf(value) == index });

oder in kurzer Hand

a.filter((v,i) => a.indexOf(v) == i)
54
Ashutosh Jha

Eine Linie:

let names = ['Mike','Matt','Nancy','Adam','Jenny','Nancy','Carl', 'Nancy'];
let dup = [...new Set(names)];
console.log(dup);
48
Jonca33

Die präziseste Methode zum Entfernen von Duplikaten aus einem Array mithilfe systemeigener Javascript-Funktionen ist die Verwendung einer Sequenz wie der folgenden:

vals.sort().reduce(function(a, b){ if (b != a[0]) a.unshift(b); return a }, [])

es gibt keine Notwendigkeit für slice oder indexOf innerhalb der Reduktionsfunktion, wie ich in anderen Beispielen gesehen habe! Es ist jedoch sinnvoll, es zusammen mit einer Filterfunktion zu verwenden:

vals.filter(function(v, i, a){ return i == a.indexOf(v) })

Eine weitere Möglichkeit, dies mit ES6 (2015) zu tun, die bereits auf einigen Browsern funktioniert, ist:

Array.from(new Set(vals))

oder sogar mit dem spread operator :

[...new Set(vals)]

prost!

34
Ivo

benutze Array.filter() so

var actualArr = ['Apple', 'Apple', 'Banana', 'Mango', 'Strawberry', 'Banana'];

console.log('Actual Array: ' + actualArr);

var filteredArr = actualArr.filter(function(item, index) {
  if (actualArr.indexOf(item) == index)
    return item;
});

console.log('Filtered Array: ' + filteredArr);

dies kann in ES6 bis kürzer gemacht werden

actualArr.filter((item,index,self) => self.indexOf(item)==index);

hier ist eine nette Erklärung von Array.filter()

31
Sumit Joshi

Gehen Sie für diesen einen:

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

Jetzt enthält uniqueArray keine Duplikate mehr.

20
Juhan

Einfachste, die ich bisher getroffen habe. In es6.

 var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl", "Mike", "Nancy"]

 var noDupe = Array.from(new Set(names))

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set

19
Deke

Lösung 1

Array.prototype.unique = function() {
    var a = [];
    for (i = 0; i < this.length; i++) {
        var current = this[i];
        if (a.indexOf(current) < 0) a.Push(current);
    }
    return a;
}

Lösung 2 (mit Set)

Array.prototype.unique = function() {
    return Array.from(new Set(this));
}

Test

var x=[1,2,3,3,2,1];
x.unique() //[1,2,3]

Leistung

Als ich beide Implementierungen (mit und ohne Set) auf Leistung in Chrome getestet habe, stellte ich fest, dass die mit Set viel schneller ist!

Array.prototype.unique1 = function() {
    var a = [];
    for (i = 0; i < this.length; i++) {
        var current = this[i];
        if (a.indexOf(current) < 0) a.Push(current);
    }
    return a;
}


Array.prototype.unique2 = function() {
    return Array.from(new Set(this));
}

var x=[];
for(var i=0;i<10000;i++){
        x.Push("x"+i);x.Push("x"+(i+1));
}

console.time("unique1");
console.log(x.unique1());
console.timeEnd("unique1");



console.time("unique2");
console.log(x.unique2());
console.timeEnd("unique2");
17
ShAkKiR

Ich hatte bei einer anderen Frage einen detaillierten Vergleich der Entfernung von Dupes durchgeführt, aber als ich bemerkte, dass dies der wahre Ort ist, wollte ich es auch hier mitteilen.

Ich glaube, das ist der beste Weg, dies zu tun

var myArray = [100, 200, 100, 200, 100, 100, 200, 200, 200, 200],
    reduced = Object.keys(myArray.reduce((p,c) => (p[c] = true,p),{}));
console.log(reduced);

OK .. obwohl dieses O(n) ist und die anderen O (n ^ 2) sind, war ich neugierig auf einen Benchmark-Vergleich zwischen dieser Reduce/Lookup-Tabelle und der Filter/IndexOf-Kombination (ich wähle) Jeetendras sehr nette Implementierung https://stackoverflow.com/a/37441144/4543207 ). Ich bereite ein Array mit 100.000 Elementen vor, das mit zufälligen positiven Ganzzahlen im Bereich von 0 bis 9999 gefüllt ist, und es entfernt die Duplikate. Ich wiederhole den Test zehnmal und der Durchschnitt der Ergebnisse zeigt, dass die Leistung nicht übereinstimmt.

  • In Firefox V47 reduzieren & Lut: 14,85 ms vs Filter & IndexOf: 2836 ms
  • In chrome v51 wird & lut: 23.90ms vs filter & indexOf: 1066ms reduziert

Na gut so weit so gut. Aber lasst es uns diesmal im ES6-Stil richtig machen. Es sieht so cool aus ..! Aber ab sofort ist mir ein Rätsel, wie es sich gegen die leistungsstarke Lut-Lösung verhalten wird. Lassen Sie uns zuerst den Code sehen und ihn dann bewerten.

var myArray = [100, 200, 100, 200, 100, 100, 200, 200, 200, 200],
    reduced = [...myArray.reduce((p,c) => p.set(c,true),new Map()).keys()];
console.log(reduced);

Wow das war kurz ..! Aber wie steht es mit der Aufführung? Es ist wunderschön ... Da das schwere Gewicht des Filters/Index über unsere Schultern gehoben wurde, kann ich ein Array von 1M zufälligen Elementen positiver Ganzzahlen im Bereich von 0..99999 testen, um einen Durchschnitt aus 10 aufeinanderfolgenden Tests zu erhalten. Diesmal kann ich sagen, dass es ein echtes Match ist. Überzeugen Sie sich vom Ergebnis :)

var ranar = [],
     red1 = a => Object.keys(a.reduce((p,c) => (p[c] = true,p),{})),
     red2 = a => reduced = [...a.reduce((p,c) => p.set(c,true),new Map()).keys()],
     avg1 = [],
     avg2 = [],
       ts = 0,
       te = 0,
     res1 = [],
     res2 = [],
     count= 10;
for (var i = 0; i<count; i++){
  ranar = (new Array(1000000).fill(true)).map(e => Math.floor(Math.random()*100000));
  ts = performance.now();
  res1 = red1(ranar);
  te = performance.now();
  avg1.Push(te-ts);
  ts = performance.now();
  res2 = red2(ranar);
  te = performance.now();
  avg2.Push(te-ts);
}

avg1 = avg1.reduce((p,c) => p+c)/count;
avg2 = avg2.reduce((p,c) => p+c)/count;

console.log("reduce & lut took: " + avg1 + "msec");
console.log("map & spread took: " + avg2 + "msec");

Welches würdest du benutzen ..? Na nicht so schnell ...! Lass dich nicht täuschen. Die Karte ist verschoben. Schauen Sie jetzt ... in allen obigen Fällen füllen wir ein Array der Größe n mit Zahlen des Bereichs <n. Ich meine, wir haben ein Array der Größe 100 und wir füllen es mit Zufallszahlen 0..9, so dass es definitiv Duplikate gibt und "fast" definitiv jede Zahl ein Duplikat hat. Wie wäre es, wenn wir das Array in Größe 100 mit Zufallszahlen 0..9999 füllen. Sehen wir uns jetzt Map zu Hause an. Diesmal ist ein Array mit 100.000 Elementen, aber einem Zufallszahlenbereich von 0..100 Millionen. Wir werden 100 aufeinanderfolgende Tests durchführen, um die Ergebnisse zu mitteln. OK, sehen wir uns die Wetten an! <- kein Tippfehler

var ranar = [],
     red1 = a => Object.keys(a.reduce((p,c) => (p[c] = true,p),{})),
     red2 = a => reduced = [...a.reduce((p,c) => p.set(c,true),new Map()).keys()],
     avg1 = [],
     avg2 = [],
       ts = 0,
       te = 0,
     res1 = [],
     res2 = [],
     count= 100;
for (var i = 0; i<count; i++){
  ranar = (new Array(100000).fill(true)).map(e => Math.floor(Math.random()*100000000));
  ts = performance.now();
  res1 = red1(ranar);
  te = performance.now();
  avg1.Push(te-ts);
  ts = performance.now();
  res2 = red2(ranar);
  te = performance.now();
  avg2.Push(te-ts);
}

avg1 = avg1.reduce((p,c) => p+c)/count;
avg2 = avg2.reduce((p,c) => p+c)/count;

console.log("reduce & lut took: " + avg1 + "msec");
console.log("map & spread took: " + avg2 + "msec");

Dies ist das spektakuläre Comeback von Map () ..! Vielleicht können Sie jetzt eine bessere Entscheidung treffen, wenn Sie die Dupes entfernen möchten.

Na gut, wir sind jetzt alle glücklich. Aber die Hauptrolle kommt immer zuletzt mit etwas Applaus. Ich bin sicher, einige von Ihnen fragen sich, was Set-Objekt tun würde. Jetzt, da wir offen für ES6 sind und wissen, dass Map der Gewinner der vorherigen Spiele ist, können wir Map mit Set als Finale vergleichen. Diesmal ein typisches Spiel zwischen Real Madrid und Barcelona ... oder doch? Mal sehen, wer den el classico gewinnt :)

var ranar = [],
     red1 = a => reduced = [...a.reduce((p,c) => p.set(c,true),new Map()).keys()],
     red2 = a => Array.from(new Set(a)),
     avg1 = [],
     avg2 = [],
       ts = 0,
       te = 0,
     res1 = [],
     res2 = [],
     count= 100;
for (var i = 0; i<count; i++){
  ranar = (new Array(100000).fill(true)).map(e => Math.floor(Math.random()*10000000));
  ts = performance.now();
  res1 = red1(ranar);
  te = performance.now();
  avg1.Push(te-ts);
  ts = performance.now();
  res2 = red2(ranar);
  te = performance.now();
  avg2.Push(te-ts);
}

avg1 = avg1.reduce((p,c) => p+c)/count;
avg2 = avg2.reduce((p,c) => p+c)/count;

console.log("map & spread took: " + avg1 + "msec");
console.log("set & A.from took: " + avg2 + "msec");

Wow Mann..! Nun, unerwartet stellte sich heraus, dass es sich überhaupt nicht um einen El Classico handelte. Mehr wie Barcelona FC gegen CA Osasuna :))

17
Redu

Das Folgende ist mehr als 80% schneller als die aufgeführte jQuery-Methode (siehe Tests unten). Es ist eine Antwort von einer ähnlichen Frage vor ein paar Jahren. Wenn ich auf die Person stoße, die es ursprünglich vorgeschlagen hat, werde ich eine Gutschrift veröffentlichen. Reine JS.

var temp = {};
for (var i = 0; i < array.length; i++)
  temp[array[i]] = true;
var r = [];
for (var k in temp)
  r.Push(k);
return r;

Mein Testfallvergleich: http://jsperf.com/remove-duplicate-array-tests

16
Levi

In ECMAScript 6 (auch bekannt als ECMAScript 2015) kann Set zum Herausfiltern von Duplikaten verwendet werden. Dann kann es mit dem spread operator wieder in ein Array konvertiert werden.

var names = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"],
    unique = [...new Set(names)];
14
Oriol

Hier ist eine einfache Antwort auf die Frage.

var names = ["Alex","Tony","James","Suzane", "Marie", "Laurence", "Alex", "Suzane", "Marie", "Marie", "James", "Tony", "Alex"];
var uniqueNames = [];

    for(var i in names){
        if(uniqueNames.indexOf(names[i]) === -1){
            uniqueNames.Push(names[i]);
        }
    }
14
drew7721

Die Top-Antworten haben die Komplexität von O(n²), aber dies kann nur mit O(n) durchgeführt werden, indem ein Objekt als Hash verwendet wird:

function getDistinctArray(arr) {
    var dups = {};
    return arr.filter(function(el) {
        var hash = el.valueOf();
        var isDup = dups[hash];
        dups[hash] = true;
        return !isDup;
    });
}

Dies funktioniert für Zeichenfolgen, Zahlen und Datumsangaben. Wenn Ihr Array Objekte enthält, funktioniert die obige Lösung nicht, da sie beim Erzwingen einer Zeichenfolge alle den Wert "[object Object]" (oder einen ähnlichen Wert) haben und dieser Wert nicht als Nachschlagewert geeignet ist. Sie können eine O(n) -Implementierung für Objekte erhalten, indem Sie ein Flag auf dem Objekt selbst setzen:

function getDistinctObjArray(arr) {
    var distinctArr = arr.filter(function(el) {
        var isDup = el.inArray;
        el.inArray = true;
        return !isDup;
    });
    distinctArr.forEach(function(el) {
        delete el.inArray;
    });
    return distinctArr;
}

2019 edit: Moderne Versionen von JavaScript machen dies zu einem viel einfacheren Problem. Die Verwendung von Set funktioniert unabhängig davon, ob Ihr Array Objekte, Zeichenfolgen, Zahlen oder einen anderen Typ enthält.

function getDistinctArray(arr) {
    return [...new Set(arr)];
}

Die Implementierung ist so einfach, dass die Definition einer Funktion nicht mehr gewährleistet ist.

10
gilly3

Eine einfache, aber effektive Methode ist die Verwendung der filter -Methode in Kombination mit dem Filter function(value, index){ return this.indexOf(value) == index }.

Codebeispiel:

var data = [2,3,4,5,5,4];
var filter = function(value, index){ return this.indexOf(value) == index };
var filteredData = data.filter(filter, data );

document.body.innerHTML = '<pre>' + JSON.stringify(filteredData, null, '\t') +  '</pre>';

Siehe auch this Fiddle .

10
John Slegers

hier ist die einfache Methode ohne spezielle Bibliotheken Sonderfunktion,

name_list = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];
get_uniq = name_list.filter(function(val,ind) { return name_list.indexOf(val) == ind; })

console.log("Original name list:"+name_list.length, name_list)
console.log("\n Unique name list:"+get_uniq.length, get_uniq)

enter image description here

Die Optionen sind also:

let a = [11,22,11,22];
let b = []


b = [ ...new Set(a) ];     
// b = [11, 22]

b = Array.from( new Set(a))   
// b = [11, 22]

b = a.filter((val,i)=>{
  return a.indexOf(val)==i
})                        
// b = [11, 22]
9
ofir_aghai

Abgesehen davon, dass es sich um eine einfachere und knappere Lösung handelt als die aktuellen Antworten (abzüglich der zukunftsweisenden ES6-Lösungen), habe ich dies getestet und es war auch viel schneller:

var uniqueArray = dupeArray.filter(function(item, i, self){
  return self.lastIndexOf(item) == i;
});

Eine Einschränkung: Array.lastIndexOf () wurde in IE9 hinzugefügt. Wenn Sie also einen niedrigeren Wert als diesen benötigen, müssen Sie an einer anderen Stelle nachsehen.

8
csuwldcat

Generischer Funktionsansatz

Hier ist ein allgemeiner und streng funktionaler Ansatz mit ES2015:

// small, reusable auxiliary functions

const apply = f => a => f(a);

const flip = f => b => a => f(a) (b);

const uncurry = f => (a, b) => f(a) (b);

const Push = x => xs => (xs.Push(x), xs);

const foldl = f => acc => xs => xs.reduce(uncurry(f), acc);

const some = f => xs => xs.some(apply(f));


// the actual de-duplicate function

const uniqueBy = f => foldl(
   acc => x => some(f(x)) (acc)
    ? acc
    : Push(x) (acc)
 ) ([]);


// comparators

const eq = y => x => x === y;

// string equality case insensitive :D
const seqCI = y => x => x.toLowerCase() === y.toLowerCase();


// mock data

const xs = [1,2,3,1,2,3,4];

const ys = ["a", "b", "c", "A", "B", "C", "D"];


console.log( uniqueBy(eq) (xs) );

console.log( uniqueBy(seqCI) (ys) );

Wir können unique leicht von unqiueBy ableiten oder die schnellere Implementierung unter Verwendung von Sets verwenden:

const unqiue = uniqueBy(eq);

// const unique = xs => Array.from(new Set(xs));

Vorteile dieses Ansatzes:

  • generische Lösung durch Verwendung einer separaten Komparatorfunktion
  • deklarative und prägnante Umsetzung
  • wiederverwendung anderer kleiner generischer Funktionen

Leistungsüberlegungen

uniqueBy ist nicht so schnell wie eine zwingende Implementierung mit Schleifen, aber aufgrund seiner Großzügigkeit viel ausdrucksvoller.

Wenn Sie uniqueBy als Ursache für einen konkreten Leistungsabfall in Ihrer App identifizieren, ersetzen Sie ihn durch optimierten Code. Das heißt, schreiben Sie Ihren Code zunächst funktional und deklarativ. Versuchen Sie anschließend, sofern Leistungsprobleme auftreten, den Code an den Stellen zu optimieren, die die Ursache des Problems sind.

Speicherverbrauch und Garbage Collection

uniqueBy verwendet Mutationen (Push(x) (acc)), die in seinem Körper verborgen sind. Der Akku wird wiederverwendet, anstatt nach jeder Iteration weggeworfen zu werden. Dies reduziert den Speicherverbrauch und den GC-Druck. Da dieser Nebeneffekt in der Funktion enthalten ist, bleibt alles Äußere rein.

7
user6445533

Hier ist sehr einfach zu verstehen und überall (auch in PhotoshopScript) Code zu arbeiten. Prüfen Sie!

var peoplenames = new Array("Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl");

peoplenames = unique(peoplenames);
alert(peoplenames);

function unique(array){
    var len = array.length;
    for(var i = 0; i < len; i++) for(var j = i + 1; j < len; j++) 
        if(array[j] == array[i]){
            array.splice(j,1);
            j--;
            len--;
        }
    return array;
}

//*result* peoplenames == ["Mike","Matt","Nancy","Adam","Jenny","Carl"]
6
bodich
for (i=0; i<originalArray.length; i++) {  
    if (!newArray.includes(originalArray[i])) {
        newArray.Push(originalArray[i]); 
    }
}
5
MBJH

Eine kleine Modifikation der hervorragenden Antwort von thg435 zur Verwendung eines benutzerdefinierten Komparators:

function contains(array, obj) {
    for (var i = 0; i < array.length; i++) {
        if (isEqual(array[i], obj)) return true;
    }
    return false;
}
//comparator
function isEqual(obj1, obj2) {
    if (obj1.name == obj2.name) return true;
    return false;
}
function removeDuplicates(ary) {
    var arr = [];
    return ary.filter(function(x) {
        return !contains(arr, x) && arr.Push(x);
    });
}
4
vin_schumi
$(document).ready(function() {

    var arr1=["dog","dog","fish","cat","cat","fish","Apple","orange"]

    var arr2=["cat","fish","mango","Apple"]

    var uniquevalue=[];
    var seconduniquevalue=[];
    var finalarray=[];

    $.each(arr1,function(key,value){

       if($.inArray (value,uniquevalue) === -1)
       {
           uniquevalue.Push(value)

       }

    });

     $.each(arr2,function(key,value){

       if($.inArray (value,seconduniquevalue) === -1)
       {
           seconduniquevalue.Push(value)

       }

    });

    $.each(uniquevalue,function(ikey,ivalue){

        $.each(seconduniquevalue,function(ukey,uvalue){

            if( ivalue == uvalue)

            {
                finalarray.Push(ivalue);
            }   

        });

    });
    alert(finalarray);
});
4
user3840178

Wenn Sie zufällig verwendet haben

D3.js

Du könntest es tun

d3.set(["foo", "bar", "foo", "baz"]).values() ==> ["foo", "bar", "baz"]

https://github.com/mbostock/d3/wiki/Arrays#set_values

4
jetpackdata.com

Dies ist wahrscheinlich eine der schnellsten Methoden, um Duplikate dauerhaft aus einem Array zu entfernen. 10x schneller als die meisten Funktionen hier. & 78x schneller auf Safari

function toUnique(a,b,c){               //array,placeholder,placeholder
 b=a.length;while(c=--b)while(c--)a[b]!==a[c]||a.splice(c,1)
}
  1. Test: http://jsperf.com/wg
  2. Demo: http://jsfiddle.net/46S7g/
  3. Mehr: https://stackoverflow.com/a/25082874/24507

wenn Sie den obigen Code nicht lesen können, lesen Sie ein Javascript-Buch oder hier einige Erklärungen zu kürzerem Code. https://stackoverflow.com/a/21353032/24507

3
cocco

Obwohl die ES6-Lösung die beste ist, bin ich verblüfft, wie niemand die folgende Lösung gezeigt hat:

function removeDuplicates(arr){
    o={}
    arr.forEach(function(e){
        o[e]=true
    })
    return Object.keys(o)
}

Beachten Sie hierbei, dass Objekte eindeutige Schlüssel haben MÜSSEN. Wir nutzen dies aus, um alle Duplikate zu entfernen. Ich hätte gedacht, dies wäre die schnellste Lösung (vor ES6).

Beachten Sie jedoch, dass dies auch das Array sortiert.

3
Sancarn

https://jsfiddle.net/2w0k5tz8/

function remove_duplicates(array_){
    var ret_array = new Array();
    for (var a = array_.length - 1; a >= 0; a--) {
        for (var b = array_.length - 1; b >= 0; b--) {
            if(array_[a] == array_[b] && a != b){
                delete array_[b];
            }
        };
        if(array_[a] != undefined)
            ret_array.Push(array_[a]);
    };
    return ret_array;
}

console.log(remove_duplicates(Array(1,1,1,2,2,2,3,3,3)));

Durchlaufen, Entfernen von Duplikaten und Erstellen eines Klonarrayplatzhalters, da der Arrayindex nicht aktualisiert wird.

Schleife rückwärts für eine bessere Leistung (Ihre Schleife muss die Länge Ihres Arrays nicht ständig überprüfen)

3
THE AMAZING

Dies war nur eine andere Lösung, aber anders als die anderen.

function diffArray(arr1, arr2) {
  var newArr = arr1.concat(arr2);
  newArr.sort();
  var finalArr = [];
  for(var i = 0;i<newArr.length;i++) {
   if(!(newArr[i] === newArr[i+1] || newArr[i] === newArr[i-1])) {
     finalArr.Push(newArr[i]);
   } 
  }
  return finalArr;
}
3
Isaac Pak

Für alle, die Arrays mit doppelten Elementen zu einem einzigen Array zusammenfassen möchten:

function flattenUniq(arrays) {
  var args = Array.prototype.slice.call(arguments);

  var array = [].concat.apply([], args)

  var result = array.reduce(function(prev, curr){
    if (prev.indexOf(curr) < 0) prev.Push(curr);
    return prev;
  },[]);

  return result;
}
2
cjjenkinson

Die einfachste Möglichkeit, ein Duplikat zu entfernen, besteht darin, eine for-Schleife durchzuführen, die nicht identischen Elemente zu vergleichen und sie in das neue Array zu verschieben

 var array = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"];

 var removeDublicate = function(arr){
 var result = []
 var sort_arr = arr.sort() //=> optional
 for (var i = 0; i < arr.length; i++) {
        if(arr[ i + 1] !== arr[i] ){
            result.Push(arr[i])
        }
 };
  return result
}  
console.log(removeDublicate(array))
==>  ["Adam", "Carl", "Jenny", "Matt", "Mike", "Nancy"]
1
user3449311

Nested-Loop-Methode zum Entfernen von Duplikaten im Array und zum Beibehalten der ursprünglichen Reihenfolge der Elemente.

var array = [1, 3, 2, 1, [5], 2, [4]]; // INPUT

var element = 0;
var decrement = array.length - 1;
while(element < array.length) {
  while(element < decrement) {
    if (array[element] === array[decrement]) {
      array.splice(decrement, 1);
      decrement--;
    } else {
      decrement--;
    }
  }
  decrement = array.length - 1;
  element++;
}

console.log(array);// [1, 3, 2, [5], [4]]

Erläuterung: Die innere Schleife vergleicht das erste Element des Arrays mit allen anderen Elementen, beginnend mit dem Element am höchsten Index. Beim Verringern in Richtung des ersten Elements wird ein Duplikat aus dem Array herausgespleißt.

Wenn die innere Schleife beendet ist, erhöht sich die äußere Schleife zum Vergleich auf das nächste Element und setzt die neue Länge des Arrays zurück.

1
y2knoproblem

Eine andere Methode, ohne viel Code zu schreiben, ist die ES5-Methode Object.keys:

var arrayWithDuplicates = ['a','b','c','d','a','c'],
    deduper = {};
arrayWithDuplicates.forEach(function (item) {
    deduper[item] = null;
});
var dedupedArray = Object.keys(deduper); // ["a", "b", "c", "d"]

in einer Funktion extrahiert

function removeDuplicates (arr) {
    var deduper = {}
    arr.forEach(function (item) {
        deduper[item] = null;
    });
    return Object.keys(deduper);
}
1
Willem de Wit

Das folgende Skript gibt ein neues Array zurück, das nur eindeutige Werte enthält. Es funktioniert mit Zeichenketten und Zahlen. Keine zusätzlichen Bibliotheken erforderlich, nur Vanilla JS.

Browser-Unterstützung:

Feature Chrome  Firefox (Gecko)     Internet Explorer   Opera   Safari
Basic support   (Yes)   1.5 (1.8)   9                   (Yes)   (Yes)

https://jsfiddle.net/fzmcgcxv/3/

var duplicates = ["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl","Mike","Mike","Nancy","Carl"]; 
var unique = duplicates.filter(function(elem, pos) {
    return duplicates.indexOf(elem) == pos;
  }); 
alert(unique);
1
GibboK
function arrayDuplicateRemove(arr){
    var c = 0;
    var tempArray = [];
    console.log(arr);
    arr.sort();
    console.log(arr);
    for (var i = arr.length - 1; i >= 0; i--) {
        if(arr[i] != tempArray[c-1]){
            tempArray.Push(arr[i])
            c++;
        }
    };
    console.log(tempArray);
    tempArray.sort();
    console.log(tempArray);
}
1
M.A.K. Ripon
const numbers = [1, 1, 2, 3, 4, 4];

function unique(array) {
  return array.reduce((a,b) => {
    let isIn = a.find(element => {
        return element === b;
    });
    if(!isIn){
      a.Push(b);
    }
    return a;
  },[]);
}

let ret = unique(numbers); // [1, 2, 3, 4]

den weg mit reduzieren und finden.

1
gnujoow

aLinks ist ein einfaches JavaScript-Array-Objekt. Wenn vor den Elementen, für die der Index anzeigt, dass ein doppelter Datensatz gelöscht wurde, ein Element vorhanden ist. Ich wiederhole, um alle Duplikate abzubrechen. Ein Durchgangsarray löscht mehr Datensätze.

var srt_ = 0;
var pos_ = 0;
do {
    var srt_ = 0;
    for (var i in aLinks) {
        pos_ = aLinks.indexOf(aLinks[i].valueOf(), 0);
        if (pos_ < i) {
            delete aLinks[i];
            srt_++;
        }
    }
} while (srt_ != 0);
0
stanislavs

Schnell und einfach mit lodash - var array = ["12346","12347","12348","12349","12349"]; console.log(_.uniqWith(array,_.isEqual));

0
Anand Somani
var lines = ["Mike", "Matt", "Nancy", "Adam", "Jenny", "Nancy", "Carl"];
var uniqueNames = [];

for(var i=0;i<lines.length;i++)
{
    if(uniqueNames.indexOf(lines[i]) == -1)
        uniqueNames.Push(lines[i]);
}
if(uniqueNames.indexOf(uniqueNames[uniqueNames.length-1])!= -1)
    uniqueNames.pop();
for(var i=0;i<uniqueNames.length;i++)
{
    document.write(uniqueNames[i]);
      document.write("<br/>");
}
0
Vishnu
function removeDuplicates(inputArray) {
            var outputArray=new Array();

            if(inputArray.length>0){
                jQuery.each(inputArray, function(index, value) {
                    if(jQuery.inArray(value, outputArray) == -1){
                        outputArray.Push(value);
                    }
                });
            }           
            return outputArray;
        }
0
realmag777
function removeDuplicates (array) {
  var sorted = array.slice().sort()
  var result = []

  sorted.forEach((item, index) => {
    if (sorted[index + 1] !== item) {
      result.Push(item)
    }
  })
  return result
}
0
Matt MacPherson

Vanilla JS-Lösungen mit der Komplexität von O(n) (für dieses Problem am schnellsten möglich). Ändern Sie die hashFunction, um die Objekte (z. B. 1 und "1") bei Bedarf zu unterscheiden. Die erste Lösung vermeidet versteckte Schleifen (die in von Array bereitgestellten Funktionen üblich sind).

var dedupe = function(a) 
{
    var hash={},ret=[];
    var hashFunction = function(v) { return ""+v; };
    var collect = function(h)
    {
        if(hash.hasOwnProperty(hashFunction(h)) == false) // O(1)
        {
            hash[hashFunction(h)]=1;
            ret.Push(h); // should be O(1) for Arrays
            return;
        }
    };

    for(var i=0; i<a.length; i++) // this is a loop: O(n)
        collect(a[i]);
    //OR: a.forEach(collect); // this is a loop: O(n)

    return ret;
}

var dedupe = function(a) 
{
    var hash={};
    var isdupe = function(h)
    {
        if(hash.hasOwnProperty(h) == false) // O(1)
        {
            hash[h]=1;
            return true;
        }

        return false;
    };

    return a.filter(isdupe); // this is a loop: O(n)
}
0
cat

Ich weiß, ich bin ein bisschen spät dran, aber hier ist eine andere Option mit jinqJs

Siehe Geige

var result = jinqJs().from(["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]).distinct().select();
0
NYTom

Der einfachste Weg, um doppelte Zeichenfolgen zu entfernen, besteht darin, ein assoziatives Array zu verwenden und dann über das assoziative Array zu iterieren, um die Liste/das Array wiederherzustellen.

Wie unten:

var toHash = [];
var toList = [];

// add from ur data list to hash
$(data.pointsToList).each(function(index, Element) {
    toHash[Element.nameTo]= Element.nameTo;
});

// now convert hash to array
// don't forget the "hasownproperty" else u will get random results 
for (var key in toHash)  {
    if (toHash.hasOwnProperty(key)) { 
      toList.Push(toHash[key]);
   }
}

Voila, jetzt sind Duplikate weg!

0
nondescript

Wenn Sie nicht die gesamte Bibliothek einschließen möchten, können Sie mit dieser Option eine Methode hinzufügen, die von jedem Array verwendet werden kann:

Array.prototype.uniq = function uniq() {
  return this.reduce(function(accum, cur) { 
    if (accum.indexOf(cur) === -1) accum.Push(cur); 
    return accum; 
  }, [] );
}

["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"].uniq()
0
Jonah

Hier ist ein anderer Ansatz mit jQuery,

function uniqueArray(array){
  if ($.isArray(array)){
    var dupes = {}; var len, i;
    for (i=0,len=array.length;i<len;i++){
      var test = array[i].toString();
      if (dupes[test]) { array.splice(i,1); len--; i--; } else { dupes[test] = true; }
    }
  } 
  else {
    if (window.console) console.log('Not passing an array to uniqueArray, returning whatever you sent it - not filtered!');
      return(array);
  }
  return(array);
}

Verfasser: William Skidmore

0
Mathankumar
var duplicates = function(arr){
     var sorted = arr.sort();
   var dup = [];
   for(var i=0; i<sorted.length; i++){
        var rest  = sorted.slice(i+1); //slice the rest of array
       if(rest.indexOf(sorted[i]) > -1){//do indexOf
            if(dup.indexOf(sorted[i]) == -1)    
         dup.Push(sorted[i]);//store it in another arr
      }
   }
   console.log(dup);
}

duplicates(["Mike","Matt","Nancy","Adam","Jenny","Nancy","Carl"]);
0
neelmeg
var uniqueCompnies = function(companyArray) {
    var arrayUniqueCompnies = [],
        found, x, y;

    for (x = 0; x < companyArray.length; x++) {
        found = undefined;
        for (y = 0; y < arrayUniqueCompnies.length; y++) {
            if (companyArray[x] === arrayUniqueCompnies[y]) {
                found = true;
                break;
            }
        }

        if ( ! found) {
            arrayUniqueCompnies.Push(companyArray[x]);
        }
    }

    return arrayUniqueCompnies;
}

var arr = [
    "Adobe Systems Incorporated",
    "IBX",
    "IBX",
    "BlackRock, Inc.",
    "BlackRock, Inc.",
];
0

Diese Lösung verwendet ein neues Array und eine Objektzuordnung innerhalb der Funktion. Es durchläuft lediglich das ursprüngliche Array und fügt jede Ganzzahl in die Objektzuordnung ein

`if (!unique[int])`

fängt dies ab, weil es für das Objekt bereits eine Schlüsseleigenschaft mit der gleichen Nummer gibt. Überspringen Sie also diese Nummer und lassen Sie nicht zu, dass sie in das neue Array verschoben wird.

    function removeRepeats(ints) {
      var unique = {}
      var newInts = []

      for (var i = 0; i < ints.length; i++) {
        var int = ints[i]

        if (!unique[int]) {
          unique[int] = 1
          newInts.Push(int)
        }
      }
      return newInts
    }

    var example = [100, 100, 100, 100, 500]
    console.log(removeRepeats(example)) // prints [100, 500]
0
Dan Zuzevich

Wenn Sie das Array selbst erstellen, können Sie sich eine Schleife und den zusätzlichen eindeutigen Filter sparen, indem Sie die Überprüfung beim Einfügen der Daten durchführen.

var values = [];
$.each(collection, function() {
    var x = $(this).value;
    if (!$.inArray(x, values)) {
        values.Push(x);
    }
});
0