JS数组、数组对象去重操作

数组去重操作

ES6 Set去重

function unique (arr) {
    
    
      return Array.from(new Set(arr))
  }
  var arr = [1,1,'true','true',true,true,undefined,undefined,null,null,NaN, NaN,{
    
    },{
    
    }];
  console.log(unique(arr))
  // [1, "true", true, undefined, null, NaN, {…}, {…}]

for循环+splice去重

function unique(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;
    }
    var arr = [1,1,'true','true',true,true,undefined,undefined,null,null,NaN, NaN,{
    
    },{
    
    }];
    console.log(unique(arr))
    //[1, "true", undefined, NaN, NaN, {…}, {…}]
    //NaN和{}没有去重，两个null直接消失了

indexOf去重

/*新建一个空的结果数组，for 循环原数组，判断结果数组是否存在当前元素，如果有相同的值则跳过，
不相同则push进数组。*/

function unique(arr) {
    
    
            if (!Array.isArray(arr)) {
    
    
                console.log('type error!')
                return
            }
            var array = [];
            for (var i = 0; i < arr.length; i++) {
    
    
                if (array .indexOf(arr[i]) === -1) {
    
    
                    array .push(arr[i])
                }
            }
            return array;
        }
        var arr = [1,1,'true','true',true,true,undefined,undefined,null,null,NaN, NaN,{
    
    },{
    
    }];
        console.log(unique(arr))
        //[1, "true", true, undefined, null, NaN, NaN, {…}, {…}]

利用sort()

function unique(arr) {
    
    
            if (!Array.isArray(arr)) {
    
    
                console.log('type error!')
                return;
            }
            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 arr = [1,1,'true','true',true,true,undefined,undefined,null,null,NaN, NaN,{
    
    },{
    
    }];
        console.log(unique(arr))
        //[1, NaN, NaN, {…}, {…}, null, "true", true, undefined]

利用includes

function unique(arr) {
    
    
            if (!Array.isArray(arr)) {
    
    
                console.log('type error!')
                return
            }
            var array =[];
            for(var i = 0; i < arr.length; i++) {
    
    
                    if( !array.includes( arr[i]) ) {
    
    //includes 检测数组是否有某个值
                            array.push(arr[i]);
                      }
            }
            return array
        }
        var arr = [1,1,'true','true',true,true,undefined,undefined,null,null,NaN, NaN,{
    
    },{
    
    }];
        console.log(unique(arr))
        //[1, "true", true, undefined, null, NaN, {…}, {…}]

使用hasOwnProperty去重

function unique(arr) {
    
    
            var obj = {
    
    };
            return arr.filter(function(item, index, arr){
    
    
                return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
            })
        }
        var arr = [1,1,'true','true',true,true,undefined,undefined,null,null,NaN, NaN,{
    
    },{
    
    }];
        console.log(unique(arr))
        //[1, "true", true, undefined, null, NaN, {…}] 可以看到都去重了
/*这里的typeof item + item可以输出"item数据类型 + item值"的字符串结果，然后通过hasOwnPrototype()
来判断obj内是否有这个数据类型的数据（hasOwnPrototype()不会攀升原型链），如果有那么就直接返回false，
根据filter()的用法，这个数据就会被过滤掉。
如果这个obj内没有这个类型的数据，那么就会通过obj[数据类型]的方式将这个类型存入obj中，并且设定值为true,
同时这个数据根据filter()的用法，会保留。*/

filter去重

function unique(arr) {
    
    
            return arr.filter(function(item, index, arr) {
    
    
              //当前元素在原始数组中的第一个索引==当前索引值时候返回当前元素
              return arr.indexOf(item, 0) === index;
            });
        }
        var arr = [1,1,'true','true',true,true,undefined,undefined,null,null,NaN, NaN,{
    
    },{
    
    }];
        console.log(unique(arr))
        //[1, "true", true, undefined, null, {…}, {…}]

递归去重

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,undefined,undefined,null,null,NaN, NaN,{
    
    },{
    
    }];
        console.log(unique(arr))
        //[1, "true", null, true, NaN, NaN, {…}, {…}, undefined]

map去重

function unique(arr) {
    
    
            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值则push进返回的数组
                array .push(arr[i]);
              }
            } 
            return array ;
        }
        var arr = [1,1,'true','true',true,true,undefined,undefined,null,null,NaN, NaN,{
    
    },{
    
    }];
        console.log(unique(arr))
        //[1, "true", true, undefined, null, NaN, {…}, {…}]

reduce+includes去重

function unique(arr){
    
    
			//pre上一次返回的值，cur当前值
            return arr.reduce((pre,cur) => prev.includes(cur) ? pre : [...pre,cur] , []);
            //pre不包含cur则将cur加入，否则返回pre作为下一次pre值 arr.reduce((pre,cur)=>pre,[])
        }
        var arr = [1,1,'true','true',true,true,undefined,undefined,null,null,NaN, NaN,{
    
    },{
    
    }];
        console.log(unique(arr));
        //[1, "true", true, undefined, null, NaN, {…}, {…}]

解构赋值+new Set()

//相当于第一种方法的简化
[...new Set(arr)]

数组中对象去重操作

reduce

var arr = [{
    
    
    id: 1,
    name: "张三",
    age: 18
}, {
    
    
    id: 2,
    name: "李四",
    age: 19
}, {
    
    
    id: 3,
    name: "王五",
    age: 20
}, {
    
    
    id: 1,
    name: "张三",
    age: 18
}];
var has = {
    
    };
arr = arr.reduce(function(item, next) {
    
    
    has[next.name] ? '' : has[next.name] = true && item.push(next);
    return item
}, [])
console.log(arr);
// [{"id":1,"name":"张三","age":18},{"id":2,"name":"李四","age":19},{"id":3,"name":"王五","age":20}]

map

var arr = [{
    
    name: '张三',id: 1}, {
    
    name: '张三',id: 1}, {
    
    name: '李四',id: 2}, {
    
    name: '王五',id: 3}];
let deWeightThree = (arr) => {
    
    
    let map = new Map();
    for (let item of arr) {
    
    
        if (!map.has(item.id)) {
    
    
            map.set(item.id, item);
        }
    }
    return [...map.values()];
}
let newArr = deWeightThree(arr);
console.log(newArr);