Appearance

1. Set 结构去重 ​

这是 ES6 提供了新的数据结构 Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。 普通数组去重：

JavaScript
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    return [...new Set(arr)]
}

//es6 Set数据结构类似于数组，成员值是唯一的，有重复的值会自动去重。
//Set内部使用===来判断是否相等，类似'1'和1会两个都保存，NaN和NaN只会保存一个
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    return [...new Set(arr)]
}

//es6 Set数据结构类似于数组，成员值是唯一的，有重复的值会自动去重。
//Set内部使用===来判断是否相等，类似'1'和1会两个都保存，NaN和NaN只会保存一个

对象数组去重： 思路：将对象序列化为字符串，然后使用 set 结构去重，最后再反序列化为对象

JavaScript
const arr=[{name:'hh',age:12},{name:'hh',age:12},{name:'hhj',age:12}]

//序列化
const noRepeat=[...new Set(arr.map(item=>JSON.stringify(item)))]

//反序列化
const newArr=noRepeat.map(item=>JSON.parse(item))
const arr=[{name:'hh',age:12},{name:'hh',age:12},{name:'hhj',age:12}]

//序列化
const noRepeat=[...new Set(arr.map(item=>JSON.stringify(item)))]

//反序列化
const newArr=noRepeat.map(item=>JSON.parse(item))

2. indexOf 去重 1 ​

数组的 indexOf()方法可返回某个指定的元素在数组中首次出现的位置。该方法首先定义一个空数组 res，然后调用 indexOf 方法对原来的数组进行遍历判断，如果元素不在 res 中，则将其 push 进 res 中，最后将 res 返回即可获得去重的数组

JavaScript
    let arr = ['1','2','3',1,NaN,NaN,undefined,undefined,null,null, 'a','b','b'];
    function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    let res = []
    for (let i = 0; i < arr.length; i++) {
        if (res.indexOf(arr[i]) === -1) {
            res.push(arr[i])
        }
    }
    return res
}

//ps:这个方法不能分辨NaN,会出现两个NaN。是有问题的，下面那个方法好一点。
    let arr = ['1','2','3',1,NaN,NaN,undefined,undefined,null,null, 'a','b','b'];
    function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    let res = []
    for (let i = 0; i < arr.length; i++) {
        if (res.indexOf(arr[i]) === -1) {
            res.push(arr[i])
        }
    }
    return res
}

//ps:这个方法不能分辨NaN,会出现两个NaN。是有问题的，下面那个方法好一点。

3. indexOf 去重 2 ​

利用 indexOf 检测元素在数组中第一次出现的位置是否和元素现在的位置相等，如果不等则说明该元素是重复元素

JavaScript
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    return Array.prototype.filter.call(arr, function(item, index){
        return arr.indexOf(item) === index;
    });
}
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    return Array.prototype.filter.call(arr, function(item, index){
        return arr.indexOf(item) === index;
    });
}

4. 相邻元素去重 ​

这种方法首先调用了数组的排序方法 sort()，然后根据排序后的结果进行遍历及相邻元素比对，如果相等则跳过改元素，直到遍历结束

JavaScript
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    arr = arr.sort()
    let res = []
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] !== arr[i-1]) {
            res.push(arr[i])
        }
    }
    return res
}
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    arr = arr.sort()
    let res = []
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] !== arr[i-1]) {
            res.push(arr[i])
        }
    }
    return res
}

5. 对象属性名去重 ​

遍历，将数组的值添加到一个对象的属性名里，并给属性赋值，对象不能添加相同属性名，以这个为依据可以实现数组去重，然后用 Object.keys(对象)返回这个对象可枚举属性组成的数组，这个数组就是去重后的数组。

JavaScript
    let a = ['1', '2', '3', 1,NaN,NaN,undefined,undefined,null,null, 'a', 'b', 'b'];
    const unique = arr => {
        var obj = {}
        arr.forEach(value => {
            obj[value] = 0;//这步新添加一个属性，并赋值，如果不赋值的话，属性会添加不上去
        })
      //`Object.keys(对象)`返回这个对象可枚举属性组成的数组，这个数组就是去重后的数组
        return Object.keys(obj);
    }
    console.log(unique(a));//["1", "2", "3", "NaN", "undefined", "null", "a", "b"]
    let a = ['1', '2', '3', 1,NaN,NaN,undefined,undefined,null,null, 'a', 'b', 'b'];
    const unique = arr => {
        var obj = {}
        arr.forEach(value => {
            obj[value] = 0;//这步新添加一个属性，并赋值，如果不赋值的话，属性会添加不上去
        })
      //`Object.keys(对象)`返回这个对象可枚举属性组成的数组，这个数组就是去重后的数组
        return Object.keys(obj);
    }
    console.log(unique(a));//["1", "2", "3", "NaN", "undefined", "null", "a", "b"]

注意 这个方法会将 number,NaN,undefined,null，变为字符串形式，因为对象的属性名就是一个字符串。

6.Map 数据结构去重 ​

如果数组里面是一个个的对象，可以遍历一遍数组，在遍历中使用 map 来去重 举例：需要去除对象中 a 的值有重复的，可以按下面的写法去重

JavaScript
const arr=[{a:1,b:2},{a:2,b:4},{a:2,b:3},{a:3,b:1},{a:5,b:3}]

const map=new Map()

arr.forEach((item,index)=>{
  if(!map.has(item['a'])) {
    map.set(item['a'],item)
  }
})
const arr=[{a:1,b:2},{a:2,b:4},{a:2,b:3},{a:3,b:1},{a:5,b:3}]

const map=new Map()

arr.forEach((item,index)=>{
  if(!map.has(item['a'])) {
    map.set(item['a'],item)
  }
})
AI助手