前端JS算法之数组去重

第一种方法：
使用双重for循环，分别去拿数组里面的元素去跟数组里面的每一项去比较

var arr1 = [1, 1, 2, 3, 3, 4, 5, 6, 7, {}, {}, [], [], 'a', 'b', 'c', 'a', 'c', true, false, true, null, NaN, null, NaN];
function separate(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);
            }
        }
    }
    return arr;
}
// NaN、{}、[]，没有去重。
separate(arr) // [1, 2, 3, 4, 5, 6, 7, {…}, {…}, Array(0), Array(0), "a", "b", "c", true, false, null, NaN, NaN]

第二种方法：
使用for循环加indexOf，新建一个数组array，使用indexOf依次用去重数组里面的元素去判断array数组是否存在，如果不存在，则push到array这个数组里面

var arr1 = [1, 1, 2, 3, 3, 4, 5, 6, 7, {}, {}, [], [], 'a', 'b', 'c', 'a', 'c', true, false, true, null, NaN, null, NaN];
function separate(arr) {
    if(!Array.isArray(arr)) {
        console.error('type errno');
        return;
    }
    let array = []
    for(let i = 0; i < arr.length; i++) {
        if(array.indexOf(arr[i]) === -1) {
            array.push(arr[i])
        }
    }
    return array;
}
// 跟第一种方法一样，{}、[]、NaN没有去重
separate(arr) // [1, 2, 3, 4, 5, 6, 7, {…}, {…}, Array(0), Array(0), "a", "b", "c", true, false, null, NaN, NaN]

第三种方法：
...：ES6的运算展开符
new Set()：ES6提供的新的数据解构，类似于数组，它的成员都是唯一的

var arr1 = [1, 1, 2, 3, 3, 4, 5, 6, 7, {}, {}, [], [], 'a', 'b', 'c', 'a', 'c', true, false, true, null, NaN, null, NaN];
function separate(arr) {
    // 由于 new Set是类数组，用ES6的展开符（...），把它的成员放到一个数组里面
    return [...new Set(arr)];
} 
// {}、[]没有去重，NaN实现了去重
separate(arr) // [1, 2, 3, 4, 5, 6, 7, {…}, {…}, Array(0), Array(0), "a", "b", "c", true, false, null, NaN]

第四种方法：
filter()：方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
语法：array.filter(function(item, index, arr), thisValue)

参数	描述
function(item,index,arr)	必须。函数，数组中的每个元素都会执行这个函数 函数参数： 参数 描述 item 必须。当前元素的值 index 可选。当前元素的索引值 arr 可选。当前元素属于的数组对象
thisValue	可选。对象作为该执行回调时使用，传递给函数，用作 “this” 的值 如果省略了 thisValue ，“this” 的值为 “undefined”

hasOwnProperty()：从Object继承来的，检测一个属性是否是存在于示例中，还是存在原型中，只有在给定的属性存在于对象实例中时，才会返回true。

var arr1 = [1, 1, 2, 3, 3, 4, 5, 6, 7, {}, {}, [], [], 'a', 'b', 'c', 'a', 'c', true, false, true, null, NaN, null, NaN];
function separate(arr) {
    let obj = {};
    return arr.filter(function(item) {
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true);
    })
}
// 从输出结果可以看出{}、[]和NaN实现了去重
separate(arr) // [1, 2, 3, 4, 5, 6, 7, {…}, Array(0), "a", "b", "c", true, false, null, NaN]

第四种方法看着对{}实现了去重，但是这种方法有问题，我们看下面的代码

var arr2 = [{a: 1}, {b: 2}, [1], [1], [2, 3]];

function separate(arr) {
    let obj = {};
    return arr.filter(function(item) {
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true);
    })
}
separate(arr2) // [{a: 1}, [1], [2, 3]]

明明arr2数组里面的两个对象不相同，却也去重了，使用hasOwnProperty这个方法，遇到对象就挂了。大家如果有更好的方法可以留下你的评论，大家一起探讨