JS 数组去重

1.使用Set将数组转换为Set对象，Set对象会自动去除重复元素，之后再将Set对象转换为数组；Array.from()方法是将一个类数组对象或可遍历对象转换成一个真正的数组。

var arr = [1, 2, 2, 4, 3, 5];
var newArr = Array.from(new Set(arr));
console.log(newArr); // [1,2,3,4,5]

2.使用Set+扩展运算符去重。

var arr = [1,2,2,4,3,5];
var newArr = [... new Set(arr)];
console.log(newArr); //[1,2,3,4,5]

3.使用Map()去重。其本质也是键值对，只是其键不局限于普通对象的字符串。

let list = ['你是最棒的2', 8, 8, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 1, 2, 3, 4, 5, 6, 7, 8, '你是最棒的2',]
let newList3 = [];
let map = new Map()
list.forEach((item) => {
    if (!map.has(item)) {//如果item不存在就设置key和value，若map存在item就不执行
        map.set(item,ture)
        newList3.push(item)
    }
})
console.log('newList3', newList3);

4.使用indexOf()去重，方法可返回某个指定的字符串值在字符串中首次出现的位置

var arr = [1,2,2,4,3,5];
function unique(arr) {
    var Arr = [];
    for (var i = 0; i < arr.length; i++) {
        if (Arr.indexOf(arr[i]) === -1) {
            Arr.push(arr[i])
        }
    }
    return Arr;
}
console.log(unique(arr))； //[1,2,3,4,5]

5.使用includes去重，判断一个数组是否包含一个指定的值，如果是返回 true，否则false。

var arr = [1,2,2,4,3,5];
let newArr = [];
arr.forEach((item) => {
    if (!newArr.includes(item)) {
        newArr.push(item);
    }
});
console.log(newArr); //[1,2,3,4,5]

6.组合Map和filter方法去重。

var arr = [1,1,2,undefined,undefined,NaN,NaN];
function unique(arr){
    var map = new Map();
    return arr.filter((a)=> !map.has(a) && map.set(a,1));
}
var newArr = unique(arr);
console.log(newArr); //[1,undefined,NaN]

7.组合filter+inidexOf方法去重：通过filter()方法遍历数组，返回仅包含首次出现的元素的新数组。

var arr = [1,2,2,4,3,5];
var newArr = arr.filter((item, index) => arr.indexOf(item) === index);
console.log(newArr); // [1,2,3,4,5]

8.组合reduce+inicludes方法去重：通过reduce()方法遍历数组，将元素存储在一个临时对象中，每次遇到重复元素时将其跳过，最后返回所有不重复元素的数组。

var arr = [1,2,2,4,3,5];
var newArr = arr.reduce((prev, cur) => prev.includes(cur) ? prev : [...prev, cur], []);
console.log(newArr); // [1, 2, 3, 4, 5]

9.使用for嵌套for，然后splice去重(es5常用)。外层循环元素，内层循环时比较值。值相同时，则删去这个值。

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

10.利用对象的属性不能相同的特点去重(这种数组去重有问题不推荐)。

function unique(arr) {
    var Arr = [];
    var obj = {};
    for (var i = 0; i < arr.length; i++) {
        if (!obj[arr[i]]) {
            Arr.push(arr[i])
            obj[arr[i]] = 1
            console.log(obj[arr[i]])
        } else {
            obj[arr[i]]++
            console.log(obj[arr[i]])
        }
    }
    return Arr;
}
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))
//[1, "true", 15, false, undefined, null, NaN, 0, "a", {…}] //两个true直接去掉了，NaN和{}去重

11.利用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,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
    console.log(unique(arr))
//[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}]   //所有的都去重了