數組去重的各類方法速度對比

首先須要一個自動生成數組的函數

// 自動生成數組的函數
    function randomArr (n) {
        let arr = [];
        for (let i = 1; i <= n; i++) {
            arr.push(Math.floor(Math.random() * (i + 1)));
        }
        return arr;
    }

1. 執行上面函數，的到的arr1數組長度爲50000，由於js執行速度很快，只有長度很大時，才能看到各個方法的執行速度的差異
2. 注意 arr2到arr7不能簡單的用賦值，不然arr1改變後，arr2到arr7也相應改變了

// 七個相同的數組 而且數組長度要足夠大才能對比出來
    var n = 50000;
    var arr1 = randomArray(n);
    var arr2 = [...arr1];
    var arr3 = [...arr1];
    var arr4 = [...arr1];
    var arr5 = [...arr1];
    var arr6 = [...arr1];
    var arr7 = [...arr1];

接下來是數組去重的各類方式

/**
     * 數組去重方法1: 有相同就跳過
     */
    function unique (arr) {
        var len = arr.length;
        var newArr = [];
        for (var i = 0; i < len; i++) {
            for (var j = i + 1; j < len; j++) {
                if (arr[i] === arr[j]) {
                    j = ++i;
                }
            }
            newArr.push(arr[i]);
        }
        return newArr;
    }

    /**
     * 數組去重方法2:有相同就刪除後面的
     */
    function unique2 (arr) {
        var len = arr.length;
        for (var i = 0; i < len; i++) {
            for (var j = i + 1; j < len; j++) {
                if (arr[i] === arr[j]) {
                    arr.splice(j, 1);
                    j--;
                    len--;
                }
            }
        }
        return arr;
    }

    /**
     * 數組去重方法3:利用對象屬性不能相同去重
     */
    function unique3 (arr) {
        var obj = {}, newArr = [];
        for (var i = 0; i < arr.length; i++) {
            if (!obj[arr[i]]) {
                obj[arr[i]] = 1;
                newArr.push(arr[i]);
            }
        }
        return newArr;
    }

    /**
     * 數組去重方法4:數組遞歸去重
     */
    function unique4 (arr) {
        arr.sort();
        var len = arr.length;
        for (var i = 0; i < len - 1; i++) {
            if (arr[i] === arr[i + 1]) {
                arr.splice(i + 1, 1);
                i--;
                len--;
            }
        }
        return arr;
    }

    /**
     * 數組去重方法5:indexOf/forEach/map/filter
     */
    function unique5 (arr) {
        var newArr = [];
        arr.forEach(function(item, index, arr){
            // if(newArr.indexOf(item)===-1){
            //     newArr.push(item);
            // }
            if (arr.indexOf(item, index + 1) === -1) {
                newArr.push(item);
            }
        });
        return newArr;
    }

    /**
     * 數組去重方法6:es6 new Set()
     */
    function unique6 (arr) {
        // return [...new Set(arr)];
        return Array.from(new Set(arr));
    }

    /**
     * 數組去重方法7:es6 [...]
     */
    function unique7 (arr) {
        return [...new Set(arr)];
    }

計算各個方法所花費的時間

1. 最後，須要一個函數調用以上數組去重的方法，並進行時間計算

// 計算時間
    function calcRunTime (func, arr) {
        console.time('testForEach');
        var array = func(arr);
        console.timeEnd('testForEach');
        console.log(array);
    }
    
    // 開始計算
    calcRunTime(unique,arr1);
    calcRunTime(unique2,arr2);
    calcRunTime(unique3,arr3);
    calcRunTime(unique4,arr4);
    calcRunTime(unique5,arr5);
    calcRunTime(unique6,arr6);
    calcRunTime(unique7,arr7);

計算結果來了

unique: 2921.845947265625ms
unique2: 3580.632080078125ms
unique3: 12.416259765625ms
unique4: 617.23779296875ms
unique5: 2497.0478515625ms
unique6: 20.821044921875ms
unique7: 12.881103515625ms

小結

能夠看出：

1. 第6種和第7種方法利用es6語法去重，不只代碼簡單，執行速度也快
2. 利用對象key值的惟一性去重，執行速度也是很快的，其它方法就比較劣勢了