JavaScript数组去重的办法总结（附代码）
数组去重在日常开发中的使用频率还是较高的，也是网上随意一抓一大把的话题，所以，我写这篇文章目的在于归纳和总结，既然许多人都在提的数组去重，本人到底理解多少呢。又或者是假如本人在开发中碰到了去重的需求，本人能想到更好的解决方案吗。
这次我们来理一理如何做数组去重才能做得最适宜，既要思考兼容性，也要思考机能和代码的文雅。
我的学习途径是仿照冴羽(github: mqyqingfeng)的学习方式，感激像冴羽这样优异的人在前面领跑，我不想光看不做，所以多实践多输出，但愿将来能走出我本人的路。
一、入门方案
function unique(origin) {
var result = [];
for(var i = 0; i < origin.length; i++) {
var arrayItem = origin[i];
for(var j= 0; j< result.length; j++) {
var resultItem = result[j];
// 假如在结果数组轮回中寻到了该元素，则跳出轮回，进入下一个源数组元素的推断
if(resultItem === arrayItem) {
break;
}
}
// 假如把结果数组轮回完都没有寻到该元素，就将该元素压入结果数组中
if(j === result.length) {
result.push(arrayItem);
}
}
return result;
}
var array = ['a', 'b', 'c', '1', 0, 'c', 1, '', 1, 0];
console.log(unique(array)); // ["a", "b", "c", "1", 0, 1, ""]以上代码是最简便实现数组去重的方式，长处在于兼容性极好，缺陷就是两次 for 轮回，时间复杂度为 O(n^2)，机能较差。
二、数组的 indexOf 属性
数组中的 indexOf 属性是 ES5 的标准，只要 IE8 及更早版本不支撑该办法。相对来说，假如你不需要兼容 IE8 的话，尽量用 indexOf 来推断一个元素可否在数组中。
function unique(origin){
var result = [];
for(var i = 0; i< origin.length; i++) {
var item = origin[i];
if(result.indexOf(item) === -1) {
result.push(item);
}
}
return result;
}三、数组的 filter 属性
数组的 filter() 办法创立一个新的数组，新数组中的元素是通过检查指定数组中相符前提的所有元素。
filter 的回调有三个参数，其中第三个参数是当前元素属于的数组对象，这样我们可以连续利用 indexOf 属性啦。
function unique(origin) {
var result = origin.filter(function (item, index, array){
// 猎取元素在源数组的位置，只返回那些索引等于当前元素索引的值。
return array.indexOf(item) === index;
});
return result;
}filter 兼容到 IE9, 这种办法没有 for 轮回，主要利用了 filter 和 indexOf 属性，所以代码相对照较文雅。
四、利用 Object 的 key value
function unique(origin) {
var result = [];
var hashTable = {};
for(var i = 0; i< origin.length; i++) {
// 假如键对应的值，为真，意味着对象的键中已经有反复的键了。
if(!hashTable[origin[i]]) {
// 将元素作为对象的键，默许键对应的值为 true,
hashTable[origin[i]] = true;
// 假如对象中没有这个键，则将这个元素放入结果数组中去。
result.push(origin[i]);
}
}
return result;
}这种方案的事件复杂度为 O(n), 但是对象的键，默许是字符串类型，这意味着什么呢，数字 1 和 字符串 '1'，在键中是相等的，所以，上面这种办法不适合字符串和数字混合的去重。
所以我们将元素的类型也放入对象的键中：
function unique(origin) {
var result = [];
var hashTable = {};
for(var i = 0; i< origin.length; i++) {
var current = origin[i];
// 字符串拼接元素的类型和元素
var key = typeof(current) + current;
if(!hashTable[key]) {
hashTable[key] = true;
result.push(current);
}
}
return result;
}五、数组的 sort 办法
function unique(origin) {
return origin.concat.sort().filter(function(item, index, array) {
// !index 表示第 0 个元素应当被返回。
return !index || item !== origin[index-1]
})
}
function unique(array) {
array.sort(); // 排序字符串
array.sort(function(a, b) {
return a-b; // 排序数字
})
for(let i=0; i<array.length; i++) {
if(array[i] === array[i+1]) {
array.splice(i, 1);
i--; // 应当将前一个数删除，而不是删除后一个数。是由于元素被删除之后，后面元素的索引会迁移，所以要 i--;
}
}
return array;
}sort 办法的长处在于利用了排序，返回后一个和前一个不相等的元素。比力简约和直不雅。缺陷在于改动了元素的原本的排序位置。
六、ES6 Set
ES6 供给了新的数据构造 Set,它相似于数组，但是成员的值都是独一的，没有反复的值。向 Set 参加值的时候，不会发生类型改变，所以 5 和 '5' 是两个不一样的值。Set内部推断两个值可否雷同，用的是相似于 "==="的算法，但是不同是，在set内部认为NaN 等于 NaN ；
Set 可以转换为数组，所以很容易实现去重
function unique(origin) {
return Array.from(new Set(origin));
}七、ES6 Map
ES6 新增了 Map 数据结果，通过 has 和 set 办法就能很利便的对前面的 object key value 方案停止优化。
function unique(origin){
const map = new Map()
return origin.filter((item) => !map.has(item) && map.set(item, true))
}八、类型推断
一些常见的数据类型是 === 和 indexOf 是没法检测的，举个例子：
console.log({} === {}) // false;
console.log(NaN === NaN) // false;
console.log(/a/ === /a/); // false;
console.log(1 === new String('1')) // false;
var arr = [NaN];
console.log(arr.indexOf(NaN)); // -1所以在推断的时候，假如数据里有 NaN 和对象时要幸免使用 indexOf 和 ===;
前面 Set 那里说过了，所以 Set 办法是可以去重 NaN的。
总结
数据去重在网上已经看烦了，但还是想专门写一篇文章来实践和总结，能在工作中多几个思绪也是极好的。感激那些热爱分享和喜爱输出的人。
以上就是JavaScript数组去重的办法总结（附代码）的具体内容，更多请关注百分百源码网其它相关文章！
