数组去重

1、

思路：建一新数组，遍历需要去重的数组，若元素不在新数组中就添加到新数组中。

知识点：判断值是否在数组的方法“indexOf()”

Array.prototype.unique = function (){
    var newArr = [];                         //新建一个数组
    for(var i=0,len=this.length;i<len;i++){
        if(newArr.indexOf(this[i]) == -1){   //若新数组中未包含该项则将其存入新数组
            newArr.push(this[i]);
        }
    }
    return newArr;
} 

function unique(arr){
    var newArr = [];                         //新建一个数组
    for(var i=0,len=arr.length;i<len;i++){
        if(newArr.indexOf(arr[i]) == -1){    //若新数组中未包含该项则将其存入新数组
            newArr.push(arr[i]);
        }
    }
    return newArr;
} 

此处用了两种写法，一个用“prototype”属性为数组对象添加了个去重方法，一个就是普通去重函数。

测试结果如下

var arr = [112, '34', 'hello', 11, '112', 112, 34, '34', 'hello', 'str', 'str1'];
console.log(arr);
console.log(arr.unique()); //[112, "34", "hello", 11, "112", 34, "str", "str1"]
console.log(unique(arr));  //[112, "34", "hello", 11, "112", 34, "str", "str1"]

2、利用数组下标去重

思路：如果当前数组的第i项在当前数组中第一次出现的位置不是i，那么表示第i项是重复的，忽略掉。否则存入新数组。

知识点：indexOf() 方法可返回某个指定的元素在数组中首次出现的位置。

Array.prototype.unique = function(){
    var newArr = [];
    for(var i=0, len=this.length; i<len; i++){
        if(this.indexOf(this[i]) == i){
            newArr.push(this[i]);
        }
    }
    return newArr;
}

function unique(arr){
    var newArr = [];
    for(var i=0, len=arr.length; i<len; i++){
        if(arr.indexOf(arr[i]) == i){
            newArr.push(arr[i]);
        }
    }
    return newArr;
}

3、排序后相邻去重（此法不推荐）

思路：将需去重的数组进行排序，重复的元素就会相邻。再遍历数组，将元素与新数组的最后一个值进行比较，若不同则加入新数组。

知识点：sort()；

Array.prototype.unique = function (){
    this.sort();
    var newArr = [this[0]];    // 将需去重数组的第一项先放入新数组
    for(var i=1, len=this.length; i<len; i++){    // i初始化为1
        if(this[i] !== newArr[newArr.length-1]){
            newArr.push(this[i]);
        }
    }
    return newArr;
}

function unique(arr){
    arr.sort();
    var newArr = [arr[0]];    // 将需去重数组的第一项先放入新数组
    for(var i=1, len=arr.length; i<len; i++){    // i初始化为1
        if(arr[i] !== newArr[newArr.length-1]){
            newArr.push(arr[i]);
        }
    }
    return newArr;
}

还是处理之前的那个用例，结果如下：

console.log(arr);             //[112, "34", "hello", 11, "112", 112, 34, "34", "hello", "str", "str1"]
console.log(arr.unique());    //[11, 112, "112", 112, "34", 34, "34", "hello", "str", "str1"]
console.log(unique(arr));     //[11, 112, "112", 112, "34", 34, "34", "hello", "str", "str1"]

由于第一步的sort()排序，出现了如 [ …,112, “112”, 112, “34”, 34, “34”,… ]这样的结果，去重失败。

若处理只有数字或只有字符串的数组，此法勉强可用。

小提示：直接复制代码出去测试的朋友们请注意，因为sort()排序会改变元素组的关系，上面的两种写法请单独测试。

4、优化遍历数组法 （墙裂推荐）

思路：遍历需去重的数组，元素与右边的元素依次比较，若元素有重复，则结束当前的元素比较，将下一个元素当做比较对象，即跳出内层循环。

Array.prototype.unique = function(){
    var newArr = [];
    for (var i=0,len=this.length; i<len; i++ ) {
        for( var j=i+1; j<len; j++ ){
            if(arr[i] === arr[j]){
                ++i;
            }
        }
        newArr.push(arr[i]);
    }
    return newArr;
}
function unique(arr){
    var newArr = [];
    for(var i=0,len=arr.length; i<len;i++){
        for(var j=i+1;j<len;j++){
            if(arr[i] === arr[j]){
                ++i;
            }                 
        }
        newArr.push(arr[i]);
    }
    return newArr;
}

即：进入新数组中的元素为 重复元素中是最右边的那个元素。

5、对象键值对法

思路：将需去重数组的元素作为对象的属性(即：键)赋值后存入对象，然后取其他元素作为键，到对象中访问这个键，若有对应的值，则说明重复。若没有，则给对象新增该键并放入新数组。

Array.prototype.unique = function() {
    var res = [];
    var json = {};
    for (var i = 0; i < this.length; i++) {
        if (!json[this[i]]) {
            res.push(this[i]);
            json[this[i]] = 1;
        }
    }
    return res;
}
function unique(arr) {
    var res = [];
    var json = {};
    for (var i = 0; i < arr.length; i++) {
        if (!json[arr[i]]) {
            res.push(arr[i]);
            json[arr[i]] = 1;
        }
    }
    return res;
}

测试结果如下

console.log(arr.unique());    //[112, "34", "hello", 11, "str", "str1"]
console.log(unique(arr));     //[112, "34", "hello", 11, "str", "str1"]

出现这样的情况，是因为判断是否为js对象键时，会自动对传入的键执行“toString()”，不同的键可能会被误认为一样；

（完）