关于javascript：删除数字数组中的所有重复数字

Remove all of the duplicate numbers in an array of numbers

本问题已经有最佳答案，请猛点这里访问。

我收到这个问题是为了练习，措辞让我困惑，因为我看到了2个可能需要的结果。

不管怎样，我都想看看这两种解决方案。

例如，如果我有一个数组：

1	let arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];

我将此视为希望最终结果：

1	let finalResult = [1, 2, 3, 4, 5, 8, 9, 10];

或：

1	let finalResult = [1, 9, 10];

两者之间的区别是，一个删除任何重复的数字，剩下的留下，第二个只需要任何不重复的数字。

不管怎样，我想写两个函数，每个函数执行一个。

这是别人给我的第二个解决方案。

1
2
3
4
5
6
7
8
9
10

let elems = {},

arr2 = arr.filter(function (e) {
if (elems[e] === undefined) {
elems[e] = true;
return true;
}
return false;
});
console.log(arr2);

我不确定第一个函数的功能(删除所有重复项)。

相关讨论

使用set和array.from()。

1
2
3

let arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];

console.log(Array.from(new Set(arr)));

交替使用regex

此处显示regex说明

1
2
3
4
5
6
7
8
9

let arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];

let res = arr
.join(',')
.replace(/(\b,\w+\b)(?=.*\1)/ig, '')
.split(',')
.map(Number);

console.log(res);

交替使用对象

1
2
3
4
5
6
7

let arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];

let obj = arr.reduce((acc, val) => Object.assign(acc, {
[val]: val
}), {});

console.log(Object.values(obj));

只需使用一个简单的array.filter一行：

1
2
3

let arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];
let finalResult = arr.filter((e, i, a) => a.indexOf(e) == i).sort(function(a, b){return a - b});
console.log(finalResult);

如果需要第二个结果，可以使用另一个filter语句：

1
2
3

let arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];
let finalResult = arr.filter((e, i, a) => a.filter(f => f == e).length == 1).sort(function(a, b){return a - b});
console.log(finalResult);

相关讨论

对于第一部分，可以使用Set()和spread语法删除重复项。

1
2
3

let arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];
let res = [...new Set(arr)]
console.log(res)

第二部分可以使用reduce()。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

相关讨论

您可以使用array.prototype.reduce()创建一个hash对象，其中keys是数组中的数字，values是arr数组变量中重复出现的数字。

然后使用object.keys()：

删除所有重复的Object.keys(hash)。
删除所有重复项，但使用array.prototype.filter()进行筛选，以获取仅出现一次的数字

代码：

1
2
3
4
5
6
7
8
9
10
11

const arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];
const hash = arr.reduce((a, c) => (a[c] = (a[c] || 0) + 1, a), {});

// [1, 2, 3, 4, 5, 8, 9, 10];
const finalResultOne = Object.keys(hash);

// [1, 9, 10];
const finalResultTwo = Object.keys(hash).filter(k => hash[k] === 1);

console.log('finalResultOne:', ...finalResultOne);
console.log('finalResultTwo:', ...finalResultTwo);

您可以一次创建两个数组

1
2
3
4
5
6
7
8
9

let arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];
let unique = new Set();
let repeated = Array.from(arr.reduce((acc, curr) => {
acc.has(curr) ? unique.delete(curr) : acc.add(curr) && unique.add(curr);
return acc;
}, new Set()));

console.log(Array.from(unique))
console.log(repeated)

相关讨论

正如许多其他人所说，第一个只是[...new Set(arr)]。

对于第二种情况，只需过滤掉那些多次出现的情况：

1
2
3
4
5
6
7

const arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];

const count = (arr, e) => arr.filter(n => n == e).length

const unique = arr => arr.filter(e => count(arr, e) < 2)

console.log(unique(arr));

您可以对前面的数组进行排序，并通过只检查一侧是否重复或两侧来筛选数组。

1
2
3
4
5
6
7
8
9
10
11

var array = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10],
result1,
result2;

array.sort((a, b) => a - b);

result1 = array.filter((v, i, a) => a[i - 1] !== v);
result2 = array.filter((v, i, a) => a[i - 1] !== v && a[i + 1] !== v);

console.log(...result1);
console.log(...result2)

相关讨论

您可以使用closure和Map。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

let arr = [1, 2, 4, 2, 3, 3, 4, 5, 5, 5, 8, 8, 9, 10];

const build = ar => {
const mapObj = ar.reduce((acc, e) => {
acc.has(e) ? acc.set(e, true) : acc.set(e, false)
return acc
}, new Map())

return function(hasDup = true) {
if(hasDup) return [...mapObj.keys()]
else return [...mapObj].filter(([key, val]) => !val).map(([k, v])=> k)
}
}

const getArr = build(arr)

console.log(getArr())
console.log(getArr(false))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16