Ich habe eine Reihe von Zahlen, die ich sicherstellen muss, dass sie eindeutig sind. Ich habe das Code-Snippet unten im Internet gefunden und es funktioniert großartig, bis das Array eine Null enthält. Ich habe dieses andere Skript gefunden hier auf Stack Overflow gefunden, das fast genau so aussieht, aber nicht fehlschlägt.

Kann mir jemand helfen, festzustellen, wo das Prototyp-Skript falsch läuft, um mir beim Lernen zu helfen?

Array.prototype.getUnique = function() {
 var o = {}, a = [], i, e;
 for (i = 0; e = this[i]; i++) {o[e] = 1};
 for (e in o) {a.push (e)};
 return a;
}

Weitere Antworten von doppelten Fragen:

• Entfernen Sie doppelte Werte aus dem JS-Array

Ähnliche Frage:

• Ruft alle nicht eindeutigen Werte (dh Duplikat / mehr als ein Vorkommen) in einem Array ab

Mit JavaScript 1.6 / ECMAScript 5 können Sie die native filterMethode eines Arrays folgendermaßen verwenden, um ein Array mit eindeutigen Werten abzurufen:

function onlyUnique(value, index, self) { 
    return self.indexOf(value) === index;
}

// usage example:
var a = ['a', 1, 'a', 2, '1'];
var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

Die native Methode filterdurchläuft das Array und hinterlässt nur die Einträge, die die angegebene Rückruffunktion bestehen onlyUnique.

onlyUniqueprüft, ob der angegebene Wert der erste ist, der auftritt. Wenn nicht, muss es ein Duplikat sein und wird nicht kopiert.

Diese Lösung funktioniert ohne zusätzliche Bibliothek wie jQuery oder prototype.js.

Es funktioniert auch für Arrays mit gemischten Werttypen.

Für alten Browser (<ie9), das nicht unterstützt die nativen Methoden filterund indexOfSie können Workarounds in der MDN - Dokumentation finden Filter und indexOf .

Wenn Sie das letzte Vorkommen eines Werts beibehalten möchten, ersetzen Sie ihn einfach indexOfdurchlastIndexOf .

Mit ES6 könnte dies verkürzt werden:

// usage example:
var myArray = ['a', 1, 'a', 2, '1'];
var unique = myArray.filter((v, i, a) => a.indexOf(v) === i); 

// unique is ['a', 1, 2, '1']

Vielen Dank an Camilo Martin für den Hinweis im Kommentar.

ES6 verfügt über ein natives Objekt Setzum Speichern eindeutiger Werte. Um ein Array mit eindeutigen Werten zu erhalten, können Sie jetzt Folgendes tun:

var myArray = ['a', 1, 'a', 2, '1'];

let unique = [...new Set(myArray)]; 

// unique is ['a', 1, 2, '1']

Der Konstruktor von Setnimmt ein iterierbares Objekt wie Array, und der Spread-Operator ...wandelt die Menge wieder in ein Array um. Vielen Dank an Lukas Liese für den Hinweis im Kommentar.

Aktualisierte Antwort für ES6 / ES2015 : Mit dem Set lautet die einzeilige Lösung:

var items = [4,5,4,6,3,4,5,2,23,1,4,4,4]
var uniqueItems = Array.from(new Set(items))

Welches kehrt zurück

[4, 5, 6, 3, 2, 23, 1]

Wie von le_m vorgeschlagen, kann dies auch mit dem Spread-Operator wie z

var uniqueItems = [...new Set(items)]

Mir ist klar, dass diese Frage bereits mehr als 30 Antworten hat. Aber ich habe zuerst alle vorhandenen Antworten durchgelesen und meine eigenen Nachforschungen angestellt.

Ich habe alle Antworten auf 4 mögliche Lösungen aufgeteilt:

1. Verwenden Sie die neue ES6-Funktion: [...new Set( [1, 1, 2] )];
2. Verwenden Sie Objekt { }, um Duplikate zu vermeiden
3. Verwenden Sie das Helper-Array [ ]
4. Verwenden filter + indexOf

Hier sind Beispielcodes in den Antworten:

Verwenden Sie die neue ES6-Funktion: [...new Set( [1, 1, 2] )];

