资讯专栏INFORMATION COLUMN

JS基础篇--JS实现数组去重方法整理

fjcgreat / 3000人阅读

摘要:使用进行操作,如下但是得到的其实是一个非常规的数组了,也就是说其实主要是用于对对象属性的操作。这确实要根据自己的需求来了。当然简单的实现如下好了到了这儿,我们开始总结下常用的数组去重的方法。

前言

我们先来看下面的例子,当然来源与网络,地址《删除数组中多个不连续的数组元素的正确姿势》

我们现在将数组中所有的‘a’元素删除:

var arr = ["a", "a", "b", "c", "d", "a", "a", "e", "g", "a", "f"];
arr.forEach(function(value, index) {
    value === "a" ? arr.splice(index, 1) : "";
})
console.log(arr); //["a", "b", "c", "d", "a", "e", "g", "f"]

只要相邻的‘ a’ 元素, 都没被删除,splice不但可以删除元素本身, 还同时可以减少数组长度( 就是抹去一切痕迹),
这样导致后续的数组元素会代替已经删除的元素的位置, 但是循环是按照数组的下标按顺序删除, 这样就会漏掉迁移的元素。

使用delete进行操作,如下:

var arr = ["a", "a", "b", "c", "d", "a", "a", "e", "g", "a", "f"];
arr.forEach(function(value, index) {
   value === "a" ? delete arr[index] : "";
})
console.log(arr); //[2: "b", 3: "c", 4: "d", 7: "e", 8: "g", 10: "f"]

但是得到的arr其实是一个非常规的数组了,也就是说其实delete主要是用于对对象属性的操作。这确实要根据自己的需求来了。

当然简单的实现如下:

var arr = ["a", "a", "b", "c", "d", "a", "a", "e", "g", "a", "f"];
var newArr = arr.filter(function(key) {
    return key !== "a"

})
console.log(newArr); //["b", "c", "d", "e", "g", "f"]

好了到了这儿,我们开始总结下常用的数组去重的方法。

方法一:

双层循环,外层循环元素,内层循环时比较值
如果有相同的值则跳过,不相同则push进数组

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();             //返回[3,4,2,1]
方法二:利用splice直接在原数组进行操作

双层循环,外层循环元素,内层循环时比较值
值相同时,则删去这个值
注意点:删除元素之后,需要将数组的长度也减1.

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

优点:简单易懂
缺点:占用内存高,速度慢

方法三:利用对象的属性不能相同的特点进行去重
Array.prototype.distinct = function (){
    var arr = this,
        i,
        obj = {},
        result = [],
        len = arr.length;

    for(i = 0; i< arr.length; i++){
        if(!obj[arr[i]]){    //如果能查找到,证明数组元素重复了
            obj[arr[i]] = 1;
            result.push(arr[i]);
        }
    }
    return result;
};

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
方法四:数组递归去重

运用递归的思想
先排序,然后从最后开始比较,遇到相同,则删除

Array.prototype.distinct = function (){
    var arr = this,
        len = arr.length;

    arr.sort(function(a,b){        //对数组进行排序才能方便比较
        return a - b;
    })

    function loop(index){
        if(index >= 1){
            if(arr[index] === arr[index-1]){
                arr.splice(index,1);
            }
            loop(index - 1);    //递归loop函数进行去重
        }
    }
    loop(len-1);

    return arr;
};

var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,56,45,56];
var b = a.distinct();
console.log(b.toString());        //1,2,3,4,5,6,45,56
方法五:利用indexOf以及forEach

首先如果你的浏览器是低版本不支持indexOfforEach方法,那么可以先先对浏览器Array对象进行支持indexOf和forEach的polyfill

Array.prototype.indexOf = Array.prototype.indexOf || function(item) {
    for (var i = 0, j = this.length; i < j; i++) {
        if (this[i] === item) {
            return i;
        }
    }
    return -1;
}

Array.prototype.forEach = Array.prototype.forEach || function(callback, thisArg) {
    if (!callback || typeof callback !== "function") return;

    for (var i = 0, j = this.length; i < j; i++) {
        callback.call(thisArg, this[i], i, this);
    }
}

去重方法:

Array.prototype.distinct = function (){
    var arr = this,
        result = [],
        len = arr.length;

    arr.forEach(function(v, i ,arr){        //这里利用map,filter方法也可以实现
        var bool =  arr.indexOf(v,i+1);        //从传入参数的下一个索引值开始寻找是否存在重复
        if(bool === -1){
            result.push(v);
        }
    })

    return result;
};

