JS實現數組去重方法整理

前言

咱們先來看下面的例子，固然來源與網絡，地址《刪除數組中多個不連續的數組元素的正確姿式》

咱們如今將數組中全部的‘ a’ 元素刪除：

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’ 元素， 都沒被刪除， splice不但能夠刪除元素自己， 還同時能夠減小數組長度（ 就是抹去一切痕跡），
這樣致使後續的數組元素會代替已經刪除的元素的位置， 可是循環是按照數組的下標按順序刪除， 這樣就會漏掉遷移的元素。

看到網上有網友在說使用delete進行操做，以下：

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實際上是一個很是規的數組了，也就是說其實delete主要是用於對對象屬性的操做。這確實要根據本身的需求來了。

固然簡單的實現以下：

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"]

 下面總結下經常使用實現方式。

方法一：

1. 雙層循環，外層循環元素，內層循環時比較值

2. 若是有相同的值則跳過，不相同則push進數組

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]

方法二：利用splice直接在原數組進行操做

1. 雙層循環，外層循環元素，內層循環時比較值

2. 值相同時，則刪去這個值

注意點:刪除元素以後，須要將數組的長度也減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

優勢：簡單易懂
缺點：佔用內存高，速度慢

方法三：利用對象的屬性不能相同的特色進行去重

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

    for(i = 0; i< arr.length; i++){
        if(!obj[arr[i]]){    //若是能查找到，證實數組元素重複了
            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

方法四：數組遞歸去重

1. 運用遞歸的思想

2. 先排序，而後從最後開始比較，遇到相同，則刪除

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

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

    function loop(index){
        if(index >= 1){
            if(arr[index] === arr[index-1]){
                arr.splice(index,1);
            }
            loop(index - 1);    //遞歸loop函數進行去重
        }
    }
    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

首先若是你的瀏覽器是低版本不支持indexOf與forEach方法，那麼能夠先先對瀏覽器Array對象進行支持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方法也能夠實現
        var bool =  arr.indexOf(v,i+1);        //從傳入參數的下一個索引值開始尋找是否存在重複
        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

方法六：數組下標判斷法, 遍歷數組，利用indexOf判斷元素的值是否與當前索引相等，如相等則加入

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

方法七：利用ES6的set

Set數據結構，它相似於數組，其成員的值都是惟一的。

利用Array.from將Set結構轉換成數組

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

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

拓展運算符(...)內部使用for...of循環

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

固然以上方法能夠不用寫到Array的原型上，單獨寫一個方法，傳遞數組當參數也是能夠的。

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

文章更新於2017-12-07