So erhalten Sie eindeutige Werte in einem Array [duplicate]

Question 1

Wie kann ich eine Liste mit eindeutigen Werten in einem Array erhalten? Muss ich immer ein zweites Array verwenden oder gibt es in JavaScript etwas Ähnliches wie die Hashmap von Java?

Ich werde verwenden JavaScript und jQuery nur. Es können keine zusätzlichen Bibliotheken verwendet werden.

Question 2

Hier ist eine viel sauberere Lösung für ES6, die meiner Meinung nach hier nicht enthalten ist. Es verwendet die Satz und das Spread-Operator: ...

var a = [1, 1, 2];

[... new Set(a)]

Was zurückkehrt [1, 2]

Question 3

Oder für diejenigen, die einen Einzeiler suchen (einfach und funktional) kompatibel mit aktuellen Browsern:

let a = ["1", "1", "2", "3", "3", "1"];
let unique = a.filter((item, i, ar) => ar.indexOf(item) === i);
console.log(unique);

Aktualisierung 2021
Ich würde empfehlen, die Antwort von Charles Clayton zu lesen, da es seit den jüngsten Änderungen an JS noch prägnantere Möglichkeiten gibt, dies zu tun.

Aktualisierung 18.04.2017

Es scheint, als ob ‘Array.prototype.includes’ jetzt weit verbreitete Unterstützung in den neuesten Versionen der Mainline-Browser (Kompatibilität)

Aktualisierung 29.07.2015:

Es gibt Pläne für Browser, eine standardisierte ‘Array.prototype.includes’-Methode zu unterstützen, die diese Frage zwar nicht direkt beantwortet; ist oft verwandt.

Verwendungszweck:

["1", "1", "2", "3", "3", "1"].includes("2");     // true

Pollyfill (Browserunterstützung, Quelle von mozilla):

// https://tc39.github.io/ecma262/#sec-array.prototype.includes
if (!Array.prototype.includes) {
  Object.defineProperty(Array.prototype, 'includes', {
    value: function(searchElement, fromIndex) {

      // 1. Let O be ? ToObject(this value).
      if (this == null) {
        throw new TypeError('"this" is null or not defined');
      }

      var o = Object(this);

      // 2. Let len be ? ToLength(? Get(O, "length")).
      var len = o.length >>> 0;

      // 3. If len is 0, return false.
      if (len === 0) {
        return false;
      }

      // 4. Let n be ? ToInteger(fromIndex).
      //    (If fromIndex is undefined, this step produces the value 0.)
      var n = fromIndex | 0;

      // 5. If n ≥ 0, then
      //  a. Let k be n.
      // 6. Else n < 0,
      //  a. Let k be len + n.
      //  b. If k < 0, let k be 0.
      var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);

      // 7. Repeat, while k < len
      while (k < len) {
        // a. Let elementK be the result of ? Get(O, ! ToString(k)).
        // b. If SameValueZero(searchElement, elementK) is true, return true.
        // c. Increase k by 1.
        // NOTE: === provides the correct "SameValueZero" comparison needed here.
        if (o[k] === searchElement) {
          return true;
        }
        k++;
      }

      // 8. Return false
      return false;
    }
  });
}

Question 4

Da ich in den Kommentaren zur Antwort von @Rocket weiter darauf eingegangen bin, kann ich auch ein Beispiel angeben, das keine Bibliotheken verwendet. Dies erfordert zwei neue Prototypfunktionen, contains und unique

Array.prototype.contains = function(v) {
  for (var i = 0; i < this.length; i++) {
    if (this[i] === v) return true;
  }
  return false;
};

Array.prototype.unique = function() {
  var arr = [];
  for (var i = 0; i < this.length; i++) {
    if (!arr.contains(this[i])) {
      arr.push(this[i]);
    }
  }
  return arr;
}

var duplicates = [1, 3, 4, 2, 1, 2, 3, 8];
var uniques = duplicates.unique(); // result = [1,3,4,2,8]

console.log(uniques);

Für mehr Zuverlässigkeit können Sie ersetzen contains mit MDNs indexOf Shim und prüfen, ob jedes Element ist indexOf ist gleich -1: Dokumentation

Question 5

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

Browser-Kompatibilität: IE9+

Question 6

Mit EcmaScript 2016 können Sie das einfach so machen.

 var arr = ["a", "a", "b"];
 var uniqueArray = Array.from(new Set(arr)); // Unique Array ['a', 'b'];

Sets sind immer einzigartig und verwenden Array.from() Sie können ein Set in ein Array konvertieren. Als Referenz werfen Sie einen Blick auf die Dokumentationen.

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

Question 7

Heutzutage können Sie den Set-Datentyp von ES6 verwenden, um Ihr Array in ein eindeutiges Set umzuwandeln. Wenn Sie dann Array-Methoden verwenden müssen, können Sie es wieder in ein Array umwandeln:

var arr = ["a", "a", "b"];
var uniqueSet = new Set(arr); // {"a", "b"}
var uniqueArr = Array.from(uniqueSet); // ["a", "b"]
//Then continue to use array methods:
uniqueArr.join(", "); // "a, b"

Question 8

Wenn Sie das ursprüngliche Array intakt lassen möchten,

Sie benötigen ein zweites Array, um die eindeutigen Elemente des ersten zu enthalten.

Die meisten Browser haben Array.prototype.filter:

var unique= array1.filter(function(itm, i){
    return array1.indexOf(itm)== i; 
    // returns true for only the first instance of itm
});


//if you need a 'shim':
Array.prototype.filter= Array.prototype.filter || function(fun, scope){
    var T= this, A= [], i= 0, itm, L= T.length;
    if(typeof fun== 'function'){
        while(i<L){
            if(i in T){
                itm= T[i];
                if(fun.call(scope, itm, i, T)) A[A.length]= itm;
            }
            ++i;
        }
    }
    return A;
}
 Array.prototype.indexOf= Array.prototype.indexOf || function(what, i){
        if(!i || typeof i!= 'number') i= 0;
        var L= this.length;
        while(i<L){
            if(this[i]=== what) return i;
            ++i;
        }
        return -1;
    }