function uniqueArray0(array) {
  var result = Array.from(new Set(array));
  return result    
}

Verwenden Sie Objekt { }, um Duplikate zu vermeiden

function uniqueArray1( ar ) {
  var j = {};

  ar.forEach( function(v) {
    j[v+ '::' + typeof v] = v;
  });

  return Object.keys(j).map(function(v){
    return j[v];
  });
} 

Verwenden Sie das Helper-Array [ ]

function uniqueArray2(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

Verwenden filter + indexOf

function uniqueArray3(a) {
  function onlyUnique(value, index, self) { 
      return self.indexOf(value) === index;
  }

  // usage
  var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

  return unique;
}

Und ich habe mich gefragt, welches schneller ist. Ich habe ein Beispiel für Google Sheet erstellt , um Funktionen zu testen. Hinweis: ECMA 6 ist in Google Sheets nicht verfügbar, daher kann ich es nicht testen.

Hier ist das Ergebnis von Tests:

Ich habe erwartet, dass Code mit Objekt { }gewinnt, weil er Hash verwendet. Daher bin ich froh, dass Tests die besten Ergebnisse für diesen Algorithmus in Chrome und IE gezeigt haben. Danke an @rab für den Code .

Sie können auch underscore.js verwenden .

console.log(_.uniq([1, 2, 1, 3, 1, 4]));

<script src="http://underscorejs.org/underscore-min.js"></script>

welches zurückkehren wird:

[1, 2, 3, 4]

Ein Liner, reines JavaScript

Mit ES6-Syntax

list = list.filter((x, i, a) => a.indexOf(x) == i)

x --> item in array
i --> index of item
a --> array reference, (in this case "list")

Mit ES5-Syntax

list = list.filter(function (x, i, a) { 
    return a.indexOf(x) == i; 
});

Browserkompatibilität : IE9 +

Ich habe seitdem eine nette Methode gefunden, die jQuery verwendet

arr = $.grep(arr, function(v, k){
    return $.inArray(v ,arr) === k;
});

Hinweis: Dieser Code wurde aus Paul Irishs Entenstanzpfosten gezogen - ich habe vergessen, eine Gutschrift zu geben: P.

Kürzeste Lösung mit ES6: [...new Set( [1, 1, 2] )];

Oder wenn Sie den Array-Prototyp ändern möchten (wie in der ursprünglichen Frage):

Array.prototype.getUnique = function() {
    return [...new Set( [this] )];
};

EcmaScript 6 ist derzeit (August 2015) nur teilweise in modernen Browsern implementiert , Babel jedoch ist sehr beliebt geworden, um ES6 (und sogar ES7) zurück auf ES5 zu übertragen. Auf diese Weise können Sie heute ES6-Code schreiben!

Wenn Sie sich fragen, was das ...bedeutet, wird es als Spread-Operator bezeichnet . Von MDN : «Mit dem Spread-Operator kann ein Ausdruck an Stellen erweitert werden, an denen mehrere Argumente (für Funktionsaufrufe) oder mehrere Elemente (für Array-Literale) erwartet werden». Da ein Set iterierbar ist (und nur eindeutige Werte haben kann), erweitert der Spread-Operator das Set, um das Array zu füllen.

Ressourcen zum Lernen von ES6:

• Erkundung von ES6 von Dr. Axel Rauschmayer
• Suchen Sie in den wöchentlichen JS-Newslettern nach „ES6“
• ES6 ausführliche Artikel aus dem Mozilla Hacks-Blog

Einfachste Lösung:

var arr = [1, 3, 4, 1, 2, 1, 3, 3, 4, 1];
console.log([...new Set(arr)]);

Oder:

var arr = [1, 3, 4, 1, 2, 1, 3, 3, 4, 1];
console.log(Array.from(new Set(arr)));

Der einfachste und schnellste (in Chrome) Weg, dies zu tun:

Array.prototype.unique = function() {
    var a = [];
    for (var i=0, l=this.length; i<l; i++)
        if (a.indexOf(this[i]) === -1)
            a.push(this[i]);
    return a;
}

Durchläuft einfach jedes Element im Array, testet, ob dieses Element bereits in der Liste enthalten ist, und drückt es auf das Array, das zurückgegeben wird, wenn dies nicht der Fall ist.

Laut jsPerf ist diese Funktion die schnellste, die ich jemals finden konnte - Sie können jedoch auch Ihre eigene hinzufügen.

Die Nicht-Prototyp-Version:

function uniques(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

Sortierung

Wenn Sie das Array auch sortieren müssen, ist Folgendes am schnellsten:

Array.prototype.sortUnique = function() {
    this.sort();
    var last_i;
    for (var i=0;i<this.length;i++)
        if ((last_i = this.lastIndexOf(this[i])) !== i)
            this.splice(i+1, last_i-i);
    return this;
}

oder Nicht-Prototyp:

function sortUnique(arr) {
    arr.sort();
    var last_i;
    for (var i=0;i<arr.length;i++)
        if ((last_i = arr.lastIndexOf(arr[i])) !== i)
            arr.splice(i+1, last_i-i);
    return arr;
}

Dies ist in den meisten Nicht-Chrome-Browsern auch schneller als die oben beschriebene Methode .

NUR LEISTUNG! Dieser Code ist wahrscheinlich 10x schneller als alle Codes hier * funktioniert in allen Browsern und hat auch die geringste Auswirkung auf den Speicher .... und mehr

Wenn Sie das alte Array nicht wiederverwenden müssen, müssen Sie übrigens die erforderlichen anderen Vorgänge ausführen, bevor Sie es in ein einzigartiges Array konvertieren. Dies ist wahrscheinlich der schnellste Weg, um dies zu tun, auch sehr kurz.

var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];

dann können Sie dies versuchen

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 1];

