js数组去重的方法

1双层for循环遍历数组

let arr = [1, 2, 3, 4, 3, 2, 3, 4, 6, 7, 6]
// 双层for循环遍历数组
function f (arr) {
  for (var i = 0; i < arr.length; i++) {
    for (var j = i + 1; j < arr.length; j++) {
      if (arr[i] == arr[j]) {
        arr.splice(j, 1)
        j--
      }
    }
  }
  return arr
}
let newArr = f(arr)
console.log(newArr)

其余的双层for循环都大同小异

2利用forEach和indexOf

let arr = [1, 2, 3, 4, 3, 2, 3, 4, 6, 7, 6]
// 用indexOf 去重
function f (arr) {
  let newArr = []
  arr.forEach(item => {
    if (newArr.indexOf(item) === -1){
      newArr.push(item)
    }
  })
  return newArr
}
let newArr = f(arr)
console.log(newArr)

这个方法的判断条件也可以换成其他的api 都是大同小异
判断条件可以用 includes() ，indexOf()，lastIndexOf() ， find() ，findIndex()，some() ， every()

3用sort排序以后 相邻计较 去重

let arr = [1, 2, 3, 4, 3, 2, 3, 4, 6, 7, 6]
// 用sort排序以后 相邻计较 去重
function f (arr) {
  arr = arr.sort()
  var arrry = []
  arr.forEach((item, i) => {
    arr[i] !== arr[i - 1] ? arrry.push(arr[i]) : ''
  });
  return arrry;
}
let newArr = f(arr)
console.log(newArr)

4 利用对象属性不能重复

let arr = [1, 2, 3, 4, 3, 2, 3, 4, 6, 7, 6]
// 对象属性不能重复
function f (arr) {
  let arrry = []
  let obj = {}
  for (var i = 0; i < arr.length; i++) {
    if (!obj[arr[i]]) {
      arrry.push(arr[i])
      obj[arr[i]] = 1
    } else {
      obj[arr[i]]++
    }
  }
  return arrry;
}
let newArr = f(arr)
console.log(newArr)

5 reduce去重

let arr = [1, 2, 3, 4, 3, 2, 3, 4, 6, 7, 6]
// reduce
function f (arr) {
  return arr.reduce((t, v) => t.includes(v) ? t : [...t, v], []);
}
let newArr = f(arr)
console.log(newArr)

嗯 reduce还是内个牛逼的reduce
这个方法的判断条件和 第2个 一样 作为判断条件的api很多

6.hasOwnProperty(回头研究)

let arr = [1, 2, 3, 4, 3, 2, 3, 4, 6, 7, 6]
// 
function f (arr) {
  var obj = {}
  return arr.filter(function (item, index, arr) {
    return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
  })
}
let newArr = f(arr)
console.log(newArr)

这玩意我没研究懂 等回头补吧
就是这玩意好几把炫酷 一副看不懂的样子
这玩意好像还很牛逼 可以去重相同类型比如 null undefined NaN

7递归去重

let arr = [1, 2, 3, 4, 3, 2, 3, 4, 6, 7, 6]
// 递归去重
function f (arr) {
  let len = arr.length
  arr.sort()
  console.log(arr)
  function loop (index) {
    if (index >= 1) {
      if (arr[index] === arr[index - 1]) {
        arr.splice(index, 1)
      }
      loop(index - 1)    //递归loop，然后数组去重
    }
  }
  loop(len - 1)
  return arr;
}
let newArr = f(arr)
console.log(newArr)

8 map数据结构去重

let arr = [1, 2, 3, 4, 3, 2, 3, 4, 6, 7, 6]

// 递归去重
function f (arr) {
  let map = new Map()
  let array = new Array()  // 数组用于返回结果
  for (let i = 0; i < arr.length; i++) {
    if (map.has(arr[i])) {  // 如果有该key值
      map.set(arr[i], true)
    } else {
      map.set(arr[i], false)   // 如果没有该key值
      array.push(arr[i])
    }
  }
  return array; 
}
let newArr = f(arr)
console.log(newArr)

9 最后来个牛逼的

let arr = [1, 2, 3, 4, 3, 2, 3, 4, 6, 7, 6]
let newArr = [...new Set(arr)]
console.log(newArr)

** 这他**** 牛*
诶 自己研究吧 MDN