常用的方法:
- ES6 Set去重
- 双重for循环+splice()方法去重
- indexOf()去重
- includes()去重
- 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}
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 = array.concat().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 的去重。
本文章是根据所有的经验总结而来,入有侵权,联系删除