function toUnique(a, b, c) { //array,placeholder,placeholder
  b = a.length;
  while (c = --b)
    while (c--) a[b] !== a[c] || a.splice(c, 1);
  return a // not needed ;)
}
console.log(toUnique(array));
//[3, 4, 5, 6, 7, 8, 9, 0, 2, 1]

Ich habe mir diese Funktion ausgedacht, als ich diesen Artikel gelesen habe ...

http://www.shamasis.net/2009/09/fast-algorithm-to-find-unique-items-in-javascript-array/

Ich mag die for-Schleife nicht. Es hat zu viele Parameter. Ich mag die while-- Schleife. while ist die schnellste Schleife in allen Browsern außer der, die wir alle so sehr mögen ... Chrome.

Trotzdem habe ich die erste Funktion geschrieben, die while verwendet. Und ja, sie ist etwas schneller als die im Artikel gefundene Funktion. Aber nicht genug.unique2()

nächster schritt moderne js verwenden. Object.keys Ich habe die andere for-Schleife durch die Object.keys von js1.7 ersetzt ... etwas schneller und kürzer (in Chrome 2x schneller);). Nicht genug!. unique3().

Zu diesem Zeitpunkt dachte ich darüber nach, was ich wirklich in MEINER einzigartigen Funktion brauche. Ich brauche das alte Array nicht, ich möchte eine schnelle Funktion. Also habe ich 2 while-Schleifen + Spleißen verwendet.unique4()

Es ist nutzlos zu sagen, dass ich beeindruckt war.

Chrom: Die üblichen 150.000 Operationen pro Sekunde stiegen auf 1.800.000 Operationen pro Sekunde.

dh: 80.000 op / s gegenüber 3.500.000 op / s

ios: 18.000 op / s vs 170.000 op / s

Safari: 80.000 op / s vs 6.000.000 op / s

Beweis http://jsperf.com/wgu oder besser console.time ... microtime ... was auch immer verwenden

unique5() soll Ihnen nur zeigen, was passiert, wenn Sie das alte Array behalten möchten.

Verwenden Sie nicht, Array.prototypewenn Sie nicht wissen, was Sie tun. Ich habe gerade viel kopiert und vergangen. Verwenden Object.defineProperty(Array.prototype,...,writable:false,enumerable:false})Sie diese Option, wenn Sie einen nativen Prototyp erstellen möchten. Beispiel: https://stackoverflow.com/a/20463021/2450730

Demo http://jsfiddle.net/46S7g/

HINWEIS: Ihr altes Array wird nach diesem Vorgang zerstört / wird einzigartig.

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

