js去重的幾種方法：

1.使用indexOf()方法---[a.檢查當(dāng)前數(shù)組是否存在;b.比較數(shù)組的下標(biāo)---(借助新數(shù)組，原數(shù)組)]

2.for內(nèi)外雙層循環(huán)

3.先排序后去重---不考慮原數(shù)組的順序時(shí)可以考慮使用

4.對(duì)象鍵值法去重(速度快，但占內(nèi)存大，空間換時(shí)間)

• 方法一 使用indexOf()方法判斷當(dāng)前數(shù)組的元素是否存在，不存在就存進(jìn)新的數(shù)組，否則跳過。
  注意indexOf方法是es5的新特性 不兼容ie8及以下的版本

        var arr = [3,1,2,1,1,3,4,5,6,7];
        console.log(arr);
        function req1(arr){
            var newarr = []; //新建臨時(shí)數(shù)組
            for(var i = 0; i < arr.length; i++){
            //如果當(dāng)前數(shù)組的第i已經(jīng)保存進(jìn)了臨時(shí)數(shù)組，那么跳過，
            //否則把當(dāng)前項(xiàng)push到臨時(shí)數(shù)組里面
                if (newarr.indexOf(arr[i]) == -1) newarr.push(arr[i]);
            }
            return newarr;
        }
        console.log(req1(arr)) //[3, 1, 2, 4, 5, 6, 7]

• //方法二 數(shù)組下標(biāo) 通過indexOf方判斷當(dāng)前元素在數(shù)組中的索引如果與循環(huán)的下標(biāo)相等則添加到新數(shù)組中
  //實(shí)現(xiàn)思路：如果當(dāng)前數(shù)組的第i項(xiàng)在當(dāng)前數(shù)組中第一次出現(xiàn)的位置不是i，那么表示第i項(xiàng)是重復(fù)的，忽略掉。否則存入結(jié)果數(shù)組。
  //性能跟方法1差不多，

function rep2(arr) {
            var newarr = [];
            for (var i = 0; i < arr.length; i++) {
                if (arr.indexOf(arr[i]) == i) newarr.push(arr[i]);
            }
            return newarr;
        }
        console.log(rep2(arr)); //[3, 1, 2, 4, 5, 6, 7]

• //方法三 在原來(lái)的數(shù)組上 借助indexOf()方法判斷此元素在該數(shù)組中首次出現(xiàn)的位置下標(biāo)與循環(huán)的下標(biāo)不相等則刪除掉

function rep3(arr) {
            for (var i = 0; i < arr.length; i++) {
                if (arr.indexOf(arr[i]) != i) {
                    arr.splice(i,1);//刪除數(shù)組元素后數(shù)組長(zhǎng)度減1后面的元素前移
                    i--;//數(shù)組下標(biāo)回退
                }
            }
           return arr;
        }
        console.log(rep3(arr)); //[3, 1, 2, 4, 5, 6, 7]

• //方法四 常規(guī)方法 新舊數(shù)組都需要進(jìn)行循環(huán)，因此效率比較低

var arr = ['d','b','c',1,2,3,'a','b']
        // console.log(arr)
        function rep4(arr) {
            var newarr = [arr[0]] //這里構(gòu)建一個(gè)newarr數(shù)組 且存放了第一個(gè)值 以便下面對(duì)比
            for (var i= 1; i< arr.length; i++) {  
                var isrepeat = false
                for (var j= 0; j< newarr.length; j++) {  //循環(huán)兩個(gè)數(shù)組做對(duì)比
                    if(arr[i] == newarr[j]) {
                        isrepeat = true 
                        break      //這里判斷下循環(huán)arr時(shí)候跟newarr對(duì)比 相等就跳出 且給出標(biāo)記 當(dāng)前arr數(shù)組第幾個(gè)是出現(xiàn)重復(fù)的
                    }
                }
                if (!isrepeat) {
                    newarr.push(arr[i])  //這里 true標(biāo)記的都是重復(fù)的  false都是可以添加的
                }
            }
            return newarr //返回
        }
        console.log(rep4(arr)) //["a", "b", "c", 1, 2, 3]

