js数组去重与性能分析（时间复杂度很重要）

随着js的深入和实际项目对性能的要求，算法的简单实现已经不能满足需要，在不同的应用场景下，时间复杂度很重要。

首先是创建数组与性能处理函数：

// 保证时间差的明显程度，创建不同量级的数组，size为数组的量级
function createArr (size) {
    var len = size/100
    var create = []
    for (var i=0; i<100; i++ ) {
        for(var j=0; j<len; j++) {
            create.push(j)
        }
    }

    return create
}


// 以回调的方式
function checkTime (fn) {
    var date1 = new Date().getTime()
    var create = fn()
    var date2 = new Date().getTime()
    return {
        create: create,
        time: date2 - date1
    }
}

下面上不同去重函数的思路：

1. 常规思路，双层for循环，逐个去重

function singelArray (array) {
    var temp =[];
    for(var i = 0; i<array.length; i++) {
        for(var j = i+1; j<array.length; j++) {
            if (array[i] === array[j]) ++i
        }
        temp.push(array[i])
    }
    return temp;
}

2.为减少for循环层级，先为数组排序

function singelArray2 (array) {
    var temp = [array[0]]

    array.sort(function(a,b){
        return a - b;
    })

    for(var i=0;  i<array.length; i++) {
        if(array[i] !== temp[temp.length - 1]) {
            temp.push(array[i])
        }
    }

    return temp
}

3.利用对象属性唯一的特性

function singelArray3 (array) {
    var obj = {};
    var temp = []
    for (var i=0; i<array.length; i++) {
        if( !obj[array[i]] ) {
            temp.push(array[i]);
            obj[array[i]] = 1;
        } 
        
    }
    return temp
}

4. ES6 新增数据结构

function singelArray4 (array) {
    return new Array(...(new Set(array)))
}

*******性能测试

为避免误差，不同量级的数组操作四次

// 百万量级  
var lgArr = createArr(1000000)
var res = checkTime(function(){return singelArray(lgArr)});
var res2 = checkTime(function(){return singelArray2(lgArr)});
var res3 = checkTime(function(){return singelArray3(lgArr)});
var res4 = checkTime(function(){return singelArray4(lgArr)});
console.log(res)  // 常规思路       time: 119   115   116    115
console.log(res2) // 先排序         time: 769   774   768    775
console.log(res3) // 对象属性唯一   time: 14    15    14     14
console.log(res4) // es6 Set        time: 25    24    26     26

// 千万量级  
var lgArr = createArr(10000000)
var res = checkTime(function(){return singelArray(lgArr)});
var res2 = checkTime(function(){return singelArray2(lgArr)});
var res3 = checkTime(function(){return singelArray3(lgArr)});
var res4 = checkTime(function(){return singelArray4(lgArr)});
console.log(res)  // 常规思路       time: 10542   10549   10550   10540
console.log(res2) // 先排序         time: 8130      8146    8072    8031
console.log(res3) // 对象属性唯一   time: 119     118     118     118
console.log(res4) // es6 Set        time: 253     247     243     239

五千万量级和一亿量级尝试了下，时间着实长了点...  作者电脑可能垃圾了，有兴趣的可以自己测一下。

总体来看在考虑兼容性的情况下，推荐使用第三种方法，可用ES6时，建议使用第四种方法。或者统一使用ES6方法，最后再用babel转一下，不过小编没试过，不好妄下评论。