数组去重的方法都有哪些？

本篇文章主要目的就是对数组去重的方法的集合。 对于数组的去重，还是有许多方法的，以下仅仅是其中一些。

• 第一种：for循环
• 第二种：filter() + indexof()
• 第三种：forEach + indexOf
• 第四种：forEach + includes
• 第五种：先排序 再两两比较 不相等再放进去
• 第六种：排序，遍历数组，判断元素是否与新数组最后元素相等
• 第七种：借用一个空对象{}
• 第八种：Set
• 第九种：forOf + Set

第一种：for循环

for循环是我们最容易想到的一个方法。 for循环主要思路：双层循环，若内层循环的元素与外层循环的元素arr[i]相等，那么需要将arr[j]这个元素去掉。 代码如下：

    let arr=[11,88,22,33,44,55,44,33,22,11];
    for(let i=0;i<arr.length;i++){
        for(let j=i+1;j<arr.length;j++){
            if(arr[i]===arr[j]){
                arr.splice(j,1);
            }

        }
    }
    console.log(arr);

也可以把循环封装到一个函数里面：

    let arr=[11,88,22,33,44,55,44,33,22,11];
    function uniqueArr(array){
        let newArr=[];
        // 定义一个变量 看元素是否重复
        let isRepeat;
        for(let i=0;i<array.length;i++){
            isRepeat=false;
            for(let j=0;j<newArr.length-1;j++){
            // 若遍历过程中出现相同元素，则给isRepeat赋值为true
                if(newArr[j]==array[i]){
                    isRepeat=true;
                    break;
                }
            }
            // 只有当isRepeat为false的时候，将array[i]元素存储到新的数组里面
            if(!isRepeat)
                newArr.push(array[i]);
        }
        return newArr;
    }
    console.log(uniqueArr(arr));

可以将去重的代码封装到一个函数里：

<script>
    let arr5=[11,88,22,33,44,55,44,33,22,11];
    function uniqueArr(array){
        let newArr=[];
        let isRepeat;
        for(let i=0;i<array.length;i++){
            isRepeat=false;
            for(let j=0;j<newArr.length-1;j++){
                if(newArr[j]==array[i]){
                    isRepeat=true;
                    break;
                }
            }
            if(!isRepeat)
                newArr.push(array[i]);
        }
        return newArr;
    }
    console.log(uniqueArr(arr5));
</script>

第二种：filter() + indexof()

filter( function(currentValue,index,arr), thisValue) 作用：起到筛选数据的作用 会创建一个新数组，原数组的每个元素传入回调函数中，若返回值为return true，则这个元素保存到新数组中；若return false，则该元素不保存到新数组中；原数组不发生改变。filter也有过滤的作用，会把满足要求的数据过滤出来。

indexOf(searchvalue,fromindex) 作用：查找字串中指定字符或字串首次出现的位置,返首索引值，若找不到返回-1. 第一个参数是要检索的字符串值，第二个参数是在整体字符串中开始检索的位置。

代码如下：

<script>
    // filter indexOf 高阶函数
    // filter()若return若返回true，则元素保存到新数组中；否则不保存；返回新数组，原数组不发生改变
    // indexOf() 查找字串中指定字符或字符串首次出现的位置,返首索引值
    let arr1=[11,88,22,33,44,55,44,33,22,11];
    let newArr1=arr1.filter(function(element,index,self){
        return self.indexOf(element)==index;
    });
    console.log(newArr1);
</script>

第三种：forEach + indexOf

<script>
    // 遍历数组元素 indexOf查找此元素是否属于新数组，
    // 若不属于返回-1，若返回-1，将此元素存进新数组
    let arr6=[11,88,22,33,44,55,44,33,22,11];
    function uniqueArr(array){
        let newArr6=[];
        array.forEach(item=>{
            if(newArr6.indexOf(item)==-1){
                newArr6.push(item);
            }
        })
        return newArr6;
    }
    console.log(uniqueArr(arr6));
</script>

第四种：forEach + includes

includes()方法：确定数组是否包含指定的元素。

如果数组包含元素，则此方法返回 true，否则返回 false。

    // .includes 找到返回true 否则 false
    // 遍历 若newArr8.includes() 没找到，则将数据存储到新数组
    let arr8=[11,88,22,33,44,55,44,33,22,11];
    function uniqueArr(array){
        let newArr8=[];
        arr8.forEach(item=>{
            if(!newArr8.includes(item)){
                newArr8.push(item);
            }
        })
        return newArr8;
    }
    console.log(uniqueArr(arr8));
</script>

第五种：先排序 再两两比较 不相等再放进去

<script>
    // 先对数组进行.sort()升序排序 再两两进行比较
    // 若array[i]==array[i+1]则不保存array[i]
    // 若array[i]！=array[i+1]，则将array[i]存入到新数组中
    let arr7=[11,88,22,33,44,55,44,33,22,11];
    function uniqueArr(array){
        arr7.sort();
        let newArr7=[];
        for(let i=0;i<array.length;i++){
            if(array[i]!=array[i+1]){
                newArr7.push(array[i]);
            }
        }
        return newArr7;
    }
    console.log(uniqueArr(arr7));
</script>

第六种：排序，遍历数组，判断元素是否与新数组最后元素相等

先进行排序，再遍历数组，并判断遍历元素是否与新数组的最后一个元素相等，若不等则将遍历元素存储到新数组

<script>
    let arr9=[11,88,22,33,44,55,44,33,22,11];
    function uniqueArr(array){
        let newArr9=[];
        arr9.sort();
        arr9.forEach(item=>{
            if(newArr9[newArr9.length-1]!=item)
                newArr9.push(item);
        })
        // for(let i=0;i<array.length;i++){
        //     if(newArr9[newArr9.length-1]!=array[i])
        //         newArr9.push(array[i]);
        // }
        return newArr9;
    }
    console.log(uniqueArr(arr9));
</script>

第七种：借用一个空对象{}

<script>
    // 遍历数组，创建一个空对象，
    // 把数组元素作为此对象的键名
    // 判断 若对象中没有此元素为键名的属性，给对象赋新的属性，并赋值为true
    // 并把此元素存储到新数组
    let arr10=[11,88,22,33,44,55,44,33,22,11];
    function uniqueArr(array){
        let newArr10=[];
        let temp={};
        for(let i=0;i<=array.length-1;i++){
            if(!temp[array[i]]){
                temp[array[i]]=true;
                newArr10.push(array[i]);
            }
        }
        return newArr10;
    }
    console.log(uniqueArr(arr10));
</script>

第八种：Set

在ES6中增加了Set数据结构,只能用new创建，不能通过字面量创建。

Set 类似数组，不能存储重复元素，一种新的数据类型，不是数组，不是对象。

若存储的数据重复，会自动去除

<script>
    let arr3=[11,88,22,33,44,55,44,33,22,11];
    let set1=new Set(arr3);
    let newArr3=[...set1];
    console.log(newArr3);

</script>

第九种：forOf + Set

数组是可迭代对象，可以用forOf. forOf可以还换成for循环、forEach

<script>
    let arr4=[11,88,22,33,44,55,44,33,22,11];
    let set2=new Set(arr4);
    let newArr4=[];
    for(let item of set2){
        newArr4.push(item);
    }
    console.log(newArr4);
</script>