js数组去重 性能最好

在JavaScript中，数组去重的性能最好的方法是使用ES6中的Set数据结构。Set是一种无序且唯一的数据结构，可以用来去除数组中的重复项。具体实现方法如下：

function distinct(arr1, arr2) {
let set = new Set([...arr1, ...arr2]);
return Array.from(set);
}

这种方法的时间复杂度为O(n)，性能较其他方法更优秀。

相关问题

js 数组去重 最好的

引用和提供了关于JavaScript数组去重的方法，下面将列举其中六种常见的数组去重方法。请注意，这些方法都是针对JavaScript语言的。

1. 使用Set：Set是ES6中引入的数据结构，它可以存储唯一的值。通过将数组转换为Set，然后再将Set转换回数组，即可实现数组去重。例如：

   const arr = [1, 2, 2, 3, 4, 4];
   const uniqueArr = Array.from(new Set(arr));

2. 使用indexOf方法：遍历数组，将元素依次与之前的元素进行比较，如果不存在相同的元素，则将其添加到结果数组中。例如：

   const arr = [1, 2, 2, 3, 4, 4];
   const uniqueArr = [];
   for(let i = 0; i < arr.length; i++){
       if(uniqueArr.indexOf(arr[i]) === -1){
           uniqueArr.push(arr[i]);
       }
   }

3. 使用includes方法：与indexOf方法类似，includes方法也可以判断数组是否包含某个元素。例如：

   const arr = [1, 2, 2, 3, 4, 4];
   const uniqueArr = [];
   for(let i = 0; i < arr.length; i++){
       if(!uniqueArr.includes(arr[i])){
           uniqueArr.push(arr[i]);
       }
   }

4. 使用filter方法：利用filter方法筛选出只包含第一次出现的元素的新数组。例如：

   const arr = [1, 2, 2, 3, 4, 4];
   const uniqueArr = arr.filter((item, index) => {
       return arr.indexOf(item) === index;
   });

5. 使用reduce方法：通过reduce方法遍历数组，将之前未出现的元素添加到结果数组中。例如：

   const arr = [1, 2, 2, 3, 4, 4];
   const uniqueArr = arr.reduce((prev, cur) => {
       if(!prev.includes(cur)){
           prev.push(cur);
       }
       return prev;
   }, []);

6. 使用Map：通过使用Map数据结构来存储数组元素，由于Map中的键是唯一的，可以实现数组去重。例如：

   const arr = [1, 2, 2, 3, 4, 4];
   const map = new Map();
   const uniqueArr = [];
   for (const item of arr) {
       if (!map.has(item)) {
           map.set(item, true);
           uniqueArr.push(item);
       }
   }

以上是常见的六种JS数组去重方法，通过灵活运用，可以根据实际情况选择最适合的方法。<span class="em">1</span><span class="em">2</span><span class="em">3</span>
#### 引用[.reference_title]
- *1* [高性能js数组去重(12种方法，史上最全)](https://download.csdn.net/download/weixin_38665814/12930200)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"]
- *2* [JS实现数组去重方法总结(六种方法)](https://download.csdn.net/download/weixin_38661008/12967052)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"]
- *3* [Html+Css+JS的生日网页](https://download.csdn.net/download/Amax3747/88254112)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"]
[ .reference_list ]

JavaScript 数组去重

### 回答1：
要在 JavaScript 中去除数组中的重复项，可以使用下列方法之一：

1. 使用 Set 对象：Set 对象具有去除数组中重复项的功能，可以这样使用：

let array = [1, 2, 3, 3, 4, 4, 5];
let uniqueArray = [...new Set(array)];
console.log(uniqueArray); // [1, 2, 3, 4, 5]

2. 使用 Array.prototype.filter() 和 indexOf()：

let array = [1, 2, 3, 3, 4, 4, 5];
let uniqueArray = array.filter(function(item, index) {
  return array.indexOf(item) === index;
});
console.log(uniqueArray); // [1, 2, 3, 4, 5]

3. 使用 Array.prototype.reduce()：

let array = [1, 2, 3, 3, 4, 4, 5];
let uniqueArray = array.reduce(function(accumulator, currentValue) {
  if (accumulator.indexOf(currentValue) === -1) {
    accumulator.push(currentValue);
  }
  return accumulator;
}, []);
console.log(uniqueArray); // [1, 2, 3, 4, 5]

注意，上述方法仅适用于去除数字数组中的重复项。如果数组包含对象，则需要使用其他方法来处理。

希望这些信息对你有帮助！

### 回答2：
JavaScript 中实现数组去重可以使用多种方法，下面我会介绍两种常用的方法。

方法一：使用 Set
Set 是 ES6 中新增的数据结构，它类似于数组，但是成员的值都是唯一的。所以我们可以利用 Set 的特性来快速去除数组重复元素。

let arr = [1, 2, 2, 3, 4, 4, 5];
let uniqueArr = [...new Set(arr)];

console.log(uniqueArr); // [1, 2, 3, 4, 5]

方法二：使用 filter
我们可以利用数组的 filter 方法，通过判断元素第一次出现的索引是否和当前索引相等来实现数组去重。

let arr = [1, 2, 2, 3, 4, 4, 5];
let uniqueArr = arr.filter((item, index) => {
  return arr.indexOf(item) === index;
});

console.log(uniqueArr); // [1, 2, 3, 4, 5]

以上是两种常用的 JavaScript 数组去重方法，根据具体场景使用不同的方法可以提高性能和代码可读性。

### 回答3：
JavaScript 数组去重可以使用多种方法。以下是几种常见的方法：

1. 使用 Set 数据结构: 可以利用 Set 数据结构的特性来实现数组去重。Set 是一种数据结构，它只允许存储不重复的值。我们可以将数组转换为 Set，然后再将 Set 转回为数组即可实现去重。

let arr = [1, 2, 2, 3, 4, 4, 5];
let uniqueArr = Array.from(new Set(arr));
console.log(uniqueArr); // [1, 2, 3, 4, 5]

2. 使用 Array.prototype.filter() 方法：使用 `filter()` 方法可以遍历数组，并返回满足条件的新数组。我们可以利用 `indexOf()` 方法来判断元素第一次出现的位置与当前索引位置是否相同，如果相同则保留，否则过滤掉。

let arr = [1, 2, 2, 3, 4, 4, 5];
let uniqueArr = arr.filter((item, index) => arr.indexOf(item) === index);
console.log(uniqueArr); // [1, 2, 3, 4, 5]

3. 使用对象键值对：利用对象的键值对是唯一的特性来实现数组去重。遍历数组，将元素作为对象的键，将出现的次数作为键的值保存在对象中。最后，提取对象中的键即可得到去重后的数组。

let arr = [1, 2, 2, 3, 4, 4, 5];
let obj = {};
arr.forEach(item => obj[item] = true);
let uniqueArr = Object.keys(obj).map(Number);
console.log(uniqueArr); // [1, 2, 3, 4, 5]

以上是几种常见的 JavaScript 数组去重方法，根据实际需求选择适合的方法即可。