数组去重的方法

数组去重是在开发中笔记常见的需求之一，以下是部分去重方法，需要根据具体的业务场景选择最合适的去重方法

第一种：使用lodash中的_.uniq(array)方法

网站：lodash.uniq | Lodash 中文文档 | Lodash 中文网

<script src="./lodash.js"></script>
<script>
    let arr = [5,1,2,4,5,2,6,5,4]
    function fn(){
      let brr = _.uniq(arr)
      console.log(brr);//打印👉[5, 1, 2, 4, 6]
    }
    fn()
</script>

第二种：利用Set()：将要去重的数组转换成Set对象，再将Set对象转换成数组。

 let arr = [1, 2, 2, 3, 4, 4]
//⭐new Set展开运算符实现
let brr =[...new Set(arr)]
console.log(brr);//打印👉[1, 2, 3, 4]
//⭐Array.from()实现
let brr = Array.from(new Set(arr))
console.log(brr);//打印👉[1, 2, 3, 4]

第三种：利用Array.indexOf()方法进行去重

//⭐利用ES6的forEach+indexOf
 let arr = [1, 2, 2, 3, 4, 4]
    function fn(){
      let brr = []
      arr.forEach(item=>{
        if(brr.indexOf(item) == -1){
          brr.push(item)
        }
      })
      console.log(brr);//打印👉[1, 2, 3, 4]
    }
    fn()
    
//⭐利用原生for循环+indexOf
let arr = [1, 2, 2, 3, 4, 4]
    function fn(arr) {
      //①定义一个空数组
      let brr = []
      //返回brr数组之前，先遍历arr中的每一项
      for (let i = 0; i < arr.length; i++) {
        //判断brr数组中是否有arr中的每一项，若没有就将那一项添加进去
        if (brr.indexOf(arr[i]) == -1) {
          brr.push(arr[i])
        }
      }
      //②最终返回空数组
      return brr
    }
    console.log(fn(arr));//打印👉[1, 2, 3, 4]

第四种：利用sort排序

let arr = [6, 2, 3, 3, 5, 4, 1]
    function fn(arr) {
      //arr排序
      arr = arr.sort()
      //定义一个brr空数组
      let brr = []
      //遍历arr中的每一项
      for (let i = 0; i < arr.length; i++) {
        //如果相邻的2个数不相等，就添加进去
        if (arr[i] !== arr[i - 1]) {
          brr.push(arr[i])
        }
      }
 
      //返回brr
      return brr
      
    }
    console.log(fn(arr));//打印👉[1, 2, 3, 4, 5, 6]

第五种：利用Array.filter()和indexOf()

let arr = [1, 2, 2, 3, 4, 4]
    function fn(){
      let brr = arr.filter((item,index)=>{
        return arr.indexOf(item)===index
      })
      return brr
    }
    console.log(fn());//打印👉[1, 2, 3, 4]

第六种：利用reduce()和includes()实现去重

let arr = [1, 2, 5, 3, 4, 4,5]
    function fn(){
      let brr = arr.reduce((pre,item)=>{
        return pre.includes(item)?pre:[...pre,item]
      },[])
      console.log(brr);//打印👉[1, 2, 5, 3, 4]
    }
    fn()

第七种：利用对象属性去重：利用对象属性唯一的特性，将数组元素放到对象属性中。

let arr = [1, 2, 2, 3, 4, 4, 5]
    function fn() {
      //设置一个空对象
      let brr = {}
      //循环数组的每一项，作为brr的key值，value随便设置
      arr.forEach((item, index) => {
        brr[arr[index]] = 'mmm'
      })
      //利用Object.keys()取出brr的key值，打印的是字符串-->打印👉 ['1', '2', '3', '4', '5']
      //再利用map方法将每一项取整，最终打印的是去重后的数组-->打印👉[1, 2, 3, 4, 5]
      brr = Object.keys(brr).map(item => parseInt(item))
 
      console.log(brr);//打印👉 [1, 2, 3, 4, 5]
    }
    fn()

第八种：双重for循环：使用双重for循环遍历数组，如果发现重复元素，就从原数组中删除此元素。

let arr = [5, 1, 2, 4, 5, 2, 6, 5, 4];
    //双重for循环，外面的循环从下标0开始，里面的循环从下标1开始，如外面的循环从数字5开始，里面的循环便从数字1开始
    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);
          //删除数据后，后面的数据需要补位，所以j需要再退一步比较
          j--;
        }
      }
    }
    let brr = arr;
    console.log(brr); //打印👉[5, 1, 2, 4, 6]