数组去重的几种实现方法

1. 使用Set

ES6 提供了新的数据结构Set， 它类似数组，和C++中的set容器一样，它成员的值都是唯一的，没有重复的值；Set本身是一个构造函数，用来生成Set数据结构。

var s = new Set();
s.add("hello").add("goodbye").add("hello");
s.size === 2;
s.has("hello") === true;

const s = new Set();
[2,3,5,4,5,2,2].forEach(x => s.add(x));
for(let i of s) {
    console.log(i);
}
// 2 3 5 4

还有更简单的方式

function dedupe(array) {
    return Array.from(new Set(array));
}
dedupe([1, 1, 2, 3]);//[1, 2, 3]

上面这种方式在于Array.from方法可以将Set结构转化为数组。如果你还觉得不过瘾，那么还有一种表示方式：将扩展运算符(...)与Set结构相结合，就可以去除数组的重复成员；扩展运算符内部使用for...of循环。

[...new Set(array)]

2. indexOf的方法

这种方法新建一个存储数组，遍历参数数组，如果新数组中没找到该元素的索引，则把该元素push进新数组。

function dedupe(array) {
    var newArr = [];
    for(var i=0; i<array.length; i++) {
        if(newArr.indexOf(array[i]) == -1) {
            newArr.push(array[i]);
        }
    }
    return newArr;
}
var arr = [1, 1, 2, 2, 3, 3];
console.log(dedupe(arr));//[1, 2, 3]

3. 比较数组下标

我们知道，通过比较数组下标可以从数组中找到重复的数字，那么自然可以根据数组成员第一次时的索引值i进行判断，该方法类似indexOf的方法。

function dedupe(array) {
    var newArr = [];
    for(var i=0; i<array.length; i++) {
        if(array.indexOf(array[i]) == i) {
            newArr.push(array[i]);
        }
    }
    return newArr;
}
var arr = [1, 1, 2, 2, 3, 3];
console.log(dedupe(arr));//[1, 2, 3]

4. 对象查找

function dedupe(arr) {
    var res = [];
    var o = Object.create(null);
    for(let v of arr) {
        var type = typeof v;
        if(!o[v]) {
            res.push(v);
            o[v] = [type];
        }else if(o[v].indexOf(type) == -1) {
            o[v].push(type);
             res.push(v);
        }
    }
    return res;
}
var arr = [1, 2, ‘2‘, 4, 7, ‘a‘, ‘a‘, 2, 3, 7, 6, 7];
console.log(dedupe(arr));//[1, 2, ‘2‘, 4, 7, ‘a‘, 3, 6]

5. 排序相邻去重

function dedupe(arr) {
    arr.sort();
    var newArr = [arr[0]];
    for(var i=1; i<arr.length; i++) {
        if(arr[i] !== newArr[newArr.length-1]) {
             newArr.push(arr[i]);
        }
    }
    return newArr;
}
var arr = [1, 2, ‘2‘, 4, 7, ‘a‘, ‘a‘, 2, 3, 7, 6, 7];
console.log(dedupe(arr));//[1, "2", 2, 3, 4, 6, 7, "a"]

6. 数组实例的includes方法

function dedupe(arr) {
    var res=[];
    for(let v of arr) {
        if(!res.includes(v)) {
            res.push(v);
        }
    }
return res;
}
var arr = [1, 2, ‘2‘, 4, 7, ‘a‘, ‘a‘, 2, 3, 7, 6, 7];
console.log(dedupe(arr));//[1, 2, "2", 4, 7, "a", 3, 6]

7. 暴力去重

function dedupe(arr) {
    arr.sort();
    console.log(arr);
    for(var i=1; i<arr.length; i++) {
        if(arr[i]===arr[i-1]) {
            arr.splice(i, 1);
             i--;
        }

    }
    return arr;
}
var arr = [1, 2, ‘2‘, 4, 2, 7, ‘a‘, ‘a‘, 2, 3, 7, 6, 7, 7, 7];
console.log(dedupe(arr));
//[1, "2", 2, 2, 2, 3, 4, 6, 7, 7, 7, 7, 7, "a", "a"]
//[1, "2", 2, 3, 4, 6, 7, "a"]

var arr0 = [5, 1, 2, ‘2‘, 4, ‘2‘, 2, 5, 7, ‘a‘, ‘a‘, 2, 3, ‘7‘, 6, ‘7‘, 7, 7];
console.log(dedupe(arr));
//[1, 2, "2", "2", 2, 2, 3, 4, 5, 5, 6, 7, 7, "7", 7, "7", "a", "a"]
//[1, 2, "2", 2, 3, 4, 5, 6, 7, "7", 7, "7", "a"]

上面这种方式最好只用在数字数组或字符串数组去重，由于sort()排序方式的原因，再加上只比较相邻元素是否相等，当出现如arr0类似数组时，去重将会出现遗漏；因此最好对单一类型数组进行去重；

参考：

http://es6.ruanyifeng.com/#docs/set-map

http://es6.ruanyifeng.com/#docs/array

原文地址：https://www.cnblogs.com/princess-knight/p/9276992.html