Javascript entfernt alle Vorkommen von doppelten Elementen und hinterlässt das einzige, das eindeutig ist

Ich möchte Elemente entfernen, die mehr als einmal vorkommen, und das eindeutige Element erhalten. Das Array hat immer 3 Elemente. Nehmen wir an, ich habe ein Array [2,3,2]dann muss ich 3 bekommen, die nur im Array eindeutig ist (beide 2 entfernen, weil sie mehr als einmal vorkommen).

Ich habe es mit folgendem Code versucht, aber sicherlich funktioniert es nicht wie erwartet.

var firstArrTemp = [2,3,2];
var sorted_arr = firstArrTemp.sort();
var unique_element;
for (var i = 0; i < sorted_arr.length - 1; i++) {
    if (sorted_arr[i + 1] != sorted_arr[i]) {
        unique_element=sorted_arr[i];
    }
}

alert(unique_element);

Danke!

Das sollte den Trick machen:

Array.prototype.getUnique = function(){
    var uniques = [];
    for(var i = 0, l = this.length; i < l; ++i){
        if(this.lastIndexOf(this[i]) == this.indexOf(this[i])) {
            uniques.push(this[i]);
        }
    }
    return uniques;
}

// Usage:

var a = [2, 6, 7856, 24, 6, 24];
alert(JSON.stringify(a.getUnique()));

console.log(a.getUnique()); // [2, 7856]

Um zu überprüfen, ob ein bestimmtes Element im Array eindeutig ist, prüft es einfach, ob der erste Index, an dem es gefunden wird, mit dem letzten Index übereinstimmt, an dem es gefunden wird.

Eine Alternative mit der Funktion filter():

var myArray = [1,2,3,2,2,4,3,7,3].sort();
var uniqueValues = myArray.filter(function(item, i, arr) {
  return (item !== arr[i-1] && item !== arr[i+1]);
});

Woher uniqueValues = [1,4,7]

Die anderen Antworten haben bisher alle O(n log n) Zeitkomplexität oder schlimmer. Dies kann in erfolgen O(n) Zeit, obwohl die Verwendung von Sets (Set.has hat O(1) Komplexität) anstelle von verschachtelten Schleifen:

// .sort has complexity O(n log n): it's not needed here, avoid it
const getOnlyUniques = (arr) => {
  const foundOnce = new Set();
  const foundTwice = new Set();
  arr.forEach((item) => {
    if (foundOnce.has(item)) {
      foundTwice.add(item);
    }
    foundOnce.add(item);
  });
  return arr.filter(item => !foundTwice.has(item));
};
console.log(getOnlyUniques([2, 3, 2]));

Wenn es darum geht, Duplikate aus einem Array zu entfernen, verwende ich normalerweise einen Ansatz:

const arrWithDuplicates = [1,2,2,2,3,4,4]
const arrWithUniqueValues = [...new Set(arrWithDuplicates)]

// result will be: [1,2,3,4]

Dies funktioniert auch mit Strings und Booleans.

Eine Alternative:

var a = [2,3,2], result = [];

for(var i = 0; i < a.length; i++){

    if(getAllIndexes(a, a[i]).length === 1)
        result.push(a[i]);
}

console.log(result);

function getAllIndexes(arr, val) {
    var indexes = [], i = -1;
    while (~(i = arr.indexOf(val, i+1)))
        indexes.push(i);
    return indexes;
}

const nums = [1,2,3,3,3,5,5,5];
const chars = ['a','b','a','b','a','a'];
const mixed = [1,3,'b',3,'b','a','b',3];
const unique = [1,'a',3]; 

const distinct = (arr) => arr.filter((el) => arr.filter((item) => item === el).length === 1);

console.log(distinct(nums)); // [ 1, 2 ]
console.log(distinct(chars)); // []
console.log(distinct(mixed)); // [ 1, 'a' ]
console.log(distinct(unique)); // [ 1, 'a', 3 ]

1. Zuerst werden wir “arr” mit “filter” doppelt durchlaufen

arr.filter((el) => arr.filter((item) => … );

2. wenn “item” gleich “el” ist, dann gib seine “länge” zurück

arr.filter((el) => arr.filter((item) => item === el).length

• Dadurch wird die Anzahl der Vorkommen für jedes Element im Array zurückgegeben
• Lassen Sie uns das 1. Beispiel verwenden, um dies zu veranschaulichen:
• [1,2,3,3,3,5,5,5] –> [1,1,3,3,3,3,3,3]
• 1 kam 1 Mal vor
• 2 kam 1 Mal vor
• 3 kam 3 Mal vor
• 5 kam 3 Mal vor

3. Um ein Element zurückzugeben, das sich nicht wiederholt oder einzigartig ist, müssen wir nur die angegebene Länge auf “1” setzen.

arr.filter((el) => arr.filter((item) => item === el).length === 1)

• Mit diesem Ansatz können Sie die Anzahl der Vorkommen eines Elements auswählen, das Sie zurückgeben möchten
• Wenn Sie beispielsweise ein Element zurückgeben möchten, das dreimal in einem Array vorkommt, setzen Sie die “Länge” auf 3

Ein anderer Ansatz, indem man a nimmt Map und setzen Sie den Wert auf false, wenn ein Schlüssel schon einmal gesehen wurde. Filtern Sie dann das Array, indem Sie den Wert der Karte nehmen.

var array = [2, 3, 2],
    result = array.filter(
        Map.prototype.get,
        array.reduce((m, v) => m.set(v, !m.has(v)), new Map)
    );

console.log(result); // [3]