数组去重终极指南：让你一次性搞定各种去重需求！

前端

2023-05-11 20:37:48

数组去重终极指南：轻松掌握各种场景下的去重方案

在日常开发和面试中，数组去重是一个常见的需求。本文将深入探讨数组去重的各种方案，涵盖从基本数组到引用数组、有序数组到无序数组的全面场景。掌握这些方案，让你在各种情况下游刃有余！

分类：了解不同的数组类型

在进行去重之前，我们先来了解一下不同类型的数组：

基本数组： 包含基本数据类型的元素，如数字、字符串等。
引用数组： 包含引用类型的元素，如对象、数组等。
有序数组： 元素按某种顺序排列，如升序或降序。
无序数组： 元素没有特定顺序。

方案：轻松解决各种去重需求

现在，让我们来看看几个常用的数组去重方案：

1. 使用Set对象

Set对象是一种数据结构，它只允许唯一元素存在。我们可以将数组元素放入Set中，然后再将其转换为数组，就可以实现去重。

const numbers = [1, 2, 3, 4, 5, 1, 2, 3];
const uniqueNumbers = [...new Set(numbers)];
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

2. 使用indexOf()和filter()方法

indexOf()方法可以返回某个元素在数组中的第一个索引。我们可以使用它来过滤掉重复的元素。

const numbers = [1, 2, 3, 4, 5, 1, 2, 3];
const uniqueNumbers = numbers.filter((item, index) => numbers.indexOf(item) === index);
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

3. 使用includes()方法

includes()方法可以判断某个元素是否在数组中。我们可以使用它来逐一检查元素，并只保留不重复的元素。

const numbers = [1, 2, 3, 4, 5, 1, 2, 3];
const uniqueNumbers = [];
for (const number of numbers) {
  if (!uniqueNumbers.includes(number)) {
    uniqueNumbers.push(number);
  }
}
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

4. 使用reduce()方法

reduce()方法可以将数组中的元素逐个处理，最终得到一个累积的结果。我们可以使用它来创建一个新的数组，只包含不重复的元素。

const numbers = [1, 2, 3, 4, 5, 1, 2, 3];
const uniqueNumbers = numbers.reduce((acc, item) => {
  if (!acc.includes(item)) {
    acc.push(item);
  }
  return acc;
}, []);
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

总结：各显神通，对症下药

不同的去重方案适用于不同的数组类型和场景。下面是一个简单的总结：

基本数组和无序数组： Set对象、indexOf()和filter()方法、includes()方法和reduce()方法都适用。
引用数组： Set对象不适用，因为引用类型元素在Set中可能会被视为相同元素。
有序数组： indexOf()和filter()方法、includes()方法和reduce()方法都适用于从小到大排列的数组。但如果数组是从大到小排列的，则indexOf()和filter()方法可能效率较低。

常见问题解答

1. 如何去重一个引用数组？

对于引用数组，我们可以使用Map对象，其键值对的形式为：元素本身作为键，任意值作为值。去重后，Map对象的键就是唯一元素。

const objects = [{id: 1}, {id: 2}, {id: 3}, {id: 1}, {id: 2}];
const uniqueObjects = [...new Map(objects.map(obj => [obj, obj])).values()];
console.log(uniqueObjects); // [{id: 1}, {id: 2}, {id: 3}]

2. 如何去重一个从大到小排列的数组？

对于从大到小排列的数组，我们可以先将其排序从小到大，然后再使用indexOf()和filter()方法、includes()方法或reduce()方法去重。

const numbers = [5, 4, 3, 2, 1, 5, 4, 3];
numbers.sort((a, b) => a - b);
const uniqueNumbers = numbers.filter((item, index) => numbers.indexOf(item) === index);
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

3. 如何同时去除数组中的重复元素和空元素？

我们可以使用filter()方法和includes()方法相结合，来同时去除重复元素和空元素。

const numbers = [1, 2, 3, 4, 5, null, 1, 2, 3, ''];
const uniqueNonEmptyNumbers = numbers.filter(item => !numbers.includes(item) && item !== null && item !== '');
console.log(uniqueNonEmptyNumbers); // [1, 2, 3, 4, 5]

4. 如何去重一个多维数组？

对于多维数组，我们可以使用递归的方法。将多维数组转换为一维数组，然后使用上述方法去重。

const multidimensionalArray = [[1, 2, 3], [4, 5, 6], [1, 2, 3], [7, 8, 9]];
const uniqueElements = [];
const flattenArray = (array) => {
  for (const element of array) {
    if (Array.isArray(element)) {
      flattenArray(element);
    } else {
      if (!uniqueElements.includes(element)) {
        uniqueElements.push(element);
      }
    }
  }
};
flattenArray(multidimensionalArray);
console.log(uniqueElements); // [1, 2, 3, 4, 5, 6, 7, 8, 9]

5. 如何去重一个大数组？

对于大数组，我们可以考虑使用分治法。将数组分成较小的部分，分别去重，然后合并结果。

const largeArray = new Array(100000).fill(1);
const numChunks = 4;
const chunkSize = largeArray.length / numChunks;
const chunks = [];
for (let i = 0; i < numChunks; i++) {
  chunks.push(largeArray.slice(i * chunkSize, (i + 1) * chunkSize));
}
const uniqueElements = [];
for (const chunk of chunks) {
  const set = new Set(chunk);
  uniqueElements.push(...set);
}
console.log(uniqueElements.length); // 1