数组去重的方法
设置全局变量
var arr = [1, 1, true, true, false, false, undefined, undefined, null, null, NaN, NaN, 'NaN', 'a', 'a', {}, {}, { name: '张三' }, { name: '张三' }, { name: '李四' }]
1、利用 ES6 的 Set()
方法去重(ES6中最常用)
原理: Set 是ES6新增的一种新集合类型。它类似于数组,但是成员的值都是唯一的,没有重复的值。其本身是一个构造函数,用来生成 Set 数据结构。
缺点: 空对象({}
) 和 内容相同的对象({ name: '张三' }
)未被去重。
function methods1(arr) {
return Array.from(new Set(arr));
}
console.log('methods1输出结果', methods1(arr)); // methods1输出结果 (13) [1, true, false, undefined, null, NaN, 'NaN', 'a', {}, {}, { name: '张三' }, { name: '张三' }, { name: '李四' }]
2、利用for嵌套for,然后splice去重(ES5中最常用)
原理: 双层循环,外层循环元素,内层循环时比较值;值相同时,则删去这个值。
缺点: NaN
、空对象({}
)和内容相同的对象({ name: '张三' }
)未被去重;而 true
和 null
全部被删去了。
function methods2(arr) {
for (var i = 0; i < arr.length; i++) {
for (var j = i + 1; j < arr.length; j++) {
if (arr[i] == arr[j]) {
arr.splice(j, 1); //第一个等同于第二个,splice方法删除第二个
j--;
}
}
}
return arr;
}
console.log('methods2输出结果', methods2(arr)); // methods2输出结果 (12) [1, false, undefined, NaN, NaN, 'NaN', 'a', {}, {}, { name: '张三' }, { name: '张三' }, { name: '李四' }]
3、利用 indexOf() 去重
原理: 建一个空的结果数组,for循环原数组,判断结果数组是否存在当前元素,如果有相同的值则跳过,不相同则 push 进结果数组。
缺点: NaN
、空对象({}
)和内容相同的对象({ name: '张三' }
)未被去重;
function methods3(arr) {
if (!Array.isArray(arr)) {
return;
}
var array = [];
for (var i = 0; i < arr.length; i++) {
if (array.indexOf(arr[i]) === -1) {
array.push(arr[i]);
}
}
return array;
}
console.log('methods3输出结果', methods3(arr)); // methods3输出结果 (14) [1, true, false, undefined, null, NaN, NaN, 'NaN', 'a', {}, {}, { name: '张三' }, { name: '张三' }, { name: '李四' }]
4、利用 sort() 去重
原理: 利用 sort()
排序方法,然后根据排序后的结果进行遍历并与相邻的元素进行对比,相同则删去,不同则保留。
缺点: NaN
、空对象({}
)和内容相同的对象({ name: '张三' }
)未被去重;
function methods4(arr) {
if (!Array.isArray(arr)) {
return;
}
arr = arr.sort();
var arrry = [arr[0]];
for (var i = 1; i < arr.length; i++) {
if (arr[i] !== arr[i - 1]) {
arrry.push(arr[i]);
}
}
return arrry;
}
console.log('methods4输出结果', methods4(arr)); // methods4输出结果 (14) [1, NaN, NaN, 'NaN', {}, {}, { name: '张三' }, { name: '张三' }, { name: '李四' }, 'a', false, null, true, undefined]
5、利用对象的属性不能相同的特点进行去重(这种数组去重的方法有问题,不建议使用,有待改进)
缺点: NaN
和 对象(引用类型) 只保留了第一个。
function methods5(arr) {
if (!Array.isArray(arr)) {
return;
}
var arrry = [];
var obj = {};
for (var i = 0; i < arr.length; i++) {
if (!obj[arr[i]]) {
arrry.push(arr[i]);
obj[arr[i]] = 1;
} else {
obj[arr[i]]++;
}
}
return arrry;
}
console.log('methods5输出结果', methods5(arr)); // methods5输出结果 (8) [1, true, false, undefined, null, NaN, 'a', {}]
6、利用 includes()
缺点: 空对象({}
)和内容相同的对象({ name: '张三' }
)未被去重;
function methods6(arr) {
if (!Array.isArray(arr)) {
return;
}
var array = [];
for (var i = 0; i < arr.length; i++) {
if (!array.includes(arr[i])) {
//includes 检测数组是否有某个值
array.push(arr[i]);
}
}
return array;
}
console.log('methods6输出结果', methods6(arr)); // methods6输出结果 (13) [1, true, false, undefined, null, NaN, 'NaN', 'a', {}, {}, { name: '张三' }, { name: '张三' }, { name: '李四' }]
7、利用 hasOwnProperty(推荐使用)
原理: 利用 hasOwnProperty 判断是否存在对象属性
缺点: 对象(引用类型)只保留了第一个。
function methods7(arr) {
var obj = {};
return arr.filter(function (item, index, arr) {
return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true);
});
}
console.log('methods7输出结果', methods7(arr)); // methods7输出结果 (9) [1, true, false, undefined, null, NaN, 'NaN', 'a', {}]
8、利用 filter() 方法
缺点: NaN
全部被去除了;空对象({}
)和内容相同的对象({ name: '张三' }
)未被去重;
function methods8(arr) {
return arr.filter(function (item, index, arr) {
//当前元素,在原始数组中的第一个索引==当前索引值,否则返回当前元素
return arr.indexOf(item, 0) === index;
});
}
console.log('methods8输出结果', methods8(arr)); // methods8输出结果 (12) [1, true, false, undefined, null, 'NaN', 'a', {}, {}, { name: '张三' }, { name: '张三' }, { name: '李四' }]
9、利用递归去重
缺点: NaN
、空对象({}
)和内容相同的对象({ name: '张三' }
)未被去重;
function methods9(arr) {
var array = arr;
var len = array.length;
array.sort(function (a, b) {
//排序后更加方便去重
return a - b;
});
function loop(index) {
if (index >= 1) {
if (array[index] === array[index - 1]) {
array.splice(index, 1);
}
loop(index - 1); //递归loop,然后数组去重
}
}
loop(len - 1);
return array;
}
console.log('methods9输出结果', methods9(arr)); // methods9输出结果 (14) [false, null, 1, true, NaN, NaN, 'NaN', 'a', {}, {}, { name: '张三' }, { name: '张三' }, { name: '李四' }, undefined]
10、利用Map数据结构去重
原理: 建一个空 Map()
数据结构,遍历需要去重的数组,把数组的每一个元素作为 key 存在 Map 中。由于 Map 中不会出现相同的 key 值,所以最终得到的就是去重后的结果。
缺点: 空对象({}
)和内容相同的对象({ name: '张三' }
)未被去重;
function methods10(arr) {
let map = new Map();
let array = new Array(); // 数组用于返回结果
for (let i = 0; i < arr.length; i++) {
if (map.has(arr[i])) {
// 如果有该key值
map.set(arr[i], true);
} else {
map.set(arr[i], false); // 如果没有该key值
array.push(arr[i]);
}
}
return array;
}
console.log('methods10输出结果', methods10(arr)); // methods10输出结果 (13) [1, true, false, undefined, null, NaN, 'NaN', 'a', {}, {}, { name: '张三' }, { name: '张三' }, { name: '李四' }]
11、利用 reduce + includes
缺点: 空对象({}
)和内容相同的对象({ name: '张三' }
)未被去重;
function methods11(arr) {
return arr.reduce((prev, cur) => (prev.includes(cur) ? prev : [...prev, cur]), []);
}
console.log('methods11输出结果', methods11(arr)); // methods11输出结果 (13) [1, true, false, undefined, null, NaN, 'NaN', 'a', {}, {}, { name: '张三' }, { name: '张三' }, { name: '李四' }]