数组去重方法总结

1、使用双重循环
优点：兼容性好

function unique(arr){
    var len=arr.length;
    if(len<=1) return arr;
    var newArr=[];
    for(var i=0;i<len;i++){
        for(var j=0;j<newArr.length;j++){
            if(arr[i]===newArr[j]){
                break;
            }
        }
        // 如果newArr中没有arr[i],则最后j===newArr.length
        if(j===newArr.length){
            newArr.push(arr[i]);
        }
    }
    return newArr;
}

2、使用indexof

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

3、先排序再去重
排好序后，只要前后两个数据不相等，就把数据加入新数组
这种方法的效率要比第二种好。

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

或者：

function unique(arr){
    var len=arr.length;
    if(len<=1) return arr;
    arr=arr.sort();
    arr.forEach(function(item,index,arr){
        if(item==arr[index+1]){
            arr.splice(index,1);
        }
    });
    return arr;
}

综合第2、3种方法，如果排好序则比较前后两个是否相等，如果没排好序，则使用indexOf进行判断

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

    }
    return newArr;
}

4、filter
利用indexOf返回的是第一次查找到相关元素的下标，如果元素重复，则遍历后边的元素时，不会将后边的元素返回。

function unique(arr){
    var len=arr.length;
    if(len<=1) return arr;
    var newArr=[];
     newArr=arr.filter(function(item,index,array){
        return array.indexOf(item)===index;
    });
    return newArr;
}

先排序：

function unique(arr){
    var len=arr.length;
    if(len<=1) return arr;
    var newArr=[];
     newArr=arr.sort().filter(function(item,index,array){
        return item!==array[index-1];
    });
    return newArr;
}

5、Object键值对
如果obj中由item这个键，则返回true，不会返回该item，不然就把item设为obj的键。
问题：由于object中所有的键都为字符串，所以1和‘1’是相等的。

var array=[1,2,1,1,'1'];
function unique(array){
    var obj={};
    return array.filter(function(item,index,array){
        return obj.hasOwnProperty(item)?false:(obj[item]=true);
    });
}
console.log(unique(array));//[1,2]

改进：
使用typeof item+item作为键，这样的话，1和‘1’对应的键分别为number1、string1，会被认为是不相等的

var array=[1,2,1,1,'1'];
function unique(array){
    var obj={};
    return array.filter(function(item,index,array){
        //console.log(typeof item+item);//number1,number2,number1,number1,string1
        return obj.hasOwnProperty(typeof item+item)?false:(obj[typeof item+item]=true);
    });
}
console.log(unique(array));//[1,2,'1']

ES6：
1、使用Set结构

function unique(array){
    return Array.from(new Set(array));
}

简化：

function unique(array){
    return [...new Set(array)];
}

再简化：

var unique=(array)=>[...new Set(array)];

2、使用Map结构

function unique(arr){
    var map=new Map();
    return arr.filter((item)=>!map.has(item)&&map.set(item,true));
}
console.log(unique([1,1,2,4,4]));

数组去重的应用：

统计页面有多少种元素？
首先通过document.getElementsByTagName("*") 获得总共有多少种元素，再通过数组去重的方法去掉重复的元素。