在实际开发中，总会遇到对数组进行去重处理，

一：利用ES6 Set去重，唯一值的概念

		var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
		console.log(Array.from(new Set(arr)))

二：利用for嵌套for，然后splice去重，外层循环元素，内层循环比较值，找到相同，然后直接删除相同的数据

				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--;
						}
					}
				}
			
		

三：利用indexOf去重，找到返回对应下标，找不到返回-1，找不到就追加到新数组

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

四：利用sort()，排序方法，然后对相邻元素进行遍历比较

                  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;      

五：利用对象的属性不能相同的特点进行去重

                  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;

六：利用includes， 检测数组是否有某个值

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

七：利用hasOwnProperty，判断是否存在对象属性

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

八：利用filter

    arr.filter(function(item, index, arr) {
			//当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
			return arr.indexOf(item, 0) === index;
		  });

九：利用递归去重,不停的调用自身进行比较

            function loop(index){
				if(index >= 1){
					if(array[index] === array[index-1]){
					array.splice(index,1);
					}
					loop(index - 1);    //递归loop，然后数组去重
				}
			}
			loop(len-1);

十：利用Map数据结构去重

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 ;

十一：利用reduce+includes

return arr.reduce((prev,cur) => prev.includes(cur) ? prev : [...prev,cur],[]);

十二：[...new Set(arr)]，数据的唯一性原理

[...new Set(arr)]