Wie kann ich eine Liste eindeutiger Werte in einem Array abrufen? Muss ich immer ein zweites Array verwenden oder gibt es etwas Ähnliches wie die Java-Hashmap in JavaScript?

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

Da ich in den Kommentaren zu @ Rockets Antwort darauf eingegangen bin, kann ich auch ein Beispiel angeben, das keine Bibliotheken verwendet. Dies erfordert zwei neue Prototypfunktionen containsundunique

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 containsdas indexOfShim von MDN ersetzen und prüfen, ob jedes Element indexOfgleich -1: Dokumentation ist

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

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

Update 18-04-2017

Es sieht so aus, als ob 'Array.prototype.includes' jetzt in den neuesten Versionen der Hauptbrowser weit verbreitet ist ( Kompatibilität) ).

Update 29-07-2015:

Es ist geplant, dass Browser eine standardisierte Methode 'Array.prototype.includes' unterstützen, die diese Frage zwar nicht direkt beantwortet. ist oft verwandt.

Verwendung:

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

Hier ist eine viel sauberere Lösung für ES6, die hier nicht enthalten ist. Es verwendet den Operator Set und den Spread-Operator :...

var a = [1, 1, 2];

[... new Set(a)]

Welches kehrt zurück [1, 2]

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 +

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

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

Sets sind immer eindeutig und werden verwendet Array.from() Sie ein Set in ein Array konvertieren. Schauen Sie sich als Referenz die Dokumentationen an.

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 /Einstellen

Jetzt können wir in ES6 die neu eingeführte ES6-Funktion verwenden

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

ODER durch Array-Spread-Syntax für Iterables

let items = [1,1,1,1,3,4,5,2,23,1,4,4,4,2,2,2]; 
let uniqueItems = [...new Set(items)];

Es wird das eindeutige Ergebnis zurückgegeben.

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

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

Sie benötigen ein zweites Array, um die einzigartigen 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;
    }

Heutzutage können Sie den Datentyp Set von ES6 verwenden, um Ihr Array in ein eindeutiges Set zu konvertieren. Wenn Sie dann Array-Methoden verwenden müssen, können Sie diese 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"

Nicht in Javascript nativ, aber viele Bibliotheken haben diese Methode.

Underscore.js _.uniq(array)( Link ) funktioniert ganz gut ( Quelle ).

Mit jQuery habe ich folgende Array-Funktion erstellt:

Array.prototype.unique = function () {
    var arr = this;
    return $.grep(arr, function (v, i) {
        return $.inArray(v, arr) === i;
    });
}

console.log([1,2,3,1,2,3].unique()); // [1,2,3]

Kurze und süße Lösung mit zweitem Array;

var axes2=[1,4,5,2,3,1,2,3,4,5,1,3,4];

    var distinct_axes2=[];

    for(var i=0;i<axes2.length;i++)
        {
        var str=axes2[i];
        if(distinct_axes2.indexOf(str)==-1)
            {
            distinct_axes2.push(str);
            }
        }
    console.log("distinct_axes2 : "+distinct_axes2); // distinct_axes2 : 1,4,5,2,3

Schnell, kompakt, keine verschachtelten Schleifen, funktioniert mit jedem Objekt, nicht nur mit Zeichenfolgen und Zahlen, benötigt ein Prädikat und nur 5 Codezeilen !!

function findUnique(arr, predicate) {
  var found = {};
  arr.forEach(d => {
    found[predicate(d)] = d;
  });
  return Object.keys(found).map(key => found[key]); 
}

Beispiel: So finden Sie eindeutige Elemente nach Typ:

var things = [
  { name: 'charm', type: 'quark'},
  { name: 'strange', type: 'quark'},
  { name: 'proton', type: 'boson'},
];

var result = findUnique(things, d => d.type);
//  [
//    { name: 'charm', type: 'quark'},
//    { name: 'proton', type: 'boson'}
//  ] 

Wenn Sie möchten, dass das erste eindeutige Element anstelle des letzten gefunden wird, fügen Sie dort ein found.hasOwnPropery () hinzu.

Sie benötigen nur Vanilla JS, um Unikate mit Array.some und Array.reduce zu finden. Mit der ES2015-Syntax sind es nur 62 Zeichen.

a.reduce((c, v) => b.some(w => w === v) ? c : c.concat(v)), b)

