Javascript 删除所有出现的重复元素，只留下唯一的一个

Question

我想删除多次出现的元素并获取唯一元素。数组总是有 3 个元素。 假设我有一个数组 [2,3,2]，那么我需要得到 3，它仅在数组中是唯一的（删除两个 2，因为它们不止一次出现）。

我已尝试使用以下代码，但肯定无法按预期工作。

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

谢谢！

Answer 1

这应该可以解决问题：

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]

要检查特定项在数组中是否唯一，它只检查找到的第一个索引是否与找到的最后一个索引匹配。

Answer 2

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

其中uniqueValues = [1,4,7]

Answer 3

到目前为止，其他答案都具有O(n log n) 时间复杂度或更糟。这可以在 O(n) 时间内完成，尽管使用集合（Set.has 具有 O(1) 复杂性）而不是嵌套循环：

// .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]));

Answer 4

在从数组中删除重复项时，我通常使用一种方法：

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

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

这也适用于字符串和布尔值。

Answer 5

另一种选择：

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

Answer 6

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. 首先，我们将使用“过滤器”对“arr”进行双重循环

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

1. 如果“item”等于“el”，则返回它的“length”

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

• 这将返回数组中每个元素的出现次数
• 让我们用第一个例子来说明这一点：
• [1,2,3,3,3,5,5,5] --> [1,1,3,3,3,3,3,3]
• 1 发生 1 次
• 2 发生 1 次
• 3 次发生 3 次
• 5 发生 3 次

1. 要返回任何不重复或唯一的元素，我们只需指定长度等于“1”

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

• 此方法允许您从要返回的元素中选择出现次数
• 例如，如果您想从数组中返回出现 3 次的元素，则将“长度”设置为等于 3

Answer 7

另一种方法是采用Map 并将值设置为false，如果之前已经看到过一个键。然后通过取地图的值来过滤数组。

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]

Answer 8

只有一行

arr.filter((item, pos, a) => a.lastIndexOf(item) === a.indexOf(item));

const arr = [1, 2, 3, 4, 1, 5, 6, 5];
const unique = arr.filter((item, pos, a) => a.lastIndexOf(item) === a.indexOf(item));
console.log(unique);

实用功能

Array.prototype.unique = function() {
    return this.filter((item, pos, a) => a.lastIndexOf(item) === a.indexOf(item));
}

console.log([1, 2, 3, 4, 1, 5, 6, 5].unique());