js数组的去重方法总结

数组去重的方法

设置全局变量

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: '李四' }]