超全的12种数组去重方法，我亲测有效！

作为一名前端开发者，我在日常工作中经常遇到需要对数组进行去重的操作。最近在简书上看到一篇关于数组去重的热搜文章，让我深受启发。今天就和大家分享一下我总结的超全12种数组去重方法。

首先，我们来了解一下最基础的几种方法：

Set 是 ES6 中引入的一种数据结构，其特点就是集合中的元素不会重复。通过将数组转化为 Set，然后再转回数组，就可以轻松实现去重。

const arr = [1, 2, 2, 3, 4, 4];
const uniqueArr = [...new Set(arr)];
console.log(uniqueArr); // 输出 [1, 2, 3, 4]

我们可以利用 indexOf 方法来判断某个元素是否已经存在于结果数组中。如果不存在，则将其加入结果数组。

function removeDuplicates(arr) {
  const result = [];
  for (let i = 0; i < arr.length; i++) {
    if (result.indexOf(arr[i]) === -1) {
      result.push(arr[i]);
    }
  }
  return result;
}
const arr = [1, 2, 2, 3, 4, 4];
console.log(removeDuplicates(arr)); // 输出 [1, 2, 3, 4]

includes 方法可以用来判断一个元素是否已经存在于数组中，与 indexOf 类似，但语法更简洁。

function removeDuplicates(arr) {
  const result = [];
  for (let item of arr) {
    if (!result.includes(item)) {
      result.push(item);
    }
  }
  return result;
}
const arr = [1, 2, 2, 3, 4, 4];
console.log(removeDuplicates(arr)); // 输出 [1, 2, 3, 4]

filter 方法可以结合 indexOf 来实现去重，逻辑简单明了。

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

reduce 方法也可以用来实现数组去重，代码稍显复杂，但功能强大。

const arr = [1, 2, 2, 3, 4, 4];
const uniqueArr = arr.reduce((acc, cur) => acc.includes(cur) ? acc : [...acc, cur], []);
console.log(uniqueArr); // 输出 [1, 2, 3, 4]

除了以上这些常见方法，还有其他一些高级技巧：

Map 可以用来记录已经出现过的元素，从而实现去重。

function removeDuplicates(arr) {
  const map = new Map();
  const result = [];
  for (let item of arr) {
    if (!map.has(item)) {
      map.set(item, true);
      result.push(item);
    }
  }
  return result;
}
const arr = [1, 2, 2, 3, 4, 4];
console.log(removeDuplicates(arr)); // 输出 [1, 2, 3, 4]

这种方法虽然效率较低，但在某些场景下仍然适用。

function removeDuplicates(arr) {
  const result = [];
  for (let i = 0; i < arr.length; i++) {
    let isUnique = true;
    for (let j = 0; j < result.length; j++) {
      if (arr[i] === result[j]) {
        isUnique = false;
        break;
      }
    }
    if (isUnique) {
      result.push(arr[i]);
    }
  }
  return result;
}
const arr = [1, 2, 2, 3, 4, 4];
console.log(removeDuplicates(arr)); // 输出 [1, 2, 3, 4]

some 方法可以用来检查数组中是否有重复元素。

function removeDuplicates(arr) {
  const result = [];
  for (let item of arr) {
    if (!result.some(el => el === item)) {
      result.push(item);
    }
  }
  return result;
}
const arr = [1, 2, 2, 3, 4, 4];
console.log(removeDuplicates(arr)); // 输出 [1, 2, 3, 4]

find 方法可以用来查找数组中是否存在重复元素。

function removeDuplicates(arr) {
  const result = [];
  for (let item of arr) {
    if (!result.find(el => el === item)) {
      result.push(item);
    }
  }
  return result;
}
const arr = [1, 2, 2, 3, 4, 4];
console.log(removeDuplicates(arr)); // 输出 [1, 2, 3, 4]

every 方法可以用来确保数组中每个元素都唯一。

function removeDuplicates(arr) {
  const result = [];
  for (let item of arr) {
    if (result.every(el => el !== item)) {
      result.push(item);
    }
  }
  return result;
}
const arr = [1, 2, 2, 3, 4, 4];
console.log(removeDuplicates(arr)); // 输出 [1, 2, 3, 4]

使用对象作为哈希表来存储已经出现过的元素。

function removeDuplicates(arr) {
  const hash = {};
  const result = [];
  for (let item of arr) {
    if (!hash[item]) {
      hash[item] = true;
      result.push(item);
    }
  }
  return result;
}
const arr = [1, 2, 2, 3, 4, 4];
console.log(removeDuplicates(arr)); // 输出 [1, 2, 3, 4]

如果你的项目中已经引入了 lodash 库，可以直接使用 _.uniq 方法。

const _ = require('lodash');
const arr = [1, 2, 2, 3, 4, 4];
const uniqueArr = _.uniq(arr);
console.log(uniqueArr); // 输出 [1, 2, 3, 4]

以上就是我总结的12种数组去重方法，每种方法都有其适用场景，大家可以根据实际需求选择最适合自己的方式。