js 數組合並而且去重

1、數組合並的兩種方法

一、concat--合併數組，而且不去重

var arr1 = ["ab","bc","de","fg"];
var arr2 = ["ml","kg","ww","bc","am"];
var arr3 = arr1.concat(arr2);
console.log(arr3)

 

二、自定義數組合並並去重函數

var arr1 = ["ab","bc","de","fg"];
var arr2 = ["ml","kg","ww","bc","am"];
function MergeArray(arr1,arr2){
    var _arr = new Array();
    for(var i=0;i<arr1.length;i++){
       _arr.push(arr1[i]);
    }
    for(var i=0;i<arr2.length;i++){
        var flag = true;
        for(var j=0;j<arr1.length;j++){
            if(arr2[i]==arr1[j]){
                flag=false;
                break;
            }
        }
        if(flag){
            _arr.push(arr2[i]);
        }
    }
    return _arr;
}

console.log(MergeArray(arr1,arr2));

 

2、單個數組去重方法

一、遍歷數組法

這是最簡單的去重方法，實現思路：遍歷舊數組，把值加入新建的數組（當新數組中不存在該值時）

// 最簡單數組去重法
function uniqueArr(array) {
    var n = []; //一個新的臨時數組
    //遍歷當前數組
    for (var i = 0; i < array.length; i++) {
        //若是當前數組的第i已經保存進了臨時數組，那麼跳過，
        //不然把當前項push到臨時數組裏面
        if (n.indexOf(array[i]) == -1) n.push(array[i]);
    }
    return n;
}

注意：indexOf是ECMA5的新方法，IE8及如下不支持，因此要作兼容性處理。

if (Array.prototype.indexOf){
  Array.prototype.indexOf = function (item) {
    var result = -1,a_item = null;
    if (this.length == 0) {
      return result 
    }
    for (var i = 0,len=this.length;i<len;i++) {
      a_item = this[i];
      if (a_item === item) {
        result = i;
        break;
      }
    }

    return result;
  }
}

二、對象鍵值對法

該方法執行的速度比其餘任何方法都快，但就是佔用的內存大一些

實現思路：新建一個js對象以及新數組，遍歷要去重的數組時，判斷值是不是js對象的鍵。不是的話，給對象新增該鍵並放入新數組。

注意：判斷是否爲對象鍵時，會自動對傳入的鍵執行‘toString()’，不一樣的鍵可能會被誤認爲是同樣的，如：a[1]與a['1']。解決該問題仍是得調用「indexOf」.

function uniqueArr(arr) {
        var n = {},
            r = [],
            len = arr.length,
            val, type;
        for (var i = 0; i < len; i++) {
            val = arr[i];
            type = typeof val;
            if (!n[val]) {
                n[val] = [type];
                r.push(val);
            } else if (n[val].indexOf(type) < 0) {
                n[val].push(type);
                r.push(val);
            }
        };
        return r;
    }

    console.log(uniqueArr([1,2,[1,2,3],,'1',2,'4','6']))

三、數組下標判斷法

仍是得調用「indexOf」性能跟方法1差很少，
實現思路：若是當前數組的第i項在當前數組中第一次出現的位置不是i，那麼表示第i項是重複的，忽略掉。不然存入結果數組。

缺點：若是數組中的值爲undefined，則會剔除，不在新數組中。

 function uniqueArr(array) {
        var n = []; //結果數組
        //從第一項開始遍歷
        for (var i = 0; i < array.length; i++) {
            //若是當前數組的第i項在當前數組中第一次出現的位置不是i，
            //那麼表示第i項是重複的，忽略掉。不然存入結果數組
            if (array.indexOf(array[i]) == i) n.push(array[i]);
        }
        return n;
    }

    console.log(uniqueArr([1, 2, [1, 2, 3], , '1', 2, '4', '6']))

四、排序後相鄰除法

雖然原生數組的」sort」方法排序結果不怎麼靠譜，但在不注重順序的去重裏，該缺點毫無影響。
實現思路：給傳入數組排序，排序後相同值相鄰，而後遍歷時新數組只加入不與前一值重複的值。

 

 function uniqueArr(array) {
        array.sort();
        var n = [];
        for (var i = 0; i < array.length; i++) {
            if (array[i] !== n[n.length - 1]) {
                n.push(array[i]);
            }
        }
        return n;
    }

    console.log(uniqueArr([1, 2, [1, 2, 3], , '1', 2, '4', '6']))

五、優化遍歷數組法

源自外國博文，該方法的實現代碼至關酷炫；
實現思路：獲取沒重複的最右一值放入新數組。（檢測到有重複值時終止當前循環同時進入頂層循環的下一輪判斷）

// 思路：獲取沒重複的最右一值放入新數組
function uniqueArr(array) {
    var r = [];
    for (var i = 0, l = array.length; i < l; i++) {
        for (var j = i + 1; j < l; j++)
            if (array[i] === array[j]) j = ++i;
        r.push(array[i]);
    }
    return r;
}
console.log(uniqueArr([1, 2, [1, 2, 3], , '1', 2, '4', '6']))