js-数组去重的几种方法

参考链接:https://blog.csdn.net/weixin_42412046/article/details/81459294

1、定义一个新数组,并存放原数组的第一个元素,然后将元素组一一和新数组的元素对比,若不同则存放在新数组中。

        function unique(arr) {
            let newArr = [arr[0]];
            for (let i = 1; i < arr.length; i++) {
                let repeat = false;
                for (let j = 0; j < newArr.length; j++) {
                    if (arr[i] === newArr[j]) {
                        repeat = true;
                        break;
                    }else{
                        
                    }
                }
                if (!repeat) {
                    newArr.push(arr[i]);
                }
            }
            return newArr;
        }
 
        console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 结果是[1, 2, 3, 5, 6, 7, 4]

2、先将原数组排序,在与相邻的进行比较,如果不同则存入新数组。

        function unique2(arr) {
            var formArr = arr.sort()
            var newArr=[formArr[0]]
            for (let i = 1; i < formArr.length; i++) {
                if (formArr[i]!==formArr[i-1]) {
                    newArr.push(formArr[i])
                }
            }
            return newArr
        }
        console.log(unique2([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 结果是[1, 2, 3,  4,5, 6, 7]

3、利用对象属性存在的特性,如果没有该属性则存入新数组。

        function unique3(arr) {
            var obj={}
            var newArr=[]
            for (let i = 0; i < arr.length; i++) {
                if (!obj[arr[i]]) {
                    obj[arr[i]] = 1
                    newArr.push(arr[i])
                }   
            }
            return newArr
        }
        console.log(unique3([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 结果是[1, 2, 3, 5, 6, 7, 4]

4、利用数组的indexOf下标属性来查询。

        function unique4(arr) {
            var newArr = []
            for (var i = 0; i < arr.length; i++) {
                if (newArr.indexOf(arr[i])===-1) {
                    newArr.push(arr[i])
                }
            }
            return newArr
        }
        console.log(unique4([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 结果是[1, 2, 3, 5, 6, 7, 4]

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

语法

str.includes(searchString[, position])

参数

searchString

要在此字符串中搜索的字符串。

position

可选。从当前字符串的哪个索引位置开始搜寻子字符串,默认值为0。

返回值

如果当前字符串包含被搜寻的字符串,就返回 true;否则返回 false。

描述

这个方法可以帮你判断一个字符串是否包含另外一个字符串。

区分大小写

includes() 方法是区分大小写的。例如,下面的表达式会返回 false :

'Blue Whale'.includes('blue'); // returns false

5、利用数组原型对象上的includes方法。

        function unique5(arr) {
            var newArr = []
            for (var i = 0; i < arr.length; i++) {
                if (!newArr.includes(arr[i])) {
                    newArr.push(arr[i])
                }
            }
            return newArr
        }
        console.log(unique5([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 结果是[1, 2, 3, 5, 6, 7, 4]

6、利用数组原型对象上的 filter 和 includes方法。

        function unique6(arr) {
            var newArr = []
            newArr = arr.filter(function (item) {
                return newArr.includes(item) ? '' : newArr.push(item)
            })
            return newArr
        }
        console.log(unique6([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 结果是[1, 2, 3, 5, 6, 7, 4]

7、利用数组原型对象上的 forEach 和 includes方法。

        function unique7(arr) {
            var newArr = []
            array.forEach(item => {
                return newArr.includes(item) ? '' : newArr.push(item)
            });
            return newArr
        }
        console.log(unique7([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 结果是[1, 2, 3, 5, 6, 7, 4]

8、利用数组原型对象上的 splice 方法。

splice() 方法向/从数组中添加/删除项目,然后返回被删除的项目。

注释:该方法会改变原始数组。

语法

arrayObject.splice(index,howmany,item1,.....,itemX)
参数描述
index必需。整数,规定添加/删除项目的位置,使用负数可从数组结尾处规定位置。
howmany必需。要删除的项目数量。如果设置为 0,则不会删除项目。
item1, ..., itemX可选。向数组添加的新项目。

返回值

类型描述
Array包含被删除项目的新数组,如果有的话。

说明

splice() 方法可删除从 index 处开始的零个或多个元素,并且用参数列表中声明的一个或多个值来替换那些被删除的元素。

如果从 arrayObject 中删除了元素,则返回的是含有被删除的元素的数组。

        function unique8(arr) {
            var 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;
        }
        console.log(unique8([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));

9、利用数组原型对象上的 lastIndexOf 方法。

        function unique9(arr) {
            var res = [];
            for (var i = 0; i < arr.length; i++) {
                res.lastIndexOf(arr[i]) !== -1 ? '' : res.push(arr[i]);
            }
            return res;
        }
        console.log(unique9([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 结果是[1, 2, 3, 5, 6, 7, 4]

10、 利用 ES6的set 方法。

ES6 提供了新的数据结构 Set。它类似于数组,但是成员的值都是唯一的,没有重复的值

Array.from() 方法从一个类似数组或可迭代对象创建一个新的,浅拷贝的数组实例。

console.log(Array.from('foo'));
// expected output: Array ["f", "o", "o"]

console.log(Array.from([1, 2, 3], x => x + x));
// expected output: Array [2, 4, 6]
Array.from(arrayLike[, mapFn[, thisArg]])

参数

arrayLike

想要转换成数组的伪数组对象或可迭代对象。

mapFn 可选

如果指定了该参数,新数组中的每个元素会执行该回调函数。

thisArg 可选

可选参数,执行回调函数 mapFn 时 this 对象

        function unique10(arr) {
            //Set数据结构,它类似于数组,其成员的值都是唯一的
            return Array.from(new Set(arr)); // 利用Array.from将Set结构转换成数组
        }
        console.log(unique10([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
        // 结果是[1, 2, 3, 5, 6, 7, 4]

11、使用filter函数

function unique11(arr){
    r = arr.filter(function (element, index, self) {
        return self.indexOf(element) === index
    })
    return r
}
console.log(unique11([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
// 结果是[1, 2, 3, 5, 6, 7, 4]

 

### 回答1: 有以下几种方法可以对JavaScript数组进行: 1. 使用 Set 数据结构: ```javascript let arr = [1, 2, 2, 3, 3, 4]; let uniqueArr = [...new Set(arr)]; console.log(uniqueArr); // [1, 2, 3, 4] ``` 2. 使用 filter() 方法: ```javascript let arr = [1, 2, 2, 3, 3, 4]; let uniqueArr = arr.filter((item, index, array) => { return array.indexOf(item) === index; }); console.log(uniqueArr); // [1, 2, 3, 4] ``` 3. 使用 reduce() 方法: ```javascript let arr = [1, 2, 2, 3, 3, 4]; let uniqueArr = arr.reduce((prev, cur) => { if (prev.indexOf(cur) === -1) { prev.push(cur); } return prev; }, []); console.log(uniqueArr); // [1, 2, 3, 4] ``` 4. 使用 Map 数据结构: ```javascript let arr = [1, 2, 2, 3, 3, 4]; let map = new Map(); let uniqueArr = []; arr.forEach(item => { if (!map.has(item)) { map.set(item, true); uniqueArr.push(item); } }); console.log(uniqueArr); // [1, 2, 3, 4] ``` 这些方法中,使用 Set 数据结构的方法最简单,代码最短。 ### 回答2: JS数组几种方法有以下几种: 1. 使用Set:将数组转换为Set,Set中的元素是唯一的,然后将Set转换回数组。例如: ```javascript var arr = [1, 2, 3, 3, 4, 4, 5]; var uniqueArr = Array.from(new Set(arr)); console.log(uniqueArr); // [1, 2, 3, 4, 5] ``` 2. 使用indexOf:遍历数组,使用indexOf方法判断元素在新数组中是否存在,如果不存在则将元素添加到新数组中。例如: ```javascript var arr = [1, 2, 3, 3, 4, 4, 5]; var uniqueArr = []; for (var i = 0; i < arr.length; i++) { if (uniqueArr.indexOf(arr[i]) === -1) { uniqueArr.push(arr[i]); } } console.log(uniqueArr); // [1, 2, 3, 4, 5] ``` 3. 使用includes:遍历数组,使用includes方法判断元素在新数组中是否存在,如果不存在则将元素添加到新数组中。例如: ```javascript var arr = [1, 2, 3, 3, 4, 4, 5]; var uniqueArr = []; for (var i = 0; i < arr.length; i++) { if (!uniqueArr.includes(arr[i])) { uniqueArr.push(arr[i]); } } console.log(uniqueArr); // [1, 2, 3, 4, 5] ``` 以上是常见的几种JS数组方法,具体选择哪种方法可以根据实际需求和性能要求进行选择。 ### 回答3: 在JavaScript中,数组有多种方法: 1. 使用Set:Set是ES6中的新数据类型,它只能存储唯一的值。我们可以将数组转换成Set,然后再将Set转换回数组即可实现。 ```javascript let arr = [1, 2, 3, 3, 4, 4, 5]; let uniqueArr = [...new Set(arr)]; console.log(uniqueArr); // [1, 2, 3, 4, 5] ``` 2. 使用filter方法:通过使用filter方法遍历数组,返回一个新数组,只保留第一次遇到的元素。 ```javascript let arr = [1, 2, 3, 3, 4, 4, 5]; let uniqueArr = arr.filter((item, index, array) => { return array.indexOf(item) === index; }); console.log(uniqueArr); // [1, 2, 3, 4, 5] ``` 3. 使用reduce方法:通过使用reduce方法遍历数组,返回一个新数组,只保留第一次遇到的元素。 ```javascript let arr = [1, 2, 3, 3, 4, 4, 5]; let uniqueArr = arr.reduce((prev, curr) => { if (prev.indexOf(curr) === -1) { prev.push(curr); } return prev; }, []); console.log(uniqueArr); // [1, 2, 3, 4, 5] ``` 以上是JS数组几种常见方法,可以根据具体情况选择合适的方法进行使用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值