Javascript - Entfernen Sie einzigartige Elemente von Array

Question

Ich frage mich, wie man über das Entfernen von einzigartigen Elementen aus einem Array gehen würde. Zum Beispiel:

var arr = [1, 2, 2, 4, 4] würde zurückgeben [2, 2, 4, 4]. Wobei [1, 2, 3][] zurückgeben würde, weil alle Elemente eindeutig sind.

Ich glaube, ich muss jedes Element mit jedem anderen Element im Array überprüfen, aber ich bin mir nicht sicher, wie ich das anstellen soll.

Danke!

Answer 1

Mit ES6, könnten Sie eine Array#map verwenden und die Werte mit Array#forEach zählen.

Spätere Verwendung Array#filter und überprüfen Sie die Anzahl.

Wenn mehr als 1 Rückkehr true (enthalten das Element in der Ergebnismenge), ansonsten false zurückkehren (nicht Einzelteil in der Ergebnismenge enthalten).

function getNotUnique(array) { 
 
    var map = new Map(); 
 
    array.forEach(a => map.set(a, (map.get(a) || 0) + 1)); 
 
    return array.filter(a => map.get(a) > 1); 
 
} 
 

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

Answer 2

Hier ist eine Implementierung (mit https://stackoverflow.com/a/5668029/4202031)

function removeUnique(arr) { 
    var counts = {} 

    for(var i = 0; i< arr.length; i++) { 
     var num = arr[i] 
     counts[num] = counts[num] ? counts[num]+1 : 1 
    } 

    var result = [] 
    for(var key in counts) { 
    if(Object.prototype.hasOwnProperty.call(counts, key) && counts[key] > 1 { 
     result.push(key) 
    } 
    } 

    return result 
} 


var arr = [1, 2, 3] 
var arr2 = [1, 1, 2, 2, 4, 6, 4] 

console.log(removeUnique(arr)) // [] 
console.log(removeUnique(arr2)) // [ '1', '2', '4' ] 

Answer 3

Sie so etwas tun könnte (streng Verwendung von Arrays):

var arr = [1,2,3,4,4]; 
var temp = []; 
var to_keep = []; 
for(var x = 0; x < arr.length; x++){ 
    if(temp.indexOf(arr[x]) > -1) { 
    if(to_keep.indexOf(arr[x]) == -1) 
     to_keep.push(arr[x]); 
    } else if(temp.indexOf(arr[x]) == -1) temp.push(arr[x]); 
} 

for(var y = 0; y < arr.length; y++){ 
    if(to_keep.indexOf(arr[y]) == -1){ 
    arr.splice(y,1); 
    y--; 
    } 
} 

// arr = [4,4]; 

Answer 4

Unten ist einfach und leicht zu entfernen einzigartig zu verstehen Elemente aus dem Array.

function removeUnique(arr) { 
 
\t var newArr = []; 
 
\t for (var i = 0; i < arr.length; i++) { 
 
\t \t var count = 0; 
 
\t \t for (var j = 0; j < arr.length; j++) { 
 
\t \t \t if (arr[j] == arr[i]) { 
 
\t \t \t \t count++; 
 
\t \t \t } 
 
\t \t } 
 
\t \t if (count >= 2) { 
 
\t \t \t newArr.push(arr[i]); 
 
\t \t } 
 
\t } 
 
    return newArr; 
 
} 
 
console.log(removeUnique([1, 2, 2, 4, 4]));

Answer 5

Iterate durch das Array, in dem Original für jedes Auftreten den Wert als einen Index in ein Objekt und Inkrement verwenden. Dann iteriere durch das Objekt und ziehe diejenigen mit Summen größer als eins heraus. Sollte für String- und numerische Typen funktionieren.

function dupsOnly(a) { 
    var T = {}; 
    for (var i = 0; i < a.length; i++) { 
     if (a[i] in T) 
      T[a[i]] += 1; 
     else 
      T[a[i]] = 1; 
    } 
    var D = []; 
    for (var t in T) { 
     if (T[t] > 1) 
      D.push(t); 
     while (T[t] > 1) { 
      T[t] -= 1; 
      D.push(t); 
     } 
    } 
    return D; 
} 

Answer 6

var arr = [1, 2, 2, 4, 4] 

var dict_with_count = {} 
for (var i=0; i<arr.length; i++){ 
    dict_with_count[arr[i]] = 0 
} 

for (var i=0; i<arr.length; i++){ 
    dict_with_count[arr[i]] += 1 
} 

var new_list = []; 

for (key in dict_with_count){ 
    if (dict_with_count[key] > 1){ 
     for (var j=0; j<dict_with_count[key]; j++){ 
      new_list.push(key) 
     } 
    } 
} 

console.log(new_list) 

Answer 7

Dies sollte es tun;

var arr = [1, 2, 2, 4, 4], 
 
    unq = arr.map((e,i,a) => a.filter(f => f === e).length) 
 
      .reduce((p,c,i) => c === 1 ? p : p.concat(arr[i]) ,[]); 
 
console.log(unq);

Answer 8

Dies ist eine alte Frage, aber der normale Weg in ES6 sollte eine set zu benutzen:

const unique_values = [...new Set([1, 2, 2, 4, 4])] 
>>> [1, 2, 4] 

Ein Satz ist eine Datenstruktur entworfen zu halten nur eindeutige Werte, und ist der Standard in den meisten Sprachen. In dem obigen Ausschnitt habe ich die spread operator verwendet, um ein neues Array aus dem Inhalt des Satzes zu konstruieren.

Beachten Sie, dass Set intern den ===-Operator verwendet, so dass dies für eine Auflistung von Objekten oder verschachtelten Arrays nicht funktioniert, da diese per Referenz verglichen werden.

Eine Sammlung primitiver Typen funktioniert jedoch sehr gut mit Set.