JavaScript几种数组去重方法（更新中...）

数组去重方法

一、利用ES6 Set去重

(1) Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用；
例：new Set([1,1,2,2,3,3])，得到的是 [1,2,3]
(2) Array.from() 方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例

function fun(arr) {
	return Array.from(new Set(arr));
}
var arr = [1, 1, 2, 2, 3, 3, "", "", NaN, NaN, undefined, 
			undefined, null, null, {}, {}, [], []];
console.log(fun(arr));
// 结果：[1, 2, 3, "", NaN, undefined, null, {…}, {…}, Array(0),Array(0)]

这种去重的方法代码最少，而且效率也好，但无法去掉 “{ }”和“[ ]”
这种方法的代码还可以进一步化简：

[...new Set(arr)] 

二、利用for循环嵌套比较，splice方法去重

splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组

function fun(arr) {
    for(var i=0; i<arr.length; i++){
        for(var j=i+1; j<arr.length; j++){
            if(arr[i] === arr[j]){
                arr.splice(j,1);
                j--;
            }
        }
    }
    return arr;
}
var arr = [1,1,0,0,false,false,[],[],"","",undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(fun(arr));
// 结果： [1, 0, false, Array(0), Array(0), "", undefined, null, NaN, NaN,{},{}]

这种方法较容易想到，但是无法去掉 “{ }”和“[ ]”还有NaN，而且效率低

三、方法二的升级：利用for…of和includes方法

includes() 方法用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false

function fun(arr) {
    let result = [];
    for(let value of arr){
            if(!result.includes(value)){
              result.push(value ); 
            }
    }
    return result;
}
var arr = [1,1,0,0,false,false,[],[],"","",undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(fun(arr));
// 输出：[1, 0, false, Array(0), Array(0), "", undefined, null, NaN, {…}, {…}]

这种方法比二效率高一点，而且可以去除NaN

四、先排序再去重

sort()方法可以对数组的元素进行排序，并返回数组

function fun(arr) {
    let sortarr = arr.sort();
    let len = sortarr.length;
    let result = [sortarr[0]];
    for(let i=1; i<len; i++){
        if(sortarr[i] !== sortarr[i-1]){
            result.push(sortarr[i]);
        }
    }
    return result;
}
var arr = [1,1,0,0,false,false,[],[],"","",undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(fun(arr));
// 输出：[Array(0), Array(0), "", 0, 1, NaN, NaN, {…}, {…}, false, null, undefined]

这种方法省去了对重复参数的索引。效率上面确实也提升不少。只做了一次排序和一次循环，对于一些重复性比较高的数组进行去重，效率明显提升

五、利用filter和hasOwnProperty

1.filter()方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素

const nums = [1,2,3,4,5,6];
const result = nums.filter(num => num>3);
console.log(result);
// 输出： [4,5,6]

2.hasOwnProperty() 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）

const object1 = {};
object1.property1 = 42;
console.log(object1.hasOwnProperty('property1'));
// 输出: true

例：

function fun(arr) {
   var obj = {};
   return arr.filter(function(item, index, arr){
   //这里我一直搞不懂是什么意思，希望有大佬知道的可以在评论区指导小弟一下~
       return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true);
   })
}
var arr = [1,1,0,0,false,false,[],[],"","",undefined,undefined,null,null,NaN,NaN,{},{}];
console.log(fun(arr));
// 输出：[1, 0, false, Array(0), "", undefined, null, NaN, {…}]

这种方法就可以去除 “{ }”和“[ ]” 了

参考博客：https://segmentfault.com/a/1190000016418021
https://zhuanlan.zhihu.com/p/93301588