var a = [1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,3,2,3,3,2,2,1,23,1,23,2,3,2,3,2,3];
var b = a.distinct();
console.log(b.toString());    //1,23,2,3
方法六:数组下标判断法, 遍历数组,利用indexOf判断元素的值是否与当前索引相等,如相等则加入
Array.prototype.distinct = function (){
    var arr = this,
        ret = [];

    arr.forEach(function(e, i, array) {
        if (array.indexOf(e) === i) {
            ret.push(e);
        }
    });

    return ret;
};

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
方法七:利用ES6的set

Set数据结构,它类似于数组,其成员的值都是唯一的。
利用Array.from将Set结构转换成数组

function dedupe(array){
    return Array.from(new Set(array));
}

dedupe([1,1,2,3]) //[1,2,3]

拓展运算符(...)内部使用for...of循环

let arr = [1,2,3,3];
let resultarr = [...new Set(arr)];   
console.log(resultarr);  //[1,2,3]

当然以上方法可以不用写到Array的原型上,多带带写一个方法,传递数组当参数也是可以的。

参考地址:http://www.cnblogs.com/leonwang/p/4845576.html

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/90311.html

相关文章

  • JavasScript重难点知识

    摘要:忍者级别的函数操作对于什么是匿名函数,这里就不做过多介绍了。我们需要知道的是,对于而言,匿名函数是一个很重要且具有逻辑性的特性。通常,匿名函数的使用情况是创建一个供以后使用的函数。 JS 中的递归 递归, 递归基础, 斐波那契数列, 使用递归方式深拷贝, 自定义事件添加 这一次,彻底弄懂 JavaScript 执行机制 本文的目的就是要保证你彻底弄懂javascript的执行机制,如果...

    forsigner 评论0 收藏0
  • JS基础入门(十五)—数组去重

    摘要:目的把数组中重复的内容去掉。思路每次取出数组一项和其他的所有项比较如果比较有相同的把重复的这个后面的删掉。是位置,表示长度。改进思路三键名是数据类型的前三位组成的字符串。思路四使用的方法可以去除数组内重复的表明展开数组的每一项 目的:把数组中重复的内容去掉。eg:将数组[2, 3, 1, 4, 2, 2, 3, 4, 1, 5,1]变成[2, 3, 1, 4, 5, 1]。 思路1: ...

    Youngdze 评论0 收藏0
  • JS基础入门(十五)—数组去重

    摘要:目的把数组中重复的内容去掉。思路每次取出数组一项和其他的所有项比较如果比较有相同的把重复的这个后面的删掉。是位置,表示长度。改进思路三键名是数据类型的前三位组成的字符串。思路四使用的方法可以去除数组内重复的表明展开数组的每一项 目的:把数组中重复的内容去掉。eg:将数组[2, 3, 1, 4, 2, 2, 3, 4, 1, 5,1]变成[2, 3, 1, 4, 5, 1]。 思路1: ...

    Yi_Zhi_Yu 评论0 收藏0
  • JS基础入门(十五)—数组去重

    摘要:目的把数组中重复的内容去掉。思路每次取出数组一项和其他的所有项比较如果比较有相同的把重复的这个后面的删掉。是位置,表示长度。改进思路三键名是数据类型的前三位组成的字符串。思路四使用的方法可以去除数组内重复的表明展开数组的每一项 目的:把数组中重复的内容去掉。eg:将数组[2, 3, 1, 4, 2, 2, 3, 4, 1, 5,1]变成[2, 3, 1, 4, 5, 1]。 思路1: ...

    YacaToy 评论0 收藏0
  • 【重温基础】11.Map和Set对象

    摘要:本文是重温基础系列文章的第十一篇。返回一个布尔值,表示该值是否为的成员。使用回调函数遍历每个成员。与数组相同,对每个成员执行操作,且无返回值。 本文是 重温基础 系列文章的第十一篇。 今日感受:注意身体,生病花钱又难受。 系列目录: 【复习资料】ES6/ES7/ES8/ES9资料整理(个人整理) 【重温基础】1.语法和数据类型 【重温基础】2.流程控制和错误处理 【重温基础】3....

    meteor199 评论0 收藏0

发表评论

0条评论

fjcgreat

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<