JS数组去重方法

一.操作原数组

1.双层循环 + splice去除 ，如果相等，arr.splice(j,1)

双层循环结合 splice 的方式可以用来去除数组中的重复元素。在这种方法中，外层循环用于遍历数组，内层循环用于比较当前元素与后续元素是否相等，如果相等，则使用 splice 方法移除重复的元素。

function removeDuplicates(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j]) {
        arr.splice(j, 1);
        j--; // 减少 j 的值，以便下一次继续比较同位置的元素
      }
    }
  }
  return arr;
}

const originalArray = [1, 2, 3, 4, 2, 5, 6, 1];
const uniqueArray = removeDuplicates(originalArray);

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

 这种方法虽然可以去除数组中的重复元素，但它的时间复杂度相对较高，为 O(n^2)，因为每次 splice 操作都会导致数组的重新排列。在大型数组中使用时可能性能较差，尤其是当数组长度较大时。

二.返回新数组

1.循环 + indexOf() 判断元素是否在数组中，是则返回位置，没有则是-1  

使用循环结合 indexOf() 来判断元素是否在数组中，如果在则返回位置，否则返回-1，是一种简单的方式来检查数组中是否有重复元素。这种方法的时间复杂度为 O(n^2)。

function removeDuplicates(arr) {
  for (let i = 0; i < arr.length; i++) {
    const index = arr.indexOf(arr[i], i + 1); // 从当前元素的下一个位置开始查找
    if (index !== -1) {
      arr.splice(index, 1);
      i--; // 减少 i 的值，以便下一次继续比较同位置的元素
    }
  }
  return arr;
}

const originalArray = [1, 2, 3, 4, 2, 5, 6, 1];
const uniqueArray = removeDuplicates(originalArray);

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

这种方法的缺点也是相对较高的时间复杂度，因为每次调用 indexOf() 都需要遍历数组来查找元素的位置。对于大型数组，性能可能会受到影响。 

2.循环 + arr.sort() 方法，sort相近似的元素排序，循环时判断当前元素和上一位元素是否相同

使用循环结合 arr.sort() 方法，通过排序相近似的元素，然后在循环中判断当前元素和上一位元素是否相同，是一种数组去重的方法。这种方法的思路是通过排序将相同的元素相邻，然后在循环中检查相邻元素是否相同，从而去除重复元素。

function removeDuplicates(arr) {
  arr.sort(); // 对数组进行排序
  for (let i = 1; i < arr.length; i++) {
    if (arr[i] === arr[i - 1]) {
      arr.splice(i, 1);
      i--; // 减少 i 的值，以便下一次继续比较同位置的元素
    }
  }
  return arr;
}

const originalArray = [1, 2, 3, 4, 2, 5, 6, 1];
const uniqueArray = removeDuplicates(originalArray);

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

 这种方法的时间复杂度取决于 arr.sort() 的实现，通常为 O(n log n)，再加上一次循环，总体效率较高。但请注意，这种方法改变了原数组的顺序，如果要保持原数组的顺序，可以在排序前创建数组的副本。

3.循环 + includes（）  arr.includes(item) 返回 true/false

使用循环结合 includes() 方法，通过判断数组中是否包含某个元素，然后在循环中判断当前元素是否在之前的元素中出现过，是一种数组去重的方法。

function removeDuplicates(arr) {
  const uniqueArray = [];
  for (let i = 0; i < arr.length; i++) {
    if (!uniqueArray.includes(arr[i])) {
      uniqueArray.push(arr[i]);
    }
  }
  return uniqueArray;
}

const originalArray = [1, 2, 3, 4, 2, 5, 6, 1];
const uniqueArray = removeDuplicates(originalArray);

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

这种方法通过 includes() 来判断当前元素是否已经存在于结果数组中，如果不存在则添加到结果数组中。这样可以保证结果数组中的元素是唯一的。

然而，需要注意的是 includes() 方法的时间复杂度为 O(n)，因此总体的时间复杂度为 O(n^2)，在大型数组上性能可能较差。

4.ES6 的Set方法，let arr = new Set(oldArr) ，set方法成员都是唯一的，可以去重

使用ES6中的Set数据结构，Set只允许存储唯一的值，因此可以通过Set实现数组去重。

const uniqueArray = [...new Set(originalArray)];

 

5.循环+ES6的Map, 判断map里是否有当前键值，没有则添加并设置false，否则修改为true

function removeDuplicates(arr) {
  const map = new Map();
  const uniqueArray = [];

  for (let i = 0; i < arr.length; i++) {
    if (!map.has(arr[i])) {
      map.set(arr[i], false); // 不存在，添加到 Map，并设置为 false
      uniqueArray.push(arr[i]);
    } else {
      map.set(arr[i], true); // 存在，设置为 true
    }
  }

  return uniqueArray.filter(item => !map.get(item));
}

const originalArray = [1, 2, 3, 4, 2, 5, 6, 1];
const uniqueArray = removeDuplicates(originalArray);

console.log(uniqueArray); // [ 3, 4, 5, 6]