JS实现数组去重方法整理

时间：2021-07-31 03:36:59

前言

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

我们现在将数组中所有的‘ 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"]

下面总结下常用实现方式。

方法一：

  1. 双层循环，外层循环元素，内层循环时比较值

  2. 如果有相同的值则跳过，不相同则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. 双层循环，外层循环元素，内层循环时比较值

  2. 值相同时，则删去这个值

注意点:删除元素之后，需要将数组的长度也减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

方法四：数组递归去重

  1. 运用递归的思想

  2. 先排序，然后从最后开始比较，遇到相同，则删除

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

首先如果你的浏览器是低版本不支持indexOf与forEach方法，那么可以先先对浏览器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的原型上，单独写一个方法，传递数组当参数也是可以的。

参考地址：

文章更新于2017-12-07


相关文章