javascript 数组去重 unique

Array.prototype.unique = function (isStrict) {
    if (this.length < 2)
        return [this[0]] || [];
    var tempObj = {}, newArr = [];
    for (var i = 0; i < this.length; i++) {
        var v = this[i];
        var condition = isStrict ? (typeof tempObj[v] != typeof v) : false;
        if ((typeof tempObj[v] == "undefined") || condition) {
            tempObj[v] = v;
            newArr.push(v);
        }
    }
    return newArr;
}

验证：
var arr = ["9", 9, 1, 3, 8, 7, 7, 6, 6, 5, 7, 8, 8, 7, 4, 3, 1, 22, 22, 'a', 'a','bcd', 'abc', 'bcd'];
var newArr = arr.unique(true);
alert(newArr.join(","));//严格模式:9,9,1,3,8,7,6,5,4,22,a,bcd,abc，将其中"9",9认为不同

var newArr = arr.unique();
alert(newArr.join(","));//普通模式:9,1,3,8,7,6,5,4,22,a,bcd,abc，将其中"9",9认为相同

注意：

1、使用临时对象tempObj，将数组的值作为对象的键值，遍历数组时对当前值根据对象键值判断，不存在就将这个数组的值push到新数组中。提高效率

2、使用类型判断，如果当前数组值做为对象键，所对应的对象值类型与当前值类型一致，则可以根据参数（isStirct严格模式）决定是否去重，true表示严格，对于字符为22，或数字为22都认为一样，否则保留

看了一下JavaScript高级程序设计中关于数组的操作，又想到种更简单的去重方法，代码如下：

Array.prototype.unique = function () {
    var newArr = [];
    for (var i = 0; i < this.length; i++) {
        if (newArr.indexOf(this[i]) == -1) {
            newArr.push(this[i]);
        }
    }
    return newArr;
}
var arr = ['a','b',1,4,5,8,4,3,1,'a','1'];
alert(arr.unique());//a,b,1,4,5,8,3,1  indexOf默认调用===,因此将1与'1'认为是不同

总体思路是把数组元素逐个搬运到另一个数组，搬运的过程中检查这个元素是否有重复，如果有就直接丢掉。从嵌套循环就可以看出，这种方法效率极低。我们可以 用一个hashtable的结构记录已有的元素，这样就可以避免内层循环。恰好，在Javascript中实现hashtable是极为简单的，改进如 下：

function unique(arr) {
    var result = [], hash = {};
    for (var i = 0, elem; (elem = arr[i]) != null; i++) {
        if (!hash[elem]) {
            result.push(elem);
            hash[elem] = true;
        }
    }
    return result;
//http://www.cnblogs.com/sosoft/
}

转:https://www.cnblogs.com/gaojun/p/3579459.html