数组去重方法和性能对比

1、数据模板

let arr1 = Array.from(new Array(100000), (x, index) => {
    return index;
})
let arr2 = Array.from(new Array(50000), (x, index) => {
    return index + index;
})
let arr = arr1.concat(arr2);
function distinct() {
    
}
console.log("开始数组去重，原数组长度：", arr.length);
let start = new Date().getTime();
let result = distinct();
let end = new Date().getTime();
console.log('数组去重结束，新数组长度：', result.length);
console.log("耗时：", end - start);

2、数组去重方法和性能对比

（1）for...of + indexOf（或includes）

        新建一个数组，遍历传入的数组，值不在新数组中就加入到该新数组

function distinct() {
    let newArr = [];
    for (let i of arr) {
        if (newArr.indexOf(i) == -1) {
            newArr.push(i);
        }
        // if (!newArr.includes(i)) {
        //    newArr.push(i);
        // }
    }
    return newArr;
}

         

（2）双重 for 循环

        外层循环遍历元素，内层循环检查是否重复，当有重复值的时候，push进新数组：

function distinct() {
    let newArr = [];
    for (let i = 0; i < arr.length; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[i] == arr[j]) {
                i++
            }
        }
        newArr.push(arr[i]);
    }
    return newArr;
}

        

（3）filter() + indexOf

        将两个数组拼接为一个数组，然后使用 ES6 中的filter()遍历数组，并结合 indexOf 来排除重复项：

function distinct() {
    return arr.filter((item, index) => arr.indexOf(item) == index)
}

         

（4）new Set()

        ES6 新增了Set这一数据结构，类似于数组，但 Set 的成员具有唯一性，基于这一特性，来做数组去重：

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

​​        

        150W长度的数据量下耗时137ms，效率比上面的方法都要高。

         

（5）sort()

        首先使用 sort() 将数组进行排序，然后比较相邻元素是否相等，从而排除重复项：

function distinct() {
    arr = arr.sort();
    let result = [arr[0]];
    for (let i = 1; i < arr.length; i++) {
        if (arr[i] !== arr[i - 1]) {
            result.push(arr[i])
        }
    }
    return result;
}

        这种方法只做了一次排序和一次循环，所以效率会比上面的方法都要高。

         

        150W长度的数据量下耗时74ms，比new Set()还要更快。

        

（6）for...of + Object

        首先创建一个空对象，然后用 for 循环遍历，利用对象的属性不会重复这一特性，校验数组元素是否重复：

function distinct() {
    let result = [];
    let obj = {};
    for (let i of arr) {
        if (!obj[i]) {
            result.push(i);
            obj[i] = 1;
        }
    }
    return result;
}

        

      150W长度的数据量下耗时51ms，比new Set()和sort还要更快，目前最快的去重方法。