※前端面试--数组去重的问题(js)

• Set去重 Array.from(new Set(arr)) 或者 [...new Set(arr)] 对象去不掉

function unique(arr){
	return [...new Set(arr)]
}

• 用双重循环的方式 对比 一样的不放入新的数组中，或者原地操作splice 对于NaN和对象都不能去重

function unique(arr){            
    for(let i=0;i<arr.length;i++){
        for(let j=i+1;j<arr.length;j++){
            if(arr[i] == arr[j]){
                arr.splice(j,1);
                j--;//删除了一个，避免后面的元素被漏
            }
        }
    }
return arr;
}

• sort之后 在比较相邻数 对于NaN和对象不能去重

function unique(arr){
    arr.sort((a,b)=> a-b);
    let array = new Array()
    for(let i=0;i<arr.length;i++){
        if(arr[i] !== arr[i+1]){
            array.push(arr[i])
        }
    }
    return array;
}

• 使用新的额外空间数组 循环遍历元素的时候，indexOf()方法， 对非重复元素放入新的数组中 对于NaN和对象都不能去重

function unique(arr){
    let a = [];
    for(let i=0; i<arr.length; i++){
        if(a.indexOf(arr[i]) == -1){
            //不含
            a.push(arr[i])
        }
    }
    return a;
}

• 使用新的额外空间数组 循环遍历元素的时候，includes()方法， 对非重复元素放入新的数组中 对于对象都不能去重
• 使用新的额外空间 map对象 循环遍历元素，使用has(key)判断属性值 ,Map的键可以是任意类型，所以对很多类型都可以去重 对于对象都不能去重

function unique(arr){
    let m = new Map();
    let array = []
    for(let i=0;i<arr.length;i++){
        if(m.has(arr[i])){
            m.set(arr[i],true)
        }else{
            m.set(arr[i],false);
            array.push(arr[i])
        }
    }
    return array
}

• 使用hasOwnProperty（判断实例上的属性）判断是否存在对象属性。对于对象却是可以去重，但是也存在问题，因为对象通过这个方法对比的时候，键都成了object[Object Object] 这样两个不一样的不该去重的对象也会被去重

function unique(arr){
    let a = {};
    for(let i=0;i<arr.length;i++){
        //注意要将键的唯一性找到  a里面的键名都是typeof item +item 转的字符串
        if(!(a.hasOwnProperty(typeof arr[i] + arr[i]))){
            a[typeof arr[i] + arr[i]] = arr[i]
        }
    }
    return Object.values(a);
}
//下面是对含有更为复杂的对象的情况 {name:1}{name:1}{name:2}
function unique(arr){
    let a = {};
    for(let i=0;i<arr.length;i++){
        if(typeof arr[i] !== 'object'){
            if(!(a.hasOwnProperty(typeof arr[i] + arr[i]))){
                a[typeof arr[i] + arr[i]] = arr[i]
            }
        }else{
            //对于对象，稍微复杂一些,将键值对拼接成唯一字符进行判断
            let str = '';
            for(let key in arr[i]){
                if(arr[i].hasOwnProperty(key)){
                    str += key;
                    str += arr[i][key]
                }
            }
            if(!(a.hasOwnProperty(typeof arr[i] + str))){
                a[typeof arr[i] + str] = arr[i]
            }
        }
    }
    return Object.values(a);
}

• 使用reduce加上includes 对于对象都不能去重