相对全面的数组去重

数组去重的方法

1. 遍历数组法

   最简单的去重方法，实现思路：新建一新数组，遍历传入数组，值不在新数组就加入该新数组；注意：判断值是否在数组的方法“indexOf”是ECMAScript5方法中，IE8以下不支持需多写一些兼容低版本浏览器代码，源码如下：

//最简单数组去重法
function unique1(array){
    var n = []; //一个新的临时数组
    //遍历当前数组
    for(var i = 0; i < array.length; i++){
        //如果当前数组的第i已经保存进了临时数组，那么跳过
        //否则把当前项push到临时数组中
        if(n.indexOf(array[i]) == -1){
            n.push(array[i]);
        }
    }
    return n;
}
//判断浏览器是否支持indexOf
if(!Array.prototype.indexOf){
	Array.prototype.indexOf = function(item){
		var result = -1,a_item = null;
		if(this.length == 0){
			return result;
		}
		for(var i = 0,len = this.length; i < len;i++){
			a_item = this[i];
			if(a_item === item){
				result = i;
				break;
			}
		}
		return result;
	}
}

2. 对象键值对法

   该方法执行的速度比较快，但占用内存比较大；实现思路：新建一js对象以及新数组，遍历传入数组时，判断值是否为js对象的值，不是的话给对象新增该键并放入新数组。注意：判断是否为js对象时，会自动对传入的键执行“toString（）”，不同的键可能会被误认为一样；如：a[4] , a[‘4’]。解决方法：调用”indexOf“。

function unique2(array){
    var n = {}, r = [], len = array.length, type, val;
    for(var i = 0; i < len; i++){
        val = array[i];
        type = typeof val;
        if(!n[val]){
           n[val] = [type];
           r.push(val); 
        }else if(n[val].indexOf(type) < 0){
            n[val].push(type);
            r.push(val);
        }
    }
    return r;
}

3. 数组下标法

   还是得调用“index Of”性能同方法1差不多，实现思路：如果当前数组的第i项在当前数组中出现的位置不是i，那么表示第i项是重复的。否则存入结果数组。

function unique3(array){
	var n = [array[0]];
	for(var i = 1; i < array.length; i++){
		if(array.indexOf(array[i]) === i){
			n.push(array[i]);
		}
	}
	return n;
}

4. 排序后相邻去除法

   虽然原生数组的“sort”方法排序后不怎么靠谱，但在不重视顺序的去重里该缺点毫无影响。实现思路：给传入的数组排序，排序后相同值相邻，然后遍历新数组只加入不与前一值重复的值。

function unique4(array){
	array.sort();
	var re = array[0];
	for(var i = 1; i < array.length; i++){
		if(array[i] !== re[re.length-1]){
			re.push(array[i]);
		}
	}
	return re;
}

5. 优化遍历数组法

   实现思路：获取没重复的最右一值放入新数组。（检测到有重复值时终止当前循环同时进入顶层循环的下一轮判断）

   function unique5(array){
       var re = [];
       for(var i = 0 , len = array.length; i < len; i++){
           for(var j = i + 1; j < len; j++){
               if(array[i] === array[j]){
                   ++i;
               }
           }
           re.push(array[i]);
       }
       return re;
   }

6. 在Array的原型上实现去重

   Array.prototype.unique6 = function(){
   	//this指向要操作的数组
   	return [...new Set(this)];
   }

7. 利用ES6中的Set + Array.from去重

   Set本身是一个构造函数，用来生成Set数据结构。它是一个类数组，成员的值都是唯一的。Array.from（）将类数组转为真正的数组。

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

8. 双层循环和splice去重

   function unique9(array){
       for(var i = 0; i < array.length; i++){
           for(var j = i + 1; j < array.length; j++){
               if(array[i] === array[j]){
                   array.splice(j,1);
                   j--;
                   console.log(array[i]);
               }
           }
       }
       return array;
   }

9. 利用includes去重

   不能去掉两个空的对象

   function unique9(array){
       var arr = [array[0]];
       for(var i = 1; i < array.length; i++){
           if(!arr.includes(array[i])){
               arr.push(array[i]);
           }
       }
       return arr;
   }

10. 利用hasOwnProperty判断是否存在对象属性。

    不能去掉两个空的对象

    function uniaue10(array){
        var obj = {};
        return arr.filter(function(item,index,array){
            return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
        });
    }

11. 利用filter去重

    function unique11(array){
        return array.filter(function(item,index,array){
            return array.indexOf(item,0) === index;
        });
    }

12. 利用map数据结构

    会将空对象看作两个对象，同时NaN与“NaNcy”也是不同的。

    function unique12(array){
        let map = new Map();
        let arr = new Array();
        for(let i = 0; i < array.length; i++){
            if(map.has(array[i])){
                map.set(array[i],true);
            }else{
                map.set(array[i],false);
                arr.push(array[i]);
            }
        }
        return arr;
    }