Array.some und Array.reduce werden in IE9 + und anderen Browsern unterstützt. Ändern Sie einfach die Fettpfeilfunktionen für reguläre Funktionen, um sie in Browsern zu unterstützen, die die ES2015-Syntax nicht unterstützen.

var a = [1,2,3];
var b = [4,5,6];
// .reduce can return a subset or superset
var uniques = a.reduce(function(c, v){
    // .some stops on the first time the function returns true                
    return (b.some(function(w){ return w === v; }) ?  
      // if there's a match, return the array "c"
      c :     
      // if there's no match, then add to the end and return the entire array                                        
      c.concat(v)}),                                  
  // the second param in .reduce is the starting variable. This is will be "c" the first time it runs.
  b);                                                 

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

Die meisten der oben genannten Lösungen weisen eine hohe Laufzeitkomplexität auf.

Hier ist die Lösung, reducedie die Arbeit verwendet und erledigen kann O (n) Zeit .

Array.prototype.unique = Array.prototype.unique || function() {
        var arr = [];
	this.reduce(function (hash, num) {
		if(typeof hash[num] === 'undefined') {
			hash[num] = 1; 
			arr.push(num);
		}
		return hash;
	}, {});
	return arr;
}
    
var myArr = [3,1,2,3,3,3];
console.log(myArr.unique()); //[3,1,2];

Hinweis:

Diese Lösung ist nicht abhängig von reduzieren. Die Idee ist, eine Objektzuordnung zu erstellen und eindeutige Objekte in das Array zu verschieben.

ES6 Weg:

const uniq = (arr) => (arr.filter((item, index, arry) => (arry.indexOf(item) === index)));

Sie können verwenden,

let arr1 = [1,2,1,3];
let arr2 = [2,3,4,5,1,2,3];

let arr3 = [...new Set([...arr1,...arr2])];

es wird Ihnen einzigartige Elemente geben,

**> aber es gibt einen Haken,

für diese "1" und 1 und sind diff Elemente, **

Die zweite Option ist die Verwendung der Filtermethode für das Array.

Sie können ein Array mit Duplikaten eingeben. Die folgende Methode gibt ein Array mit eindeutigen Elementen zurück.

function getUniqueArray(array){
    var uniqueArray = [];
    if (array.length > 0) {
       uniqueArray[0] = array[0];
    }
    for(var i = 0; i < array.length; i++){
        var isExist = false;
        for(var j = 0; j < uniqueArray.length; j++){
            if(array[i] == uniqueArray[j]){
                isExist = true;
                break;
            }
            else{
                isExist = false;
            }
        }
        if(isExist == false){
            uniqueArray[uniqueArray.length] = array[i];
        }
    }
    return uniqueArray;
}

Das einzige Problem mit den bisher gegebenen Lösungen ist die Effizienz. Wenn Sie sich darüber Sorgen machen (und dies wahrscheinlich auch tun sollten), müssen Sie verschachtelte Schleifen vermeiden: Für * for, filter * indexOf, grep * inArray durchlaufen alle das Array mehrmals. Sie können eine einzelne Schleife mit Lösungen wie dieser oder dieser implementieren

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

Ich habe dieses Problem in reinem JS ausprobiert. Ich habe die folgenden Schritte ausgeführt: 1. Sortieren Sie das angegebene Array, 2. Durchlaufen Sie das sortierte Array, 3. Überprüfen Sie den vorherigen und den nächsten Wert mit dem aktuellen Wert

// JS
var inpArr = [1, 5, 5, 4, 3, 3, 2, 2, 2,2, 100, 100, -1];

//sort the given array
inpArr.sort(function(a, b){
    return a-b;
});

var finalArr = [];
//loop through the inpArr
for(var i=0; i<inpArr.length; i++){
    //check previous and next value 
  if(inpArr[i-1]!=inpArr[i] && inpArr[i] != inpArr[i+1]){
        finalArr.push(inpArr[i]);
  }
}
console.log(finalArr);

Demo

function findUniques(arr){
  let uniques = []
  arr.forEach(n => {
    if(!uniques.includes(n)){
      uniques.push(n)
    }       
  })
  return uniques
}

let arr = ["3", "3", "4", "4", "4", "5", "7", "9", "b", "d", "e", "f", "h", "q", "r", "t", "t"]

