方法一：利用ES6的 Set去重 (ES6中最常用)

var arr=[1,2,3,3,4,4,5,5,6,6,7]
function ArrayToHeavy(arr){
    return Array.from(new Set(arr))
}
console.log(ArrayToHeavy(arr))
// [1,2,3,4,5,6,7]

方法二：利用for嵌套for,然后splice去重 (ES5中最常用)

var arr=[1,2,3,3,4,4,5,5,6,6,7]
function ArrayToHeavy(arr) { 
    for (let i=0, len=arr.length; i<len; i++) { 
        for (let j=i+1; j<len; j++) { 
            if (arr[i] == arr[j]) { 
                arr.splice(j, 1); 
                // splice 会改变数组长度，所以要将数组长度 len 和下标 j 减一 
                len--; 
                j--; 
            } 
        } 
    }
    return arr; 
}
console.log(ArrayToHeavy(arr))
// [1,2,3,4,5,6,7]

function uniqueFunc3(arr, uniId){ 
    let obj = {} 
    let tempArr = [] 
    for(var i = 0; i<arr.length; i++){ 
        if(!obj[arr[i][uniId]]){ 
            tempArr.push(arr[i]) obj[arr[i][uniId]] = true 
        } 
    } 
    return tempArr 
}

方法三：利用 Array.sort() 加一行遍历冒泡(相邻元素去重)

var arr=[1,2,3,3,4,4,5,5,6,6,7]
function ArrayToHeavy(arr) {
    var res = [];
    var sortedArray = arr.concat().sort();
    var seen;
    for (var i = 0, len = sortedArray.length; i < len; i++) {
        // 如果是第一个元素或者相邻的元素不相同
        if (!i || seen !== sortedArray[i]) {
            res.push(sortedArray[i])
        }
        seen = sortedArray[i];
    }
    return res;
}
console.log(ArrayToHeavy(arr))
// [1,2,3,4,5,6,7]

方法四：利用 Object 键值对去重

var arr=[1,2,3,3,4,4,5,5,6,6,7]
function ArrayToHeavy(array) { 
    var obj = {}; 
    return array.filter(function(item, index, array){ 
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true) 
    }) 
}
console.log(ArrayToHeavy(arr))
// [1,2,3,4,5,6,7]

方法五：利用 reduce 实现对象数组去重复

var resources = [ 
    { name: "张三", age: "18" }, 
    { name: "张三", age: "19" }, 
    { name: "张三", age: "20" }, 
    { name: "李四", age: "19" }, 
    { name: "王五", age: "20" }, 
    { name: "赵六", age: "21" } 
] 
var temp = {}; 
resources = resources.reduce((prev, curv) => { 
    // 如果临时对象中有这个名字，什么都不做 
    if (temp[curv.name]) { 
    } 
    // 如果临时对象没有就把这个名字加进去，同时把当前的这个对象加入到prev中 
    else { 
        temp[curv.name] = true;
        prev.push(curv); 
    } 
    return prev 
}, []); 
console.log("结果", resources);
// [ 
    { name: "张三", age: "18" }, 
    { name: "李四", age: "19" }, 
    { name: "王五", age: "20" }, 
    { name: "赵六", age: "21" } 
  ] 

function uniqueFunc2(arr, uniId){ 
    let hash = {} 
    return arr.reduce((accum,item) => { 
    hash[item[uniId]] ? '' : hash[item[uniId]] = true && accum.push(item) return accum 
    },[]) 
}

方法五：利用 使用filter和Map去重

function uniqueFunc(arr, uniId){ 
    const res = new Map(); 
    return arr.filter((item) => !res.has(item[uniId]) && res.set(item[uniId], 1)); 
}

方法六：利用 indexOf去重

let arr = [12,1,12,3,1,88,66,9,66]; 
function unique(ary) { 
    let newAry = [];
    for(let i=0;i<ary.length;i++){ 
        let cur = ary[i]; 
        if(newAry.indexOf(cur)===-1){ 
            newAry.push(cur); 
        } 
    } 
    return newAry; 
} 
unique(arr)
// [12, 1, 3, 88, 66, 9]

方法七：利用 sort去重

let arr = [12,1,12,3,1,88,66,9,66]; 
function unique(ary) { 
    let a = ary.sort(function (a,b) { 
        return a-b; 
    }); 
    for(let i=0;i<a.length;i++){ 
        if(a[i]===a[i+1]){ 
            a.splice(i+1,1); i--; 
        } 
    } 
    return a; 
} 
unique(arr)
//  [1, 3, 9, 12, 66, 88]

方法八：利用 includes :包含；如果数组包含那一项，返回true；不包含返回false；

let arr = [12,1,12,3,1,88,66,9,66]; 
function unique(ary) { 
    let newAry = []; 
    let len = ary.length; 
    for(let i=0;i<len;i++){ 
    let cur = ary[i]; 
        if(!newAry.includes(cur)){ 
            newAry.push(cur); 
        } 
    } 
    return newAry; 
} 
console.log(unique(arr));
//  [12, 1, 3, 88, 66, 9]

方法九：利用 hasOwnProperty : 检测属性名是否是对象的一个私有属性;返回一个布尔值；

let arr = [12,1,12,3,1,88,66,9,66]; 
function unique(ary) { 
    let obj = {}; 
    return ary.filter(function (item,index,a) { 
    // item : 数组每一个成员 
    // index: 成员对应的索引 
    // a : 整个数组 
    // hasOwnProperty来校验的该属性是否出现过； 
    return obj.hasOwnProperty(typeof item+item)?false:obj[typeof  item+item]=true; 
        if(obj.hasOwnProperty(typeof item+item)){ 
            return false 
        }else{ 
            obj[typeof item+item]=true; return true; 
        } 
    }) 
} 
console.log(unique(arr))
// [12, 1, 3, 88, 66, 9]

方法十：利用filter+indexOf

let arr = [12,1,12,3,1,88,66,9,66]; 
function unique(ary) { 
    return ary.filter(function (item,index,a) { 
        return ary.indexOf(item)===index; 
    }) 
} 
console.log(unique(arr));
// [12, 1, 3, 88, 66, 9]

方法十一：利用 递归

let arr = [12,1,12,3,1,88,66,9,66];
function unique(ary) {
    let  len= ary.length;
    ary = ary.sort(function (a,b) {
        return a-b;
    });
    function loop(index) {
        if(index>=1){
            if(ary[index]===ary[index-1]){
                ary.splice(index,1);
            }
            loop(index-1)
        }
    }
    loop(len-1);
    return ary;
}
console.log(unique(arr));
// [1, 3, 9, 12, 66, 88]

方法十二：利用 filter对数组对象去重

allThelist.filter(item =>
    obj[item.ip] ? '' : (obj[item.ip] = true)
);