Einige verwenden indexOf ... nicht ... http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

für leere Arrays

!array.length||toUnique(array); 

Viele der Antworten hier sind für Anfänger möglicherweise nicht hilfreich. Wenn es schwierig ist, ein Array zu de-dupen, wissen sie dann wirklich etwas über die Prototypenkette oder sogar über jQuery?

In modernen Browsern besteht eine saubere und einfache Lösung darin, Daten in einem Set zu speichern , das als Liste eindeutiger Werte konzipiert ist.

const cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
const uniqueCars = Array.from(new Set(cars));

Dies Array.fromist nützlich, um das Set wieder in ein Array zu konvertieren, damit Sie einfachen Zugriff auf alle fantastischen Methoden (Funktionen) von Arrays haben. Es gibt auch andere Möglichkeiten , dasselbe zu tun. Möglicherweise benötigen Sie dies jedoch überhaupt nicht Array.from, da Sets zahlreiche nützliche Funktionen wie forEach enthalten .

Wenn Sie den alten Internet Explorer unterstützen müssen und Set daher nicht verwenden können, besteht eine einfache Methode darin, Elemente in ein neues Array zu kopieren, während Sie zuvor prüfen, ob sie sich bereits im neuen Array befinden.

// Create a list of cars, with duplicates.
var cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
// Create a list of unique cars, to put a car in if we haven't already.
var uniqueCars = [];

// Go through each car, one at a time.
cars.forEach(function (car) {
    // The code within the following block runs only if the
    // current car does NOT exist in the uniqueCars list
    // - a.k.a. prevent duplicates
    if (uniqueCars.indexOf(car) === -1) {
        // Since we now know we haven't seen this car before,
        // copy it to the end of the uniqueCars list.
        uniqueCars.push(car);
    }
});

Um dies sofort wiederverwendbar zu machen, fügen wir es in eine Funktion ein.

function deduplicate(data) {
    if (data.length > 0) {
        var result = [];

        data.forEach(function (elem) {
            if (result.indexOf(elem) === -1) {
                result.push(elem);
            }
        });

        return result;
    }
}

Um die Duplikate loszuwerden, würden wir dies jetzt tun.

var uniqueCars = deduplicate(cars);

Der deduplicate(cars)Teil wird zu dem, was wir als Ergebnis bezeichnet haben das wenn die Funktion abgeschlossen ist.

Übergeben Sie einfach den Namen eines beliebigen Arrays.

["Defects", "Total", "Days", "City", "Defects"].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);

[0,1,2,0,3,2,1,5].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);

Wir können dies mit ES6-Sets tun:

var duplicatedArray = [1, 2, 3, 4, 5, 1, 1, 1, 2, 3, 4];
var uniqueArray = Array.from(new Set(duplicatedArray));

console.log(uniqueArray);

// Die Ausgabe wird sein

uniqueArray = [1,2,3,4,5];

Dieser Prototyp getUniqueist nicht ganz korrekt, denn wenn ich ein Array wie das folgende habe: ["1",1,2,3,4,1,"foo"]Es wird zurückgegeben ["1","2","3","4"]und "1"ist ein String und 1eine Ganzzahl. Sie sind anders.

Hier ist eine richtige Lösung:

Array.prototype.unique = function(a){
    return function(){ return this.filter(a) }
}(function(a,b,c){ return c.indexOf(a,b+1) < 0 });

mit:

var foo;
foo = ["1",1,2,3,4,1,"foo"];
foo.unique();

Das obige wird produzieren ["1",2,3,4,1,"foo"].

Ohne Array.prototype zu erweitern (es wird als schlechte Praxis bezeichnet) oder jquery / underscore zu verwenden, können Sie filterdas Array einfach erweitern .

Durch Beibehalten des letzten Auftretens:

    function arrayLastUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps last occurrence
            return c.indexOf(a, b + 1) < 0;
        });
    },

oder erstes Auftreten:

    function arrayFirstUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps first occurrence
            return c.indexOf(a) === b;
        });
    },

Nun, es ist nur Javascript ECMAScript 5+, was nur IE9 + bedeutet, aber es ist gut für eine Entwicklung in nativem HTML / JS (Windows Store App, Firefox OS, Sencha, Phonegap, Titan, ...).

