Alle nicht eindeutigen Werte (d.h.: doppeltes/mehrmaliges Vorkommen) in einem Array ermitteln

Question

Ich muss ein JavaScript-Array überprüfen, um festzustellen, ob es irgendwelche doppelten Werte gibt. Was ist der einfachste Weg, dies zu tun? Ich brauche nur zu finden, was die doppelten Werte sind - ich brauche nicht wirklich ihre Indizes oder wie oft sie dupliziert werden.

Ich weiß, dass ich das Array in einer Schleife durchlaufen und alle anderen Werte auf eine Übereinstimmung prüfen kann, aber es scheint, als sollte es einen einfacheren Weg geben.

Ähnliche Frage:

• Alle eindeutigen Werte in einem JavaScript-Array abrufen (Duplikate entfernen)

Answer 1

Sie können diese Funktion hinzufügen oder sie abändern und dem Array-Prototyp von Javascript hinzufügen:

Array.prototype.unique = function () {
    var r = new Array();
    o:for(var i = 0, n = this.length; i < n; i++)
    {
        for(var x = 0, y = r.length; x < y; x++)
        {
            if(r[x]==this[i])
            {
                alert('this is a DUPE!');
                continue o;
            }
        }
        r[r.length] = this[i];
    }
    return r;
}

var arr = [1,2,2,3,3,4,5,6,2,3,7,8,5,9];
var unique = arr.unique();
alert(unique);

Answer 2

AKTUALISIERT: Im Folgenden wird eine optimierte kombinierte Strategie verwendet. Sie optimiert die primitiven Suchvorgänge, um von der O(1)-Suchzeit des Hashes zu profitieren (die unique für ein Array von Primitiven ist O(n)). Die Suche nach Objekten wird optimiert, indem Objekte mit einer eindeutigen Kennung versehen werden, während sie durchlaufen werden, so dass die Identifizierung doppelter Objekte ebenfalls O(1) pro Objekt und O(n) für die gesamte Liste ist. Die einzige Ausnahme sind eingefrorene Objekte, aber die sind selten und ein Fallback wird mit einem Array und indexOf bereitgestellt.

var unique = function(){
  var hasOwn = {}.hasOwnProperty,
      toString = {}.toString,
      uids = {};

  function uid(){
    var key = Math.random().toString(36).slice(2);
    return key in uids ? uid() : uids[key] = key;
  }

  function unique(array){
    var strings = {}, numbers = {}, others = {},
        tagged = [], failed = [],
        count = 0, i = array.length,
        item, type;

    var id = uid();

    while (i--) {
      item = array[i];
      type = typeof item;
      if (item == null || type !== 'object' && type !== 'function') {
        // primitive
        switch (type) {
          case 'string': strings[item] = true; break;
          case 'number': numbers[item] = true; break;
          default: others[item] = item; break;
        }
      } else {
        // object
        if (!hasOwn.call(item, id)) {
          try {
            item[id] = true;
            tagged[count++] = item;
          } catch (e){
            if (failed.indexOf(item) === -1)
              failed[failed.length] = item;
          }
        }
      }
    }

    // remove the tags
    while (count--)
      delete tagged[count][id];

    tagged = tagged.concat(failed);
    count = tagged.length;

    // append primitives to results
    for (i in strings)
      if (hasOwn.call(strings, i))
        tagged[count++] = i;

    for (i in numbers)
      if (hasOwn.call(numbers, i))
        tagged[count++] = +i;

    for (i in others)
      if (hasOwn.call(others, i))
        tagged[count++] = others[i];

    return tagged;
  }

  return unique;
}();

Wenn Sie ES6 Collections zur Verfügung haben, gibt es eine viel einfachere und deutlich schnellere Version. (Shim für IE9+ und andere Browser hier: https://github.com/Benvie/ES6-Harmony-Collections-Shim )

function unique(array){
  var seen = new Set;
  return array.filter(function(item){
    if (!seen.has(item)) {
      seen.add(item);
      return true;
    }
  });
}

Answer 3

var a = ["a","a","b","c","c"];

a.filter(function(value,index,self){ return (self.indexOf(value) !== index )})

Answer 4

Finden. nicht einmalig Werte aus 3 Arrays (oder mehr):

ES2015

//                             
var arr =  [1,2,2,3,3,4,5,6,2,3,7,8,5,22],
    arr2 = [1,2,511,12,50],
    arr3 = [22,0],
    merged,
    nonUnique;

// Combine all the arrays to a single one
merged = arr.concat(arr2, arr3)

// create a new (dirty) Array with only the non-unique items
nonUnique = merged.filter((item,i) => merged.includes(item, i+1))

// Cleanup - remove duplicate & empty items items 
nonUnique = [...new Set(nonUnique)]

console.log(nonUnique)

---

PRE-ES2015:

In dem folgenden Beispiel habe ich eine überlagerte unique Methode über der Array Prototyp und ermöglicht den Zugang von überall her und hat mehr "deklarativ" Syntax. Ich empfehle diesen Ansatz bei großen Projekten nicht, da es sehr wohl zu Kollisionen mit einer anderen Methode mit demselben benutzerdefinierten Namen kommen kann.

Array.prototype.unique = function () {
    var arr = this.sort(), i=arr.length; // input must be sorted for this to work
    while(i--)
      arr[i] === arr[i-1] && arr.splice(i,1) // remove duplicate item
    return arr
}

Array.prototype.nonunique = function () {
    var arr = this.sort(), i=arr.length, res = []; // input must be sorted for this to work
    while(i--)
      arr[i] === arr[i-1] && (res.indexOf(arr[i]) == -1) && res.push(arr[i]) 
    return res
}

//                             
var arr =  [1,2,2,3,3,4,5,6,2,3,7,8,5,22],
    arr2 = [1,2,511,12,50],
    arr3 = [22,0],
    // merge all arrays & call custom Array Prototype - "unique"
    unique = arr.concat(arr2, arr3).unique(),
    nonunique = arr.concat(arr2, arr3).nonunique()

console.log(unique)     // [1,12,2,22,3,4,5,50,511,6,7,8]
console.log(nonunique)  // [1,12,2,22,3,4,5,50,511,6,7,8]

Answer 5

Damit sollten Sie bekommen, was Sie wollen, nur die Duplikate.

function find_duplicates(arr) {
  var len=arr.length,
      out=[],
      counts={};

  for (var i=0;i<len;i++) {
    var item = arr[i];
    counts[item] = counts[item] >= 1 ? counts[item] + 1 : 1;
    if (counts[item] === 2) {
      out.push(item);
    }
  }

  return out;
}

find_duplicates(['one',2,3,4,4,4,5,6,7,7,7,'pig','one']); // -> ['one',4,7] in no particular order.