摘要：使用進(jìn)行操作，如下但是得到的其實(shí)是一個(gè)非常規(guī)的數(shù)組了，也就是說(shuō)其實(shí)主要是用于對(duì)對(duì)象屬性的操作。這確實(shí)要根據(jù)自己的需求來(lái)了。當(dāng)然簡(jiǎn)單的實(shí)現(xiàn)如下好了到了這兒，我們開(kāi)始總結(jié)下常用的數(shù)組去重的方法。

我們先來(lái)看下面的例子，當(dāng)然來(lái)源與網(wǎng)絡(luò)，地址《刪除數(shù)組中多個(gè)不連續(xù)的數(shù)組元素的正確姿勢(shì)》

我們現(xiàn)在將數(shù)組中所有的‘a(chǎn)’元素刪除：

var arr = ["a", "a", "b", "c", "d", "a", "a", "e", "g", "a", "f"];
arr.forEach(function(value, index) {
    value === "a" ? arr.splice(index, 1) : "";
})
console.log(arr); //["a", "b", "c", "d", "a", "e", "g", "f"]

只要相鄰的‘ a’ 元素， 都沒(méi)被刪除，splice不但可以刪除元素本身， 還同時(shí)可以減少數(shù)組長(zhǎng)度（ 就是抹去一切痕跡），
這樣導(dǎo)致后續(xù)的數(shù)組元素會(huì)代替已經(jīng)刪除的元素的位置， 但是循環(huán)是按照數(shù)組的下標(biāo)按順序刪除， 這樣就會(huì)漏掉遷移的元素。

使用delete進(jìn)行操作，如下：

var arr = ["a", "a", "b", "c", "d", "a", "a", "e", "g", "a", "f"];
arr.forEach(function(value, index) {
   value === "a" ? delete arr[index] : "";
})
console.log(arr); //[2: "b", 3: "c", 4: "d", 7: "e", 8: "g", 10: "f"]

但是得到的arr其實(shí)是一個(gè)非常規(guī)的數(shù)組了，也就是說(shuō)其實(shí)delete主要是用于對(duì)對(duì)象屬性的操作。這確實(shí)要根據(jù)自己的需求來(lái)了。

當(dāng)然簡(jiǎn)單的實(shí)現(xiàn)如下：

var arr = ["a", "a", "b", "c", "d", "a", "a", "e", "g", "a", "f"];
var newArr = arr.filter(function(key) {
    return key !== "a"

})
console.log(newArr); //["b", "c", "d", "e", "g", "f"]

好了到了這兒，我們開(kāi)始總結(jié)下常用的數(shù)組去重的方法。

雙層循環(huán)，外層循環(huán)元素，內(nèi)層循環(huán)時(shí)比較值
如果有相同的值則跳過(guò)，不相同則push進(jìn)數(shù)組

Array.prototype.distinct = function(){
    var arr = this,
        result = [],
        i,
        j,
        len = arr.length;

    for(i = 0; i < len; i++){
        for(j = i + 1; j < len; j++){
            if(arr[i] === arr[j]){
                j = ++i;
            }
        }
        result.push(arr[i]);
    }
    return result;
}
var arra = [1,2,3,4,4,1,1,2,1,1,1];
arra.distinct();             //返回[3,4,2,1]

雙層循環(huán)，外層循環(huán)元素，內(nèi)層循環(huán)時(shí)比較值
值相同時(shí)，則刪去這個(gè)值
注意點(diǎn):刪除元素之后，需要將數(shù)組的長(zhǎng)度也減1.

Array.prototype.distinct = function (){
    var arr = this,
        i,
        j,
        len = arr.length;

    for(i = 0; i < len; i++){
        for(j = i + 1; j < len; j++){
            if(arr[i] == arr[j]){
                arr.splice(j,1);
                len--;
                j--;
            }
        }
    }
    return arr;
};

var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
var b = a.distinct();
console.log(b.toString()); //1,2,3,4,5,6,56

優(yōu)點(diǎn)：簡(jiǎn)單易懂
缺點(diǎn)：占用內(nèi)存高，速度慢

Array.prototype.distinct = function (){
    var arr = this,
        i,
        obj = {},
        result = [],
        len = arr.length;

    for(i = 0; i< arr.length; i++){
        if(!obj[arr[i]]){    //如果能查找到，證明數(shù)組元素重復(fù)了
            obj[arr[i]] = 1;
            result.push(arr[i]);
        }
    }
    return result;
};

var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
var b = a.distinct();
console.log(b.toString()); //1,2,3,4,5,6,56

運(yùn)用遞歸的思想
先排序，然后從最后開(kāi)始比較，遇到相同，則刪除

Array.prototype.distinct = function (){
    var arr = this,
        len = arr.length;

    arr.sort(function(a,b){        //對(duì)數(shù)組進(jìn)行排序才能方便比較
        return a - b;
    })

    function loop(index){
        if(index >= 1){
            if(arr[index] === arr[index-1]){
                arr.splice(index,1);
            }
            loop(index - 1);    //遞歸loop函數(shù)進(jìn)行去重
        }
    }
    loop(len-1);

    return arr;
};

var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,56,45,56];
var b = a.distinct();
console.log(b.toString());        //1,2,3,4,5,6,45,56

首先如果你的瀏覽器是低版本不支持indexOf與forEach方法，那么可以先先對(duì)瀏覽器Array對(duì)象進(jìn)行支持indexOf和forEach的polyfill

Array.prototype.indexOf = Array.prototype.indexOf || function(item) {
    for (var i = 0, j = this.length; i < j; i++) {
        if (this[i] === item) {
            return i;
        }
    }
    return -1;
}

Array.prototype.forEach = Array.prototype.forEach || function(callback, thisArg) {
    if (!callback || typeof callback !== "function") return;

    for (var i = 0, j = this.length; i < j; i++) {
        callback.call(thisArg, this[i], i, this);
    }
}

去重方法：

Array.prototype.distinct = function (){
    var arr = this,
        result = [],
        len = arr.length;

    arr.forEach(function(v, i ,arr){        //這里利用map，filter方法也可以實(shí)現(xiàn)
        var bool =  arr.indexOf(v,i+1);        //從傳入?yún)?shù)的下一個(gè)索引值開(kāi)始尋找是否存在重復(fù)
        if(bool === -1){
            result.push(v);
        }
    })

    return result;
};

var a = [1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,3,2,3,3,2,2,1,23,1,23,2,3,2,3,2,3];
var b = a.distinct();
console.log(b.toString());    //1,23,2,3

Array.prototype.distinct = function (){
    var arr = this,
        ret = [];

    arr.forEach(function(e, i, array) {
        if (array.indexOf(e) === i) {
            ret.push(e);
        }
    });

    return ret;
};

var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
var b = a.distinct();
console.log(b.toString()); //1,2,3,4,5,6,56

Set數(shù)據(jù)結(jié)構(gòu)，它類(lèi)似于數(shù)組，其成員的值都是唯一的。
利用Array.from將Set結(jié)構(gòu)轉(zhuǎn)換成數(shù)組

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

dedupe([1,1,2,3]) //[1,2,3]

拓展運(yùn)算符(...)內(nèi)部使用for...of循環(huán)

let arr = [1,2,3,3];
let resultarr = [...new Set(arr)];   
console.log(resultarr);  //[1,2,3]

當(dāng)然以上方法可以不用寫(xiě)到Array的原型上，多帶帶寫(xiě)一個(gè)方法，傳遞數(shù)組當(dāng)參數(shù)也是可以的。

參考地址：http://www.cnblogs.com/leonwang/p/4845576.html