嵌套数组扁平化和数组去重性能检测

前言:

常规的数组扁平化的写法以及常见的面试中数组去重的几种写法,顺便记录一下数组去重的性能分析,特别是面对大量数据的操作,方便以后在项目中更高效的使用.

数组扁平化的常规写法跟es6写法比较

常规写法:(扁平化,去重,排序)

    let arr = [
        [1, 2, 2],
        [3, 4, 5, 5],
        [6, 7, 8, 9, [11, 12, [12, 13, [14]]]], 10
    ];
    //实现数组扁平化,正常思路
    function flat1(arr) {
        //扁平化数组
        let arr1 = arr.toString().split(',')
            //数组排序
        console.log(arr1) // ["1", "2", "2", "3", "4", "5", "5", "6", "7", "8", "9", "11", "12", "12", "13", "14", "10"]
        let arr2 = arr1.map(it => Number(it)).sort((a, b) => {
            return a - b
        });
        console.log(arr2); // [1, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11, 12, 12, 13, 14]
        //数组去重
        for (let i = 0; i < arr2.length; i++) {
            if (arr2[i] === arr2[i + 1]) {
                arr2.splice(i, 1);
                i--
            }
        }
        console.log(arr2); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
    }

es6(arr.flat)

    //es6数组扁平化 去重,  排序
    var arrNew = Array.from(new Set(arr.flat(Infinity))).sort((a, b) => {
        return a - b
    });
    console.log(arrNew); //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

数组去重的几种常规方法跟性能检测(高性能数组去重)

首先我们先构造两个数据量比较大的数据数组,然后拼接起来构造重复项,然后拿到去重前后的时间戳,然后比较不同方法的耗时.

    let arr1 = Array.from(new Array(100000), (x, index) => {
        return index;
    })

    let arr2 = Array.from(new Array(80000), (x, index) => {
        return index;
    })

    let startTime = new Date().getTime();

    console.log('去重后的数组长度 =', dupliate(arr1, arr2).length)

    let endTime = new Date().getTime();

    console.log('耗费时长 =', (endTime - startTime));

1.filter加indexOf数组去重

    //1.filter加indexOf数组去重
    function dupliate(arr1, arr2) {
        let arr = arr1.concat(arr2)
        return arr.filter((item, index) => {
            return arr.indexOf(item) === index;
        })
    }

filter加indexOf数组去重.jpeg

2.双重for循环数组去重

    function dupliate(arr1, arr2) {
        let arr = arr1.concat(arr2);
        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;
    }

双重for循环数组去重.jpeg

3.利用sort进行数组去重

 function dupliate(arr1, arr2) {
        let arr = arr1.concat(arr2);
        let arr3 = arr.sort();
        let result = [];
        for (let i = 0; i < arr3.length; i++) {
            if (arr3[i] !== arr3[i + 1]) {
                result.push(arr3[i])
            }
        }
        return result;
    }

sort排序数组去重.jpeg

4.es6 new Set()

   function dupliate(arr1, arr2) {
        let arr = arr1.concat(arr2);
        let result = Array.from(new Set(arr));
        return result;
    }

new Set数组去重.jpeg

5.for...of语句和object的使用

    function dupliate(arr1, arr2) {
        let arr = arr1.concat(arr2);
        let result = [];
        let obj = {};
        for (let item of arr) {
            if (!obj[item]) {
                result.push(item);
                obj[item] = 1;
            }
        }
        return result;
    }

for...of和object数组去重.jpeg

---

总结:以上就是常见几种数组去重写法在十万条数据量的性能检测,我们可以根据项目的实际需要以及我们使用的数据复杂度更好的去应用在项目开发中.