数组去重与数组合并去重

数组去重

（1）indexOf()方法

let arr = [4, 1, 3, 2, 4, 1, 2]  
arr = removeRepeat(arr)
console.log(arr) // [ 1, 2, 3, 4 ]

function removeRepeat(val){
    let newArr = []
    val.forEach( item => {
        if(newArr.indexOf(item) == -1){
            newArr.push(item)
        }
    })
    return newArr.sort()
}
           

使用indexOf()方法，判断当前值是否在新数组中存在，如若不存在，即返回值为

-1

，就将其push到新数组中

（2）splice()方法

let arr = [4, 1, 3, 2, 4, 1, 2]  
arr = removeRepeat(arr)
console.log(arr) // [ 1, 2, 3, 4 ]

function removeRepeat(val){
    for(i = 0; i < val.length - 1; i++){
        for (var j = i + 1; j < val.length; j++) {
            if(val[i] == val[j]){
                val.splice(j, 1)
                j--
            }
        }
    }
    return val.sort()
}
           

使用splice()方法去重需要使用

两层for

循环，使用数组中的第一个值依次与后面的每一个值进行判断，看其是否相等，如若相等，则使用splice()方法从

后面相等值

的下标开始

删除1项

，然后让

j

进行自减，因为减去一个值后，原数组的长度发生了变化，即后面的值已经填充了刚才删除值得位置，所以需要再次进行判断

（3）数组下标判断法

let arr = [4, 1, 3, 2, 4, 1, 2] 
arr = removeRepeat(arr)
console.log(arr) // [ 1, 2, 3, 4 ]

function removeRepeat(val){
    let newArr = []
    for (var i = 0; i < val.length; i++) {
       if(val.indexOf(val[i]) == i){
           newArr.push(val[i])
       }
    }
    return newArr.sort()
}
           

indexOf()

方法的定义：可返回某个指定的字符串值在字符串中

首次出现的位置

，正是使用了这一特性，判断值首次出现时的

i

和使用

indexOf()

方法查找的是否一直，若二者相等，则表示该值是首次出现

（4）排序相邻去除

let arr = [4, 1, 3, 2, 4, 1, 2] 
arr = removeRepeat(arr)
console.log(arr) // [ 1, 2, 3, 4 ]

function removeRepeat(val){
    val = val.sort((a, b) => a - b)
    let newArr = [val[0]]
    for (var i = 1; i < val.length; i++) {
        if(val[i] !== newArr[newArr.length - 1]){
            newArr.push(val[i])
        }
    }
    return newArr
}
           

注意：使用此方法必须先对数组进行排序（升序降序均可），将排序后的第一个值放入新数组，然后从第二个值开始判断，其是否与新数组中的最后一个相等，如若不等，即可向新数组中push

（5）ES6中Set()去重

let arr = [4, 1, 3, 2, 4, 1, 2] 
arr = removeRepeat(arr)
console.log(arr) // [ 1, 2, 3, 4 ]

// 可以使用ES6的扩展运算符
function removeRepeat(val){
    return [ ...new Set(val) ].sort()
}

// 可以使用Array.form()
function removeRepeat(val){
    return Array.from(new Set(val)).sort()
}
           

ES6中新增了Set容器，它类似于数组，但是成员的值都是唯一的，没有重复的值，

Set()

本身是一个

构造函数

，所以需要使用

new关键字

（6）利用对象的属性去重

let arr = [4, 1, 3, 2, 4, 1, 2] 
arr = removeRepeat(arr)
console.log(arr) // [ 1, 2, 3, 4 ]

function removeRepeat(val){
    let newArr = []
    let obj = {}
    val.forEach(item => {
        if(!obj[item]){
            newArr.push(item)
            obj[item] = 1
        }
    })
    return newArr.sort()
}
           

因为对象中的键名是不能重复的，所以将不重复的值在对象中进行标识。首先判断每一个值是否作为键名存放在对象中，如若没有，则向新数组中push该值，并且在对象中将

以该值作为键名的键值

赋值为

1

数组合并去重

// 方法一
let m = [3, 1, 2], 
    n = [3 ,4 ,5, 2],
    result = []
    result = removeRepeat(m, n)
console.log(result) // [ 1, 2, 3, 4, 5 ]

function removeRepeat(){
    let arr = [].concat.apply([], arguments)
    return Array.from(new Set(arr)).sort()
}

// 方法二
let m = [3, 1, 2], 
    n = [3 ,4 ,5, 2],
    result = []
    result = removeRepeat(m, n)
console.log(result) // [ 1, 2, 3, 4, 5 ]

function removeRepeat(m, n){
    let arr = m.concat(n)
    return [ ...new Set(arr) ].sort()
}
           

方法一首先使用

apply()

方法接收类数组，然后再使用

concat()

方法进行合并，最后使用

Set()

方法进行去重

方法二首先将两个数组使用

concat()

进行合并，然后使用

Set()

方法进行去重

这次的分享就到这里了，后续了解了新的知识再来补充~~