JS数组去重

JS数组去重

这篇文章归纳了几个常用的数组去重的方法，如果还有其他方法欢迎各位读者在评论区留言

方案一：

• 有一个叫做Set的数据结构，是一个类似数组的结构
• 这个数据结构不接收重复数据
• 语法：new Set(数组)
• 返回值不是一个数组而是一个类似数组的结构
• 为了返回一个数组我们使用...运算符展开Set，然后放到数组中

let arr = [1, 3, 6, 3, 2, 1, 4, 5, 3, 2]
console.log('去重之前 : ', arr)
arr=[...new Set(arr)]
console.log(arr);
//output Array[1, 3, 6, 2, 4, 5]

方案二：

• 利用obj对象键值key不会重复的特点
• 先定义一个空的obj对象
• 循环遍历数组，以数组的元素值作为obj对象的键值key，遇到重复的元素值会修改key值，而不是添加key值
• 然后清空原数组的长度
• 遍历obj对象，将键值用push()添加到数组中

let arr = [1, 3, 6, 3, 2, 1, 4, 5, 3, 2]
console.log('去重之前 : ', arr)
let obj={}
for(let i=0;i<arr.length;i++){
    obj[arr[i]]=''  //对象的值随便设置，反正也用不到
}
arr.length=0
for(let k in obj){
    arr.push(k-0)//因为拿到的键值是字符所以用减法隐式转换为数值
}
console.log(arr);
//output Array[1, 2, 3, 4, 5, 6]

方案三：

• 循环遍历数组，使用数组API方法indexOf()检索数组
• 把数组的每个元素都检索一遍，检索的位置从当前元素的下一个元素开始，看看有没有和被检索元素相同的元素，如果有该方法会返回相同的值的索引，没有就返回-1
• 当该方法不返回-1的时候就代表存在重复的值，然后使用splice()方法删掉被检索的元素
• 注意当删除元素的时候数组的长度会发生改变，数组元素的索引值也会发生改变，所以要执行i–
• 或者倒着循环数组就不会发生数组塌陷问题

let arr = [1, 3, 6, 3, 2, 1, 4, 5, 3, 2]
console.log('去重之前 : ', arr)
for(let i=0;i<arr.length;i++){
    if(arr.indexOf(arr[i],i+1)!==-1){
        arr.splice(i,1)
        i--
    }
}
console.log(arr);
//outout Array[6, 1, 4, 5, 3, 2]

//倒着循环数组
for(let i=arr.length;i>=0;i--){
    if(arr.indexOf(arr[i],i+1)!==-1){
         arr.splice(i,1)
     }
}
console.log(arr); 
//outout Array[6, 1, 4, 5, 3, 2]

方案四：

• 准备一个新的数组
• 循环遍历原数组，使用indexOf()方法，检索新数组中是否存在被检索的值
• 如果没有就把被检索的值添加到新数组中，没有就不添加
• 最后再把新数组的值赋给原数组，覆盖掉原数组的值

let arr = [1, 3, 6, 3, 2, 1, 4, 5, 3, 2]
console.log('去重之前 : ', arr)
let newArr=[]
for(let i=0;i<arr.length;i++){
    if(newArr.indexOf(arr[i])===-1){
         newArr.push(arr[i])
     }
}
arr=newArr
console.log(arr); 
//output Array[1, 3, 6, 2, 4, 5]

方案五：

• 先使用sort()方法对数组进行排序
• 循环遍历数组，判断正在遍历的元素与下一个元素是否相同，相同就使用splice()方法删除
• 删除后数组长度会发生变化，发生数组塌陷，所以要执行i–
• 反向遍历数组可以避免数组塌陷

let arr = [1, 3, 6, 3, 2, 1, 4, 5, 3, 2]
console.log('去重之前 : ', arr)
arr.sort((a,b)=>a-b)
console.log(arr);
//output Array[1, 1, 2, 2, 3, 3, 3, 4, 5, 6]
for(let i=0;i<arr.length;i++){
     if(arr[i]===arr[i+1]){
        arr.splice(i,1)
        i--
     }
}
console.log(arr);
//output Array[1, 2, 3, 4, 5, 6]

方案六：

• 定义一个has()函数判断数组中是否存在一个值，返回一个布尔值
• 定义一个新数组来存放去重后的元素
• 循环遍历数组，利用has()函数判断新数组中是否存在遍历的元素，如果不存在就将这个元素添加到新数组中，存在就不添加
• 最后用新数组的值覆盖原数组

let arr = [1, 3, 6, 3, 2, 1, 4, 5, 3, 2]
console.log('去重之前 : ', arr)
function has(arr,val){
     for(let i=0;i<arr.length;i++){
         if(arr[i]===val){
               return true
         }
     }
     return false
}
let newArr=[]
for(let j=0;j<arr.length;j++){
    const exist=has(newArr,arr[j])
    if(exist===false){
        newArr.push(arr[j])
     }
}
arr=newArr
console.log(arr);
//output Array[1, 3, 6, 2, 4, 5]

方案七：

• 定义一个新数组存放去重后的元素
• 使用reduce()方法
• reduce(function(res,curr){})中res代表累计值，curr代表当前正在处理的元素

let arr = [1, 3, 6, 3, 2, 1, 4, 5, 3, 2]
console.log('去重之前 : ', arr)
const newArr = arr.reduce(function (result, curr) {
            if (!result.includes(curr)) {
                result.push(curr)
            }
            return result
        }, [])
arr=newArr
console.log('去重后：', arr)