最全的数组去重方法对比

本文最早发布于csdn，为原创

常规方法两种

let json = arr => {
let res = [],
obj = {};
arr.forEach(value => {
let key = typeof(value) + value;
!obj.hasOwnProperty(key) && (res.push(value), obj[key] = 1);
})
return res;
}

let sort = arr => {
//数组深拷贝，为不了影响原来的数组
let newArr = arr.concat();
newArr.sort();
for (var i = newArr.length; i > 0; i--) {
if ( newArr[i] === newArr[ i - 1 ] ) { // use == if '2' eq 2, else ===
newArr.splice( i, 1 );
}
}
return newArr;
}
第一种方法常用但是有坑

console.log(unique([ new String(1), new Number(1) ]))
//[String]0: String0: "1"length: 1proto: String[[PrimitiveValue]]: "1"length: 1proto:Array[0]

碰到这种情况就出问题了

第二种方法使用sort，sort方法返回的结果并不一定是升序，主要目的是将重复的数字排到一起

使用ES5的indexOf方法两种

let foreach = arr => {
arr.forEach(value => {
res.indexOf(value) == -1 && res.push(value);
}, res = [])
}
let unique = arr => {
let res = [];
arr.forEach(function(value) {
(res.indexOf(value) == -1) && res.push(value);
})
return res;
}
let arr = [1, 1, 2, 2];
unique3(arr);
console.log(res);

简洁优雅版

let filter = arr => { return arr.filter(function (value, index, array) { return index

es6奇技淫巧

2016.7.7更新
看到评论提醒的方法

let array = Array.from(new Set([1, 1, 1, 2, 3, 2, 4]));
console.log(array);
// => [1, 2, 3, 4]
补充说明，from方法现在浏览器支持程度不太好，另外经测试，性能也不具有优势

性能对比

2016.7.12更新，最近发现了一篇文章进行性能测试，觉得很赞，以后测性能就用这个了
benchmark地址

let benchmark = require('benchmark');
let suit = new benchmark.Suite;
let arr = [1, 1, 1, 2, 3, 2, 4];
let es6 = arr => {
let array = Array.from(new Set(arr));
};

let filter = arr => {
arr.filter((value, index, array) => { return index {
let res = [],
obj = {};
arr.forEach(value => {
let key = typeof(value) + value;
!obj.hasOwnProperty(key) && (res.push(value), obj[key] = 1);
})
return res;
}

let sort = arr => {
//数组深拷贝，为不了影响原来的数组
let newArr = arr.concat();
newArr.sort();
for (var i = newArr.length; i > 0; i--) {
if ( newArr[i] === newArr[ i - 1 ] ) { // use == if '2' eq 2, else ===
newArr.splice( i, 1 );
}
}
return newArr;
}

let foreach = arr => {
arr.forEach(value => {
res.indexOf(value) == -1 && res.push(value);
}, res = [])
}

suit.add('es6', function() {
es6(arr);
}).add('filter', function() {
filter(arr);
}).add('json', function() {
json(arr);
}).add('sort', function() {
sort(arr);
}).add('foreach', function() {
foreach(arr);
}).on('cycle', function(event) {
console.log(String(event.target));
}).on('complete', function() {
console.log('Fastest is ' + this.filter('fastest').map('name') + '\n slowest is ' + this.filter('slowest').map('name'));
}).run({'async': true});
在teminal运行node test.js得到如下结果

$ node 数组去重方法及对比.js
es6 x 275,353 ops/sec ±4.87% (63 runs sampled)
filter x 703,449 ops/sec ±1.49% (89 runs sampled)
json x 238,876 ops/sec ±5.24% (72 runs sampled)
sort x 217,857 ops/sec ±4.58% (64 runs sampled)
foreach x 915,368 ops/sec ±3.84% (65 runs sampled)
Fastest is foreach
slowest is sort

总结

以上所有方法都不会出现将1和"1"视作一起去重的情况，除开第一种，其他的方法也能区分开[new String(1), new Number(1)],这里的方法已经是比较全，和其他博客比起来只有一些实现上的差异，总体方法思想是一样的

参考资料

一行代码实现数组去重（ES6）
从 JavaScript 数组去重谈性能优化
js对象的hasOwnProperty为什么比数组的indexof方法在性能上高的多？
使用Benchmark.js和jsPerf分析代码性能
源代码github地址

关键字：JavaScript

版权声明

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处。如若内容有涉嫌抄袭侵权/违法违规/事实不符，请点击 举报 进行投诉反馈！