js 查重 浅去重 深去重

查重

一：

var arr = [0,2,3,4,4];
var obj = {};
var tmp = [];
for(var i = 0 ;i< arr.length;i++){
   if( !obj[arr[i]] ){
      obj[arr[i]] = 1;
      tmp.push(arr[i]);
   }
}
console.log(tmp); //[0, 2, 3, 4]

二：

var arr = [2,3,4,4,5,2,2,3,3,6],
   arr2 = [];
for(var i = 0;i< arr.length;i++){
    if(arr2.indexOf(arr[i]) < 0){
        arr2.push(arr[i]);
    }
}
console.log(arr2); //[2, 3, 4, 5, 6]

三：

var arr = [2,3,4,4,5,2,3,6];
var arr2 = arr.filter(function(element,index,self){
return self.indexOf(element) === index;
});
console.log(arr2); //[2, 3, 4, 5, 6]

四

var ary = new Array("111","22","33","111");
var nary=ary.sort();
 for(var i=0;i<ary.length;i++){
 if (nary[i]==nary[i+1]){
  alert("数组重复内容："+nary[i]);
 }
}

五

function isRepeat(arr){
     var hash = {};
     for(var i in arr) {
         if(hash[arr[i]])
              return true;
         hash[arr[i]] = true;
     }
     return false;
}

注：有部分摘自网络

浅去重

无法去除含有 object 类型的数组

let arr = [1, "a", "1", "a"];

// es6 法
function foo1(arr) {
    return [...new Set(arr)]
}

// 双重循环 + map
function foo2(arr) {
    let obj = new Map()
    for (let i = 0; i < arr.length; i++) {
        if (!obj.has(arr[i])) obj.set(arr[i], 1)
    }
    return [...Array.from(obj.keys())]
}

// 前后对比法
function foo3(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;
}

// 双重循环法
function foo4(arr) {
    var res = [];
    for (var i = 0; i < arr.length; i++) {
        for (var j = i + 1; j < arr.length; j++) {
            if (arr[i] === arr[j]) {
                ++i;
            }
        }
        res.push(arr[i]);
    }
    return res;
}

// 单重循环
function foo5(arr) {
    let res = []
    for (let i = 0; i < arr.length; i++) {
        if (!res.includes(arr[i])) { // includes 是 ===
            res.push(arr[i])
        }
    }
    return res
}

// indexOf 方法
function foo6(arr) {
    return arr.filter((e, i) => arr.indexOf(e) === i);
}

深去重

let arr = [2, 3, '2', '4', 2, '4', { a: 1 }, { a: 1 }, { b: 2 }, { a: 5 }]

function repeat(arr) {
    let left = [], right = []

    // 简单数据类型和引用数据类型分开
    arr.map(res => { res instanceof Object ? left.push(res) : right.push(res) })

    // 排重简单类型
    right = right.filter((res, i, arr) => arr.indexOf(res) === i)

    // 排重复杂类型
    left = left.map(res => JSON.stringify(res))
    left = left.filter((res, i, arr) => arr.indexOf(res) === i)

    // 返回
    return [...right, ...left.map(res => JSON.parse(res))]
}

console.log(repeat(arr));
// [ 2, 3, '2', '4', { a: 1 }, { b: 2 }, { a: 5 } ]

let arr = [123, { a: 1 }, { a: { b: 1 } }, { a: "1" }, { a: { b: 1 } }, "meili"]

function repeat(arr) {
    arr = arr.map(res => JSON.stringify(res))
    arr = arr.filter((res, i, arr) => arr.indexOf(res) === i)
    arr = arr.map(res => JSON.parse(res))
    return arr
}

console.log(repeat(arr));
// [ 123, { a: 1 }, { a: { b: 1 } }, { a: '1' }, 'meili' ]

const responseList = [
    { id: 1, value: 1 },
    { id: 2, value: 2 },
    { id: 3, value: 3 },
    { id: 1, value: 4 },
    { id: 4, value: 1 },
];

const result = responseList.reduce((acc, cur) => {
    const ids = acc.map(item => item.id)
    const values = acc.map(item => item.value)
    return ids.includes(cur.id) || values.includes(cur.value) ? acc : [...acc, cur]
}, [])

console.log(result); // [ { id: 1, a: 1 }, { id: 2, a: 2 }, { id: 3, a: 3 } ]