Magie

a.filter(e=>!(t[e]=e in t)) 

O (n) Leistung ; Wir gehen davon aus, dass sich Ihr Array in aund befindet t={}. Erklärung hier (+ Jeppe Impr.)

let t={}, unique= a=> a.filter(e=>!(t[e]=e in t));

// "stand-alone" version working with global t:
// a1.filter((t={},e=>!(t[e]=e in t)));

// Test data
let a1 = [5,6,0,4,9,2,3,5,0,3,4,1,5,4,9];
let a2 = [[2, 17], [2, 17], [2, 17], [1, 12], [5, 9], [1, 12], [6, 2], [1, 12]];
let a3 = ['Mike', 'Adam','Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl'];

// Results
console.log(JSON.stringify( unique(a1) ))
console.log(JSON.stringify( unique(a2) ))
console.log(JSON.stringify( unique(a3) ))

[...new Set(duplicates)]

Dies ist die einfachste und wird in MDN-Webdokumenten referenziert .

const numbers = [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5]
console.log([...new Set(numbers)]) // [2, 3, 4, 5, 6, 7, 32]

Wenn Sie das Prototype-Framework verwenden, müssen keine 'for'-Schleifen ausgeführt werden. Sie können http://www.prototypejs.org/api/array/uniq folgendermaßen verwenden :

var a = Array.uniq();  

Dadurch wird ein doppeltes Array ohne Duplikate erstellt. Ich bin auf Ihre Frage gestoßen, als ich nach einer Methode gesucht habe, um verschiedene Array-Datensätze zu zählen

uniq ()

ich benutzte

Größe()

und da war mein einfaches Ergebnis. ps Entschuldigung, wenn ich etwas falsch geschrieben habe

Bearbeiten: Wenn Sie undefinierte Datensätze maskieren möchten, möchten Sie diese möglicherweise hinzufügen

kompakt()

vorher so:

var a = Array.compact().uniq();  

Mit Sets können Sie jetzt Duplikate entfernen und wieder in das Array konvertieren.

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

console.log([...new Set(names)])

Eine andere Lösung ist die Verwendung von Sortieren und Filtern

var names = ["Mike","Matt","Nancy", "Matt","Adam","Jenny","Nancy","Carl"];
var namesSorted = names.sort();
const result = namesSorted.filter((e, i) => namesSorted[i] != namesSorted[i+1]);
console.log(result);

Das 0liegt daran, dass es sich bei JavaScript um einen falschen Wert handelt.

this[i] wird falsch sein, wenn der Wert des Arrays 0 oder ein anderer falscher Wert ist.

Array.prototype.getUnique = function() {
    var o = {}, a = []
    for (var i = 0; i < this.length; i++) o[this[i]] = 1
    for (var e in o) a.push(e)
    return a
}

Ich hatte ein etwas anderes Problem, bei dem ich Objekte mit doppelten ID-Eigenschaften aus einem Array entfernen musste. das hat funktioniert.

let objArr = [{
  id: '123'
}, {
  id: '123'
}, {
  id: '456'
}];

objArr = objArr.reduce((acc, cur) => [
  ...acc.filter((obj) => obj.id !== cur.id), cur
], []);

console.log(objArr);

Die einfachste Antwort lautet:

const array = [1, 1, 2, 2, 3, 5, 5, 2];
const uniqueArray = [...new Set(array)];
console.log(uniqueArray); // [1, 2, 3, 5]

Ich bin mir nicht sicher, warum Gabriel Silveira die Funktion so geschrieben hat, aber eine einfachere Form, die für mich genauso gut und ohne Minimierung funktioniert, ist:

Array.prototype.unique = function() {
  return this.filter(function(value, index, array) {
    return array.indexOf(value, index + 1) < 0;
  });
};

oder in CoffeeScript:

Array.prototype.unique = ->
  this.filter( (value, index, array) ->
    array.indexOf(value, index + 1) < 0
  )

Wenn Sie mit zusätzlichen Abhängigkeiten einverstanden sind oder bereits eine der Bibliotheken in Ihrer Codebasis haben, können Sie mit LoDash (oder Underscore) Duplikate aus einem vorhandenen Array entfernen.