• //方法五 排序后去重
  //實(shí)現(xiàn)思路：給傳入數(shù)組排序，排序后相同值相鄰，然后遍歷時(shí) 就比較原數(shù)組的元素和新數(shù)組最后一個(gè)元素是否相同。
  //缺點(diǎn)：改變了原數(shù)組的順序
  // 將相同的值相鄰，然后遍歷去除重復(fù)值

var arr = ['e','a','b',1,2,3,'a','b'];
        function rep5(array){
          array.sort();
          var newarr=[array[0]]; //構(gòu)建一個(gè)newarr數(shù)組 存放原數(shù)組第一個(gè)元素
          for(var i = 1; i < array.length; i++){
            if( array[i] !== newarr[newarr.length-1])
                {
                  newarr.push(array[i]);
                }
            }
            return newarr;
        }
        console.log(rep5(arr)) //[1, 2, 3, "a", "b", "e"]

• //方法六 對(duì)象鍵值法去重(推薦使用)
  //速度最快， 占空間最多（空間換時(shí)間）
  //思路：新建一js對(duì)象以及新數(shù)組，遍歷傳入數(shù)組時(shí)，判斷值是否為js對(duì)象的鍵，不是的話給對(duì)象新增該鍵并放入新數(shù)組。

var arr = ['f', '0', '3', '2', 'd', 'd',0,2]
        function rep6(arr) {
            var newarr = [] //構(gòu)建newarr 數(shù)組
            var obj = {}  //構(gòu)建一個(gè)對(duì)象obj
            for (var i= 0; i< arr.length; i++) {
                if (!obj[arr[i]]) { //如果元素跟數(shù)組對(duì)比
                    newarr.push(arr[i])
                    obj[arr[i]] = 1 // 元素內(nèi)容作為對(duì)象屬性，不為0就行
                    //將當(dāng)前數(shù)組的這個(gè)屬性設(shè)置一個(gè)值表示對(duì)象中有了這個(gè)值
                }
            }
            return newarr 
        }
        console.log(rep6(arr)) //["f", "0", "3", "2", "d"]

//注意點(diǎn)：判斷是否為js對(duì)象鍵時(shí)，會(huì)自動(dòng)對(duì)傳入的鍵執(zhí)行“toString()”，JS 的鍵是不分類型的
//不同的鍵可能會(huì)被誤認(rèn)為一樣，例如n[val]-- n[1]、n["1"]；
//解決上述問題還是得調(diào)用“indexOf()”。如果要區(qū)分?jǐn)?shù)字和字符串，就要保存類型
//理解：當(dāng)遍歷到一個(gè)新值 val，問題中的代碼會(huì)檢查 val 是否在 obj 的鍵中，然后檢查 val 的類型是否在 val 鍵對(duì)應(yīng)的值中，兩種皆否則認(rèn)定這是一個(gè)非重復(fù)的值。

function rep6_1(array){
            var obj = {}, newarr = [], len = array.length, val, type;
            for (var i = 0; i < array.length; i++) {
                val = array[i];
                type = typeof val; //判斷val類型
                //1.判斷val是否在obj的鍵中；2.判斷val的類型是否在val鍵對(duì)應(yīng)的值中。找不到返回-1
                if (!obj[val]) {
                    obj[val] = [type]; 
                    newarr.push(val);
                } else if (obj[val].indexOf(type) < 0) {
                    //返回的結(jié)果是true 小于0是正確的
                    obj[val].push(type); 
                    newarr.push(val);
                }
            }
            return newarr;
        }
        console.log(rep6_1(arr)) //["f", "0", "3", "2", "d", 0, 2]

• //方法七 是四的優(yōu)化
  //實(shí)現(xiàn)思路：獲取沒重復(fù)的最右一值放入新數(shù)組。（檢測(cè)到有重復(fù)值時(shí)終止當(dāng)前循環(huán)同時(shí)進(jìn)入頂層循環(huán)的下一輪判斷）
  //可以辨別0 和 “0” 比方法六的方法還優(yōu)化

var arr = ['g', '0', '3', '2', 'd', 'd',0]
        function rep7(array){
            var r = [];
            var len = array.length;
            for(var i = 0;i < len; i++) {
                for(var j = i + 1; j < len; j++){
                    if (array[i] === array[j]) j = ++i;
                }
                r.push(array[i]);
            }
            return r;
        }
        console.log(rep7(arr)) ////["g", "0", "3", "2", "d"]