常见前端面试题--数组去重

1. 利用ES6 Set去重（ES6最常用）
   new Set，用来去重数组
   Set类似于数组，区别在于它所有的成员都是唯一的，不能有重复的值

function unique(arr) {
    return Array.from(new Set(arr));
}
let arr = [1, 1, '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, undefined, null, null, NaN, 'NaN', 0, 'a', {}, {}]
//无法去掉'{}'空对象

2. 利用for嵌套for，然后splice去重（ES5常用）

function unique(arr) {
    for(let i =0; i < arr.length; i++) {
        for(let j = i +1; j < arr.length; j++) {
            // 第一个等同于第二个，splice方法删除第二个
            if (arr[i] == arr[j]) {
                arr.splice(j, 1);
                j--;
            }
        }
    }
    return arr;
}
let arr = [1, 1, '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直接消失了

双层循环，外层循环元素，内层循环时比较值。值相同时，则删除这个值
3. 利用indexOf去重

function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!');
        return;
    }
    let array = [];
    for(let i = 0; i < arr.length; i++) {
        if(arr.indexOf(arr[i]) === -1) {
            array.push(arr[i]);
        }
    }
}
let arr = [1, 1, 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN, NaN, "NaN", 0, 0, 'a', 'a', {}, {}];
// [1, 'true', true, 15, false, undefined, null, NaN, NaN, 'NaN', 0, 'a', {}, {}]
// NaN、{}没有去重

新建一个空的结果数组，for循环原数组，判断结果数组是否存在当前元素，如果有相同的值则跳过，不相同则push进数组
4. 利用sort()

function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!');
        return;
    }
    arr = arr.sort();
    let arr = [arr[0]];
    for(let i = 0; i < arr.length; i++) {
        if (arr[i] !== arr[i-1]) {
            array.push(arr[i]);
        }
    }
    return array;
}
let arr = [1, 1, 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN, NaN, "NaN", 0, 0, 'a', 'a', {}, {}];
// [0, 1, 15, 'NaN', NaN, NaN, {}, {}, 'a', false, null, true, 'true', undefined]
// NaN、{}没有去重

利用sort()排序方法，然后根据排序后的结果进行遍历及相邻元素比对
5. 利用includes

• includes()方法判断字符串是否包含指定的子字符串
  如果找到匹配的字符串则返回true，否则返回false
  includes()区别大小写
  string.includes(查找的字符串, 从哪个位置开始查找(默认为0))

function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!');
        return;
    }
    let array = [];
    for(let i = 0; i < arr.length; i++) {
        if(!array.includes( arr[i] )) {
            array.push(arr[i]);
        }
    }
    return array;
}
let arr = [1, 1, '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', {}, {}]
// {}没有去重

6. 利用hasOwnProperty
   返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）

function unique(arr) {
    let obj = {};
    return arr.filter(function(item, index, arr) {
        return obj.hasOwnProperty(typeof item + item ? false : (obj[typeof item + item = true]))
    })
}
let arr = [1, 1, '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', 'NaN', 0, 'a', {}]
// 所有的都去重了

7. 利用filter

function unique(arr) {
    return arr.filter(function(item, index, arr) {
        // 当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
        return arr.indexOf(item, 0) === index;
    });
}
let arr = [1, 1, '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', 0, 'a', {}, {}]
// {}不能去重

8. 利用递归去重

function unique(arr) {
    let array = arr;
    let 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;
}
let arr = [1, 1, 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN, NaN, "NaN", 0, 0, 'a', 'a', {}, {}];
console.log(unique(arr));
// [1, 'a', 'true', true, 15, false, 1, {}, null, NaN, NaN, 'NaN', 0, 'a', {}, undefined]
// NaN、{}没有去重

9. 利用Map数据结构去重

function arrayNonRepeatfy(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 {
            // 如果没有该key值
            map.set(arr[i], false);
            array.push(arr[i]);
        }
    }
    return array;
}
let arr = [1, 1, 'true', true, true, 15, 15, false, false, undefined, undefined, null, null, NaN, NaN, "NaN", 0, 0, 'a', 'a', {}, {}];
console.log(arrayNonRepeatfy(arr));
// [1, 'true', true, 15, false,undefined, null, NaN, 'NaN', 0, 'a', {}, {}}]
// {}无法去重

创建一个空Map数据结构，遍历需要去重的数组，把数组的每一个元素作为key存到Map中。
由于Map中不会出现相同的key值，所以最终得到的就是去重后的结果。
10. 利用reduce+includes

• reduce()方法
  接受一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值
  reduce()对于空数组是不会执行回调函数的。

function unique(arr) {
    return arr.reduce( (prev, cur) => prev.includes(cur) ? prev : [...prev, cur], []);
}
let arr = [1, 1, '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', {}, {}]