JavaScript中 数组去重的一些方法

1. for循环(两次嵌套) + 新数组

   function deduplication(arr) {
   	var flag = 0;
   	// 创建一个新数组
   	var result = new Array();
   	// 遍历原数组
   	for(var i = 0; i < arr.length; i++) {
   		flag = 0;
   		for(var j = 0; j < arr.length; j++) {
   			// 判断数组内是否已经存在当前元素
   			if(result[j] == arr[i]) {
   				// 相同值跳过
   				flag = 1;
   				break;
   			}
   		}
   		// 不同值push进新数组
   		if(flag == 0)
   			result.push(arr[i]);
   	}
   	// 返回新数组
   	return result;
   }
   

   新建一个空数组，for循环遍历原数组，判断数组内是否已存在当前元素，如有相同的值则跳过，不同的推入新数组中，直至原数组遍历完，返回新数组，涉及到多次遍历，执行时间较长；

2. for循环(两次嵌套) + splice

   function deduplication(arr) {
   	for (var i = 0; i < arr.length; i++) {
   		for (var j = i + 1; j < arr.length; j++) {
   			if (arr[i] == arr[j]) {
   				//两者相等时，splice方法删除第二个
   				arr.splice(j, 1);
   				j--;
   			}
   		}
   	}
   	return arr;
   }
   

   双层循环，外层循环元素，内层循环时比较值，值相同时，删除这个值；

3. for循环(一次) + indexOf() + 新数组

   function deduplication(arr) {
   	// 创建新数组
   	var result = new Array();
   	for (var i = 0; i < arr.length; i++) {
   		// 判断新数组中是否存在当前遍历元素
   		if (result.indexOf(arr[i]) == -1)
   			// 不存在则push到新数组中
   			result.push(arr[i]);
   	}
   	// 返回新数组
   	return result;
   }
   

   对新数组判定是否有该字符，调用 Array.prototype.indexOf 函数，执行时间相对于 方法1 缩减了很多；

4. sort方法

   function deduplication(arr) {
   	// 数组排序
   	arr = arr.sort()
   	var result = [arr[0]];
   	for (var i = 1; i < arr.length; i++) {
   		// 相邻元素比较
   		if (arr[i] !== arr[i - 1]) {
   			// 相邻元素不相等push进数组
   			result.push(arr[i]);
   		}
   	}
   	// 返回新数组
   	return result;
   }
   

   利用sort()排序方法，然后根据排序后的结果进行遍历及相邻元素对比;

5. 利用Map去重

   function deduplication(arr) {
   	let map = new Map();
   	let result = new Array();
   	for (let i = 0; i < arr.length; i++) {
   		// 如果有该key值
   		if (map.has(arr[i])) {
   			map.set(arr[i], true);
   		} else {
   			// 如果没有该key值
   			map.set(arr[i], false);
   			result.push(arr[i]);
   		}
   	}
   	// 返回新数组
   	return result;
   }
   

   利用 ES6 中的 Map 集合替代前面方法中的新数组，调用Map.has替代indexOf()，Map.set 替代push()，执行速度比前面的方法都要快;

6. new Set() + Array.from()

   function deduplication(arr) {
   	return Array.from(new Set(arr));
   }
   

   利用 ES6 中的 Set 集合，Set 集合是一种无重复元素的列表，new Set(arr)会自动剔除重复元素，Array.from(...)将 Set 集合转换为数组;

7. new Set() + …(展开运算符)

   function deduplication(arr) {
   	return [...(new Set(arr))];
   }
   

   思路与方法6一致，只是将 Set 集合转换为数组的实现方法从 Array.from(...) 改成了 ...(展开运算符);

8. for循环(一次) + 新对象

   function deduplication(arr) {
   	let obj = {};
   	for (let i = 0; i < arr.length; i++) {
   		if (!obj[arr[i]]) {
   			obj[arr[i]] = 1;
   		}
   	}
   	return Object.keys(obj);;
   }
   

   将创建一个新数组，改成创建一个新对象，判定对象的 key 值，存在跳过，不存在则将字符以对象的 key 值存储, 这种方法也是所有方法中执行时间最短的；