数组去重的6种方法，以及性能比较

最新推荐文章于 2026-06-20 11:33:30 发布

原创最新推荐文章于 2026-06-20 11:33:30 发布 · 820 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

本文介绍六种不同的数组去重方法，包括使用新数组存储、原地修改数组、利用对象存储、排序后去重、Set集合及高效对象法，并对比了各种方法的优缺点和执行效率。

第一种方法 - 创建新的空数组，indexOf ==-1,则往空数组push这个元素 —耗时6007ms

        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);

        let start = new Date().getTime();
        console.log('开始数组去重');

        function filter(arr) {
            let newarr = [];
            arr.forEach(item => {
                if (newarr.indexOf(item) == -1) {
                    newarr.push(item);
                }
            })
            return newarr;
        }
        console.log(filter(arr));

        let end = new Date().getTime()
        console.log('耗时', end - start);     //耗时6007

在这里插入图片描述

第二种方法 - 在原数组操作, indexOf !=当前下标，splice当前元素 — 耗时6542ms

        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);

        let start = new Date().getTime();
        console.log('开始数组去重');

        function filter(arr) {
            for (let i = 0; i <= arr.length - 1; i++) {
                if (arr.indexOf(arr[i]) != i) {
                    arr.splice(i, 1);
                    i--;
                }
            }
            return arr;
        }
        console.log(filter(arr));

        let end = new Date().getTime()
        console.log('耗时', end - start);     //耗时6542

在这里插入图片描述
第三种方法 - 在原数组操作，与最后一个元素交换,删去最后一个元素, 缺点：会打乱顺序 — 耗时6049ms

        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);

        let start = new Date().getTime();
        console.log('开始数组去重');

        function filter(arr) {
            for (let i = 0; i <= arr.length - 1; i++) {
                if (arr.indexOf(arr[i]) != i) {
                    arr[i] = arr[arr.length - 1];
                    arr.length--;
                    i--;
                }
            }
            return arr;
        }
        console.log(filter(arr));

        let end = new Date().getTime()
        console.log('耗时', end - start);     //耗时6049

在这里插入图片描述
第四种方法：对象法, 利用对象没有这个属性时为undefined — 耗时11ms !!!

        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);

        let start = new Date().getTime();
        console.log('开始数组去重');

        function filter(arr) {
            let obj = {};
            let newarr = [];
            for (let i = 0; i <= arr.length - 1; i++) {
                if (obj[arr[i]] == undefined) {
                    newarr.push(arr[i]);
                    obj[arr[i]] = 1;
                }
            }
            return newarr;
        }
        console.log(filter(arr));

        let end = new Date().getTime()
        console.log('耗时', end - start);     //耗时11

在这里插入图片描述
第五种：排序，相邻数值不相等则放到新数组 — 耗时11ms!!!

        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);

        let start = new Date().getTime();
        console.log('开始数组去重');

        function filter(arr) {
            let obj = {};
            let newarr = [];
            for (let i = 0; i <= arr.length - 1; i++) {
                if (obj[arr[i]] == undefined) {
                    newarr.push(arr[i]);
                    obj[arr[i]] = 1;
                }
            }
            return newarr;
        }
        console.log(filter(arr));

        let end = new Date().getTime()
        console.log('耗时', end - start);     //耗时11

在这里插入图片描述
第六种：Set是一组key的集合，但不存储value。由于key不能重复，所以，在Set中，没有重复的key。— 耗时14ms!!!

        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);

        let start = new Date().getTime();
        console.log('开始数组去重');

        function filter(arr) {
            return [...new Set(arr)];
        }
        console.log(filter(arr));

        let end = new Date().getTime()
        console.log('耗时', end - start);     //耗时14