数组去重⽅法总结
常⽤的⽅法：
1. ES6 Set去重
2. 双重for循环+splice()⽅法去重
3. indexOf()去重
4. includes()去重
5. filter()⽅法去重
ES6 中的 Set 去重
Set 数据结构，类似数组，区别在于它所有的成员都是唯⼀的，不能有重复的值。它本⾝是⼀个构造函数。
let arr =[1,2,2,3];
let set=new Set(arr);
console.log(set);//{1,2,3} 是⼀个对象
let newArr = Array.from(set);//将对象转成数组
console.log(newArr);// [1, 2, 3]
// 最终简化为⼀⾏代码：
let array = Array.from(new Set([1, 2, 2, 3]))
console.log(array )
拓展了解：
let arr = [1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5];
let set = new Set(arr);
console.log(set);
console.log(set.size); //5
console.log(set.add(9)); //Set(6) {1, 2, 3, 4, 5, 9}
lodash有哪些方法console.log(set.delete(9)); //true
console.log(set.has(9)); // false 因为上⾯已经删除
set.clear(); // 清空set数据结构中的所有数据
console.log(set); //Set(0) {}
// let testArr = new Array() // ⽤来去重数组
// console.log(testArr)
// let newArr = Array.from(set) // 把类数组转成数组
// console.log(newArr) // [1, 2, 3]
set数据结构打印如下：
Array.form可以把⼀个类数组或者可⽐案例对象转化成⼀个真正的数组
使⽤新数组变量来装去过重的数组去重⽅法：
<script>
//定义⼀个数据重复的数组
var arr = [1,2,3,45,2,3,1,5,8,9];
//定义⼀个空数组，⽤于接收去重后的数组元素
var newarr = [];
//便利arr数组，判断新数组的在这个位置有⽊有这个元素，如果有返回0，没有就返回-1，
//这⾥⼤家⾃⼰打印
for(var i = 0;i<arr.length;i++){
if(newarr.indexOf(arr[i])<0){
newarr.push(arr[i])
}
}
console.log(newarr);//[1, 2, 3, 45, 5, 8, 9]
</script>
使⽤对象⽅法来数组去重
var array = [1, '1', 1, 2, 3, 2, 4];
var tmpObj = {};
var result = [];
array.forEach(function(a) {
var key = (typeof a) + a;
if (!tmpObj[key]) {
tmpObj[key] = true;
result.push(a);
}
});
console.log(result);
// => [1, "1", 2, 3, 4]
Object 键值对⽅法：
function distinct(array) {
var obj = {};
return array.filter(function(item, index, array){
return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
})
}
这种⽅法是利⽤⼀个空的 Object 对象，我们把数组的值存成 Object 的 key 值，⽐如 Object[value1] = true，在判断另⼀个值的时候，如果 Object[value2]存在的话，就说明该值是重复的，但是最后请注意这⾥obj[typeof item + item] = true没有直接使⽤obj[item]，是因为 123 和 '123' 是不同的，直接使⽤前⾯的⽅法会判断为同⼀个值，因为对象的键值只能是字符串，所以我们可以使⽤ typeof item + item 拼成字符串作为 key 值来避免这个问题。
双层 for 循环
function distinct(arr) {
for (let i=0, len=arr.length; i<len; i++) {
for (let j=i+1; j<len; j++) {
if (arr[i] == arr[j]) {
arr.splice(j, 1);
// splice 会改变数组长度，所以要将数组长度 len 和下标 j 减⼀
len--;
j--;
}
}
}
return arr;
}
// splice(index,howManny)  从什么位置开始删除，删除的个数。返回删除之后的新的数组
Array.filter() 加 indexOf
思想: 利⽤indexOf检测元素在数组中第⼀次出现的位置是否和元素现在的位置相等，如果不等则说明该元素是重复元素
function distinct(a, b) {
let arr = a.concat(b);
return arr.filter((item, index)=> {
return arr.indexOf(item) === index
})
}
// filter() ⽅法创建⼀个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
// 注意： filter() 不会对空数组进⾏检测。
// 注意： filter() 不会改变原始数组。
Array.sort() 加⼀⾏遍历冒泡(相邻元素去重)
function distinct(array) {
var res = [];
var sortedArray = at().sort();
var seen;
for (var i = 0, len = sortedArray.length; i < len; i++) {
// 如果是第⼀个元素或者相邻的元素不相同
if (!i || seen !== sortedArray[i]) {
res.push(sortedArray[i])
}
seen = sortedArray[i];
}
return res;
}
思想: 调⽤了数组的排序⽅法 sort()，V8引擎的 sort() ⽅法在数组长度⼩于等于10的情况下，会使⽤插⼊排序，⼤于10的情况下会使⽤快速排序(sort函数在我之前⾼阶函数那篇⽂章有详细讲解【JS必知必会】⾼阶函数详解与实战)。然后根据排序后的结果进⾏遍历及相邻元素⽐对(其实就是⼀⾏冒泡排序⽐较)，如果相等则跳过该元素，直到遍历结束。
第三⽅库lodash数组去重
简单说下 lodash 的 uniq ⽅法的源码实现。
这个⽅法的⾏为和使⽤ Set 进⾏去重的结果⼀致。
当数组长度⼤于等于 200 时，会创建 Set并将 Set 转换为数组来进⾏去重（Set 不存在情况的实现不做分析）。当数组长度⼩于 200时，会使⽤类似前⾯提到的 双重循环 的去重⽅案，另外还会做 NaN 的去重。
本⽂章是根据所有的经验总结⽽来，⼊有侵权，联系删除

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。