js实现数组去重(数组内对象去重)

1.遍历数组法

它是最简单的数组去重方法（indexOf方法）
实现思路：新建一个数组，遍历去要重的数组，当值不在新数组的时候（indexOf为-1）就加入该新数组中；

var arr=[2,8,5,0,5,2,6,7,2];
function unique1(arr){
	if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    var hash=[];
	for (var i = 0; i < arr.length; i++) {
	   if(hash.indexOf(arr[i])==-1){
	    hash.push(arr[i]);
	   }
	}
	return hash;
}

2.数组下标判断法

调用indexOf方法，性能和方法1差不多
实现思路：如果当前数组的第 i 项在当前数组中第一次出现的位置不是 i，那么表示第 i 项是重复的，忽略掉。否则存入结果数组。

function unique2(arr){
  var hash=[];
  for (var i = 0; i < arr.length; i++) {
     if(arr.indexOf(arr[i])==i){
      hash.push(arr[i]);
     }
  }
  return hash;
}
// 备注 原理一样
var arr = ['lisi','lucy','lily','hmm','lisi','lisi','hmm','lucy'];
var arr1 = arr.filter(function(item,index,array){
	return array.indexOf(item) === index;
})
console.log(arr1);

3.排序后相邻去除法

实现思路：给传入的数组排序，排序后相同的值会相邻，然后遍历排序后数组时，新数组只加入不与前一值重复的值。

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

4.优化遍历数组法（推荐）

实现思路：双层循环，外循环表示从0到arr.length，内循环表示从i+1到arr.length
将没重复的右边值放入新数组。（检测到有重复值时终止当前循环同时进入外层循环的下一轮判断）

function unique4(arr){
  var hash=[];
  for (var i = 0; i < arr.length; i++) {
    for (var j = i+1; j < arr.length; j++) {
      if(arr[i]===arr[j]){
        ++i;
      }
    }
      hash.push(arr[i]);
  }
  return hash;
}

5.ES6实现

基本思路：ES6提供了新的数据结构Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。
Set函数可以接受一个数组（或类似数组的对象）作为参数，用来初始化。

function unique5(arr){
  var x = new Set(arr);
 return [...x];
}
> 扩展：如果重复，则去掉该元素数组下标去重
function unique22(arr){
  var hash=[];
  for (var i = 0; i < arr.length; i++) {
     if(arr.indexOf(arr[i])==arr.lastIndexOf(arr[i])){
      hash.push(arr[i]);
     }
  }
  return hash;
}

6.利用for嵌套for，然后splice去重（ES5中最常用）

思路：利用双重for循环找出重复的元素，然后在使用splice()方法删除重复的一个
function unique(arr){            
        for(var i=0; i<arr.length; i++){
			cconsole.log(arr.length)
            for(var j=i+1; j<arr.length; j++){
            //检查是否有重复的元素
                if(arr[i]==arr[j]){        
               		 //有，就从数组中去除
					console.log('前',arr.length)
                    arr.splice(j,1);
					console.log('后',arr.length)
                    j--;
                }
            }
        }
return arr;
}
var arr = ['1','2','1','2','3']

function unique(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;
    }
    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(unique(arr))

filter(）+ indexOf( )

//思路：主要是利用filter()方法过滤掉重复的元素
function ArrayToHeavy(arr) {
    //过滤掉原数组中重复的数字,返回新的数组
    return arr.filter((item, index)=> {
        //遍历出数组中数字第一次出现的下标,与数字所在数组的下标相比较，
        //为true就是第一次出现
        return arr.indexOf(item) === index
    })
}
let arr =[1,21,2,24,3,3,7,4,4,5,5]
console.log(ArrayToHeavy(arr))
//打印的是 1, 21, 2, 24, 3, 7, 4, 5

push() + indexOf()

//思路：主要是利用indexOf()方法判断传入的数组值的是否在新数组存在，不存在就把传值push到新数组
function ArrayToHeavy(arr){
    //新建一个空数组
    let newArr = [];
    for(var i = 0; i < arr.length; i++ ){
        //遍历传入的数组，查找传入数组的值是否存在新数组中
         if(newArr.indexOf(arr[i]) === -1){
             //不存在就把值push到新数组
            newArr.push(arr[i]);
         }
    }
    //返回新的数组
    return newArr;
}
let a = [1,1,2,3,4,5,6,4,6,8,65,77];
console.log(ArrayToHeavy(a));
//打印的是 [1, 2, 3, 4, 5, 6, 8, 65, 77]

数组里面对象去重的3种方法

var arr = [{
      key: '01',
      value: '西施'
    }, {
      key: '02',
      value: '王昭君'
    }, {
      key: '03',
      value: '杨玉环'
    }, {
      key: '04',
      value: '貂蝉'
    }, {
      key: '01',
      value: '西施'
    }, {
      key: '01',
      value: '西施'
    }];

// 方法一
var result = [];
    var obj = {};
    for (var i = 0; i < arr.length; i++) {
      if (!obj[arr[i].key]) {
        result.push(arr[i]);
        obj[arr[i].key] = true;
      }
    }
    console.log(result); // [{key: "01", value: "西施"},{key: "02", value: "王昭君"},{key: "03", value: "杨玉环"},{key: "04", value: "貂蝉"}]
// 方法二
var result = [];
    for (var i = 0; i < arr.length; i++) {
      var flag = true;
      for (var j = 0; j < result.length; j++) {
        if (arr[i].key === result[j].key) {
          flag = false;
        }
      }
      if (flag) {
        result.push(arr[i]);
      }
    }
    console.log(result); // [{key: "01", value: "西施"},{key: "02", value: "王昭君"},{key: "03", value: "杨玉环"},{key: "04", value: "貂蝉"}]
// 方法三 (6的扩展)
 for (var i = 0; i < arr.length; i++) {
        for (var j = i + 1; j < arr.length; j++) {
            if (arr[i].key === arr[j].key) {
                arr.splice(j, 1);
                j = j - 1;
            }
        }
    }
    console.log(arr); //