双重循环

使用循环嵌套，如果值相等，就删去这个值。

  1. let array = [1,5,2,3,4,2,3,1,3,4]
  3. function unique(array) {
  4.   for (let i = 0; i < array.length; i++) {
  5.     for (let j = i + 1; j < array.length; j++) {
  6.       if (array[i] === array[j]) {
  7.         array.splice(j, 1)
  8.         j--
  9.       }
  10.     }
  11.   }
  12.   return array
  13. }
  14. console.log(unique(array))
  • 优点：兼容性好。
  • 缺点：对象不可以去重，因为对象不可以用来比较；NaN不可以去重；时间复杂度o(n2)。

indexOf

新建一个新数组res，遍历传入数组，值不在新数组就push进该新数组中

  1. let array = [1,5,2,3,4,2,3,1,3,4]
  3. function unique(array) {
  4.   let res = [];
  5.   for (let i = 0; i < array.length; i++) {
  6.     var current = array[i];
  7.     if (res.indexOf(current) === -1) {
  8.       res.push(current)
  9.     }
  10.   }
  11.   return res;
  12. }
  14. console.log(unique(array));
  • 优点：可以区分’1’和1。
  • 缺点：对象不可以去重，因为对象不可以用来比较；NaN不可以去重；时间复杂度o(n2)。

Set

Set对象是值的集合，你可以按照插入的顺序迭代它的元素。 Set中的元素只会出现一次，即 Set 中的元素是唯一的。
因为Set中的元素是唯一的所以，可以用于数组去重。

  1. let array = [1,5,2,3,4,2,3,1,3,4]
  2. function unique(arr){
  3.   return Array.from(new Set(arr))
  4. }
  5. console.log(unique(array))
  • 优点：简单高效时间复杂度到O(n)，可用于NaN去重。
  • 缺点：对象不可被去重；可能有兼容性问题。

Map

使用map的方法set和has，用has方法来判断是否存在这个key，如果没有值将map中存一个key-value。

  1. let array = [1,5,2,3,4,2,3,1,3,4]
  3. function unique(arr) {
  4.   let current = new Map()
  5.   let res = arr.filter(function(item, index, arr) {
  6.     if (current.has(item)) {
  7.       return false
  8.     } else {
  9.       return current.set(item, 1)
  10.     }
  11.   })
  12.   return res
  13. }
  15. console.log(unique(array))
  • 优点：简单高效，时间复杂度到O(n)。
  • 缺点：可能有兼容性问题