数组去重

一 双层循环匹配

1. 选择排序

1. 思想： 将标志位的每一项与后面的项进行对比，一致则删除，j--。

function avoidRepeat(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      let flag = arr[i];
      let temp = arr[j];
      if (temp === flag) {
        arr.splice(j, 1);
        j--;
      }
    }
  }
  return arr
}

二 新建数组，保持数组数据的唯一性。

主要技术方法：

1. indexOf || includes || find || findIndex || some || filter(判断数组length) 判断数组值是否重复
2. push

1 判断数组中是否存在唯一的项。

1. 思想：indexof判断是否在数组中存在，不存在则push。

function avoidRepeat2(arr) {
  let newArr = [];
  for (let j = 0; j < arr.length; j++) {
    let temp = arr[j];
    let notExigst = newArr.indexOf(temp) === -1;
    if (notExigst) {
      newArr.push(temp);
    }
  }
  return newArr
}

2 reduce 实现循环

1. 思想：归并思想。

function avoidRepeat4(arr) {
  return arr.reduce((pre, next) => pre.includes(next) ? pre : pre.concat(next), [])
}

3 利用对象key的不可重复性

function avoidRepeat5(arr) {
  return Object.keys(arr.reduce((pre, next) => {
    pre[next] = true;
    return pre
  }, {}))
}

4 对排序之后的数组进行前后值的对比。

1. 思想
   1. 将数组进行排序，遍历数组，将当前项和下一项进行对比，一样则将下一项删除掉。最后return数组。

function avoidRepeat7(arr) {
  let sortArr = arr.sort((a, b) => b - a);
  for (let i = 0; i < sortArr.length; i++) {
    let cur = sortArr[i];
    let next = sortArr[i + 1];
    if (cur === next) {
      sortArr.splice(i + 1, 1);
      i--;
    }
  }
  return sortArr
}

三 利用下标进行判断

主要思想

1. 遍历数组，将当前子项的下标和其第一次出现时的下标进行对比。
   1. 如果一致，则是第一次出现。返回该项
   2. 如果不一致，证明前面已经存在该项，该项是重复的值。
      主要技术
2. filter indexOf || findIndex
3. for indexOf || findIndex push

1 filter + indexOf

function avoidRepeat3(arr) {
  return arr.filter((ele, index) => index === arr.indexOf(ele))
}

四 es6 新增api Set

function avoidRepeat6(arr) {
  return [...new Set(arr)]
}