【视频教程】JS数组优雅去重-冰山工做室-沙翼-web前端

视频教程-数组去重

案例分析：

随机生成20个10之内的数字

随机生成10之内数字

let arr = Array.from({length:20},=>Math.random()*10|0);
console.log(arr);
//输出结果：
[5,4,7,0,0,0,8,0,2,9,3,0,0,1,5,9,2,8,6,0]

去重思路：

1. 双层循环，外层循环元素，内层循环时比较值
2. 值相同时，则删去这个值

利用splice直接在原数组进行操做

Array.prototype.distinct = function (){
    var arr = this,
        i,
        j,
        len = arr.length;
 
    for(i = 0; i < len; i++){
        for(j = i + 1; j < len; j++){
            if(arr[i] == arr[j]){
                arr.splice(j,1);
                len--;
                j--;
            }
        }
    }
    return arr;
};
 
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
var b = a.distinct();
console.log(b.toString()); //1,2,3,4,5,6,56

注意：删除相同值时，数组长度相应减一。

可是，咱们要注意的是，此种方法会改变原数组的值，也就是说，咱们改变了arr的结果。若是不想改变原数组改怎么办呢？

不改变原数组

Array.prototype.distinct = function(){
    var arr = this,
        result = [],
        i,
        j,
        len = arr.length;
  
    for(i = 0; i < len; i++){
        for(j = i + 1; j < len; j++){
            if(arr[i] === arr[j]){
                j = ++i;
            }
        }
        result.push(arr[i]);
    }
    return result;
}
var arra = [1,2,3,4,4,1,1,2,1,1,1];
arra.distinct()

此种方法，先建立一个空数组，而后利用双层循环，符合的，push进result数组中，若遇到相同值，则直接跳过，再也不进行push操做。这样，咱们就避免了对原数组的操做。

这种方法解决了操做原数组的问题，可是，若是数组的值特别大怎么办？好比说，数组arr有10000个值，找到第一项后，比较数组后面的值，那咱们须要比较9999次，找到第二项，须要比较9998次。可是，咱们已经肯定了，咱们的结果集中，就10个数，这样显然不是咱们想要的，怎么办呢？

为了提高性能，咱们能够从结果集中进行比较。

indexOf的使用

let rs = [];
for(let i=0;i<arr.length;i++){
    if(rs.indexOf arr[i] === -1){
        rs.push(arr[i])
    }
};
console.log(rs)

经过indexOf方法，若是获得的值为-1，则肯定数组中不存在该值，这样，咱们就把arr[i],push到数组中。这样咱们就获得了去重后的数组。

既然咱们想到了indexOf方法，那咱们是否是还能有更加简便的方法来使数组去重呢？

仔细想一想，咱们就会想到，数组的filter方法。

数组的filter方法

console.log(arr.filter(function(element,index,self){
    return self.indexOf(element) === index;
 }));

element是数组的每一个值，index是数组的索引，self是数组自己。

当使用indexOf方法时，若是数组的每项的indexOf方法获得的值与数组索引相同，则证实此值第一次出现，若是数组的索引与index的值不相同，则证实不是第一次出现。

前面咱们介绍的这些方法，都是使用数组自己的方法。其实在js中，还有一个特殊的东西，叫作对象。

对象去重法

var o={};
var new_arr=[];
for(var i=0;i<arr.length;i++){
    var k=arr[i];
    if(!o[k]){
        o[k]=true;
        new_arr.push(k);
    }
}
console.log(new_arr)

这种方法利用到，对象的属性惟一行，来进行判断。

为何要用到这种方法呢？其实前面的方法，都用到了双层循环，indexOf也不例外，可是利用对象的key来作判断时，咱们只用到了一次循环，这样就会大大增长运行的性能，利用对象去重也是这些方法中运行速度最快的一种。

前面介绍到的这些种方法，都是ES3,ES5中用到的方法，接下来咱们介绍一下利用ES6来进行数组去重的方法。

在本文的开头，咱们建立随机数组的时候，用到了 Array.from()方法，在ES6中新增了from方法。接下来咱们借助from方法和一些其余的方法来把数组进行去重。

form方法

let rs = Array.from(arr);

//获得与当前同样的数组
let rs= Array.from(new Set(arr));
// 利用ES6的Set方法进行去重。
console.log([...new Set(arr)]);
//这种方法只用到了13个字符，也是数组去重最方便的方法。

总结：

数组去重在咱们平常的开发中用到的比较少，可是咱们要理解其中的逻辑，以便于咱们更好的进行其余的开发任务。

关于咱们

原始高清视频下载

视频讲解-提取码：q82t

QQ答疑交流群:

600633658

咱们的连接：

知乎 掘金 今日头条 新浪微博 前端网 思否 简书 B站