参考文章：浅析JS如何实现数组去重

ES6语法Set实现数组去重

Set对象是值的集合，你可以按照插入的顺序迭代它的元素。 Set中的元素只会出现一次，即 Set 中的元素是唯一的。

  1. var array = [1, 2, 1, 1, '1'];
  2. function unique(array) {
  3.    return Array.from(new Set(array));
  4. }
  5. console.log(unique(array)); // [1, 2, "1"]
  8. //可以简化为
  9. function unique(array) {
  10.     return [...new Set(array)];
  11. }

双重循环来实现数组去重

使用双重for循环将数组中数据一次对比，将相同数据筛去。一般来说，这种方法适用性是比较好的。

  1. var array = [1, 1, '1', '1'];
  2. function unique(array) {
  3.     // res用来存储结果
  4.     var res = [];
  5.     for (var i = 0, arrayLen = array.length; i < arrayLen; i++) {
  6.         for (var j = 0, resLen = res.length; j < resLen; j++ ) {
  7.             if (array[i] === res[j]) {
  8.                 break;
  9.             }
  10.         }
  11.         // 如果array[i]是唯一的，那么执行完循环，j等于resLen
  12.         if (j === resLen) {
  13.             res.push(array[i])
  14.         }
  15.     }
  16.     return res;
  17. }
  18. console.log(unique(array)); // [1, "1"]

splice实现

也可以不创建新的数组，而是使用splice方法将数组中相同的删掉

  1. function unique(arr){            
  2.         for(var i=0; i<arr.length; i++){
  3.             for(var j=i+1; j<arr.length; j++){
  4.                 if(arr[i]==arr[j]){         //第一个等同于第二个，splice方法删除第二个
  5.                     arr.splice(j,1);
  6.                     j--;
  7.                 }
  8.             }
  9.         }
  10. return arr;
  11. }

indexOf实现

同样也是双重循环，判断条件从两数相等变为用indexOf判断

  1. function unique(arr) {
  2.     if (!Array.isArray(arr)) {
  3.         console.log('type error!')
  4.         return
  5.     }
  6.     var array = [];
  7.     for (var i = 0; i < arr.length; i++) {
  8.         if (array .indexOf(arr[i]) === -1) {
  9.             array .push(arr[i])
  10.         }
  11.     }
  12.     return array;
  13. }

利用sort实现

先使用sort方法将数组排序重组，之后比较相邻位置大小，双重循环的变种

  1. function unique(arr) {
  2.     if (!Array.isArray(arr)) {
  3.         console.log('type error!')
  4.         return;
  5.     }
  6.     arr = arr.sort()
  7.     var arrry= [arr[0]];
  8.     for (var i = 1; i < arr.length; i++) {
  9.         if (arr[i] !== arr[i-1]) {
  10.             arrry.push(arr[i]);
  11.         }
  12.     }
  13.     return arrry;
  14. }

利用includes

  1. function unique(arr) {
  2.     if (!Array.isArray(arr)) {
  3.         console.log('type error!')
  4.         return
  5.     }
  6.     var array =[];
  7.     for(var i = 0; i < arr.length; i++) {
  8.             if( !array.includes( arr[i]) ) {//includes 检测数组是否有某个值
  9.                     array.push(arr[i]);
  10.               }
  11.     }
  12.     return array
  13. }

利用hasOwnProperty

  1. function unique(arr) {
  2.     var obj = {};
  3.     return arr.filter(function(item, index, arr){
  4.         return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
  5.     })
  6. }

利用map

  1. function arrayNonRepeatfy(arr) {
  2.   let map = new Map();
  3.   let array = new Array();  // 数组用于返回结果
  4.   for (let i = 0; i < arr.length; i++) {
  5.     if(map .has(arr[i])) {  // 如果有该key值
  6.       map .set(arr[i], true); 
  7.     } else { 
  8.       map .set(arr[i], false);   // 如果没有该key值
  9.       array .push(arr[i]);
  10.     }
  11.   } 
  12.   return array ;
  13. }

利用for…of + Object

首先创建一个空对象，然后用 for 循环遍历
利用对象的属性不会重复这一特性，校验数组元素是否重复

  1. function distinct(a, b) {
  2.     let arr = a.concat(b)
  3.     let result = []
  4.     let obj = {}
  5.     for (let i of arr) {
  6.         if (!obj[i]) {
  7.             result.push(i)
  8.             obj[i] = 1
  9.         }
  10.     }
  11.     return result
  12. }