findUniques(arr)
// ["3", "4", "5", "7", "9", "b", "d", "e", "f", "h", "q", "r", "t"]

Wenn Sie bedenken, dass indexOfdas erste Auftreten eines Elements zurückgegeben wird, können Sie Folgendes tun:

Array.prototype.unique = function(){
        var self = this;
        return this.filter(function(elem, index){
            return self.indexOf(elem) === index;
        })
    }

Wenn Sie sich nicht so viele Gedanken über ältere Browser machen müssen, ist dies genau das, wofür Sets entwickelt wurden.

Mit dem Set-Objekt können Sie eindeutige Werte eines beliebigen Typs speichern, unabhängig davon, ob es sich um primitive Werte oder Objektreferenzen handelt.

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

const set1 = new Set([1, 2, 3, 4, 5, 1]);
// returns Set(5) {1, 2, 3, 4, 5}

Ein anderer Gedanke an diese Frage. Folgendes habe ich getan, um dies mit weniger Code zu erreichen.

var distinctMap = {};
var testArray = ['John', 'John', 'Jason', 'Jason'];
for (var i = 0; i < testArray.length; i++) {
  var value = testArray[i];
  distinctMap[value] = '';
};
var unique_values = Object.keys(distinctMap);

console.log(unique_values);

Hier ist ein Ansatz mit anpassbarer equalsFunktion, der sowohl für Grundelemente als auch für benutzerdefinierte Objekte verwendet werden kann:

Array.prototype.pushUnique = function(element, equalsPredicate = (l, r) => l == r) {
    let res = !this.find(item => equalsPredicate(item, element))
    if(res){
        this.push(element)
    }
    return res
}

Verwendung:

//with custom equals for objects
myArrayWithObjects.pushUnique(myObject, (left, right) => left.id == right.id)

//with default equals for primitives
myArrayWithPrimitives.pushUnique(somePrimitive)

Meine Antwort verwendet Array.filterund Array.indexOfMethoden, um die eindeutigen Werte zu erhalten

array.filter((value, index, self)=>self.indexOf(value)===index)

Ich habe diesen Ansatz auf einer Website gesehen, aber ihr Code ist anders als hier. Ich habe den Code auf eine Zeile vereinfacht und hier veröffentlicht, damit jemand davon profitiert

Hinweis: Mein Ansatz ähnelt dem von Josh. Ich lasse es hier, da die Variablennamen in meinem Code selbsterklärend sind.

Ich dachte nur, ob wir die lineare Suche verwenden können, um die Duplikate zu beseitigen:

JavaScript:
function getUniqueRadios() {

var x=document.getElementById("QnA");
var ansArray = new Array();
var prev;


for (var i=0;i<x.length;i++)
  {
    // Check for unique radio button group
    if (x.elements[i].type == "radio")
    {
            // For the first element prev will be null, hence push it into array and set the prev var.
            if (prev == null)
            {
                prev = x.elements[i].name;
                ansArray.push(x.elements[i].name);
            } else {
                   // We will only push the next radio element if its not identical to previous.
                   if (prev != x.elements[i].name)
                   {
                       prev = x.elements[i].name;
                       ansArray.push(x.elements[i].name);
                   }
            }
    }

  }

   alert(ansArray);

}}

HTML:

<body>

<form name="QnA" action="" method='post' ">

<input type="radio"  name="g1" value="ANSTYPE1"> good </input>
<input type="radio" name="g1" value="ANSTYPE2"> avg </input>

<input type="radio"  name="g2" value="ANSTYPE3"> Type1 </input>
<input type="radio" name="g2" value="ANSTYPE2"> Type2 </input>


<input type="submit" value='SUBMIT' onClick="javascript:getUniqueRadios()"></input>


</form>
</body>

Hier ist die Einzeiler-Lösung für das Problem:

var seriesValues = [120, 120, 120, 120];
seriesValues = seriesValues.filter((value, index, seriesValues) => (seriesValues.slice(0, index)).indexOf(value) === -1);
console.log(seriesValues);

Kopieren, in die Browserkonsole einfügen und die Ergebnisse erhalten, yo :-)

Ich habe JQuery Unique Funktion eingebaut .

uniqueValues= jQuery.unique( duplicateValues );

Weitere Informationen finden Sie in den jquery API-Dokumentationen.

http://api.jquery.com/jquery.unique/