Verwendungszweck

Wenn Sie es noch nicht in Ihrer Codebasis haben, installieren Sie es mit npm:

npm install lodash

Verwenden Sie es dann wie folgt:

import _ from 'lodash';
let idArray = _.uniq ([
    1,
    2,
    3,
    3,
    3
]);
console.dir(idArray);

Aus:

[ 1, 2, 3 ]

Dies wurde viel beantwortet, aber es wurde nicht auf meine besonderen Bedürfnisse eingegangen.

Viele Antworten lauten wie folgt:

a.filter((item, pos, self) => self.indexOf(item) === pos);

Dies funktioniert jedoch nicht für Arrays komplexer Objekte.

Angenommen, wir haben ein Array wie dieses:

const a = [
 { age: 4, name: 'fluffy' },
 { age: 5, name: 'spot' },
 { age: 2, name: 'fluffy' },
 { age: 3, name: 'toby' },
];

Wenn wir die Objekte mit eindeutigen Namen haben möchten, sollten wir array.prototype.findIndexanstelle von array.prototype.indexOf:

a.filter((item, pos, self) => self.findIndex(v => v.name === item.name) === pos);

Aus Shamasis Bhattacharyas Blog (O (2n) Zeitkomplexität):

Array.prototype.unique = function() {
    var o = {}, i, l = this.length, r = [];
    for(i=0; i<l;i+=1) o[this[i]] = this[i];
    for(i in o) r.push(o[i]);
    return r;
};

Aus Paul Irishs Blog : Verbesserung von JQuery .unique():

(function($){

    var _old = $.unique;

    $.unique = function(arr){

        // do the default behavior only if we got an array of elements
        if (!!arr[0].nodeType){
            return _old.apply(this,arguments);
        } else {
            // reduce the array to contain no dupes via grep/inArray
            return $.grep(arr,function(v,k){
                return $.inArray(v,arr) === k;
            });
        }
    };
})(jQuery);

// in use..
var arr = ['first',7,true,2,7,true,'last','last'];
$.unique(arr); // ["first", 7, true, 2, "last"]

var arr = [1,2,3,4,5,4,3,2,1];
$.unique(arr); // [1, 2, 3, 4, 5]

Finden eindeutiger Array-Werte in einer einfachen Methode

function arrUnique(a){
  var t = [];
  for(var x = 0; x < a.length; x++){
    if(t.indexOf(a[x]) == -1)t.push(a[x]);
  }
  return t;
}
arrUnique([1,4,2,7,1,5,9,2,4,7,2]) // [1, 4, 2, 7, 5, 9]

Es scheint, dass wir Rafaels Antwort verloren haben , die einige Jahre lang als akzeptierte Antwort galt. Dies war (zumindest 2017) die leistungsstärkste Lösung, wenn Sie kein Array vom gemischten Typ haben :

Array.prototype.getUnique = function(){
    var u = {}, a = [];
    for (var i = 0, l = this.length; i < l; ++i) {
        if (u.hasOwnProperty(this[i])) {
            continue;
        }
        a.push(this[i]);
        u[this[i]] = 1;
    }
return a;
}

Wenn Sie tun , ein Array Mischtyp haben, können Sie die Raute - Taste serialisiert:

Array.prototype.getUnique = function() {
    var hash = {}, result = [], key; 
    for ( var i = 0, l = this.length; i < l; ++i ) {
        key = JSON.stringify(this[i]);
        if ( !hash.hasOwnProperty(key) ) {
            hash[key] = true;
            result.push(this[i]);
        }
    }
    return result;
}

Um das Problem umgekehrt zu lösen, kann es nützlich sein, beim Laden Ihres Arrays kein Duplikat zu haben, so wie es das Set- Objekt tun würde, aber es ist noch nicht in allen Browsern verfügbar. Es spart Speicher und ist effizienter, wenn Sie den Inhalt mehrmals betrachten müssen.

Array.prototype.add = function (elem) {
   if (this.indexOf(elem) == -1) {
      this.push(elem);
   }
}

Stichprobe:

set = [];
[1,3,4,1,2,1,3,3,4,1].forEach(function(x) { set.add(x); });

Gibt Ihnen set = [1,3,4,2]