数组去重方法

Set方法+includes，不改变原数组。

    let arr = [9, 9, 18, 18, 5, 23, 15, 21, 13, 7, 4, 20]
    function func (arr) {
        return Array.from(new Set(arr))
      }
      const arr1 = func(arr)
      console.log(arr1) 
      //[1, true, false, null, 'af', undefined, {…}, {…}, Array(0), Array(0), NaN]
      //问题：对于对象和数组不能去重
      //原因：因为js是判断对象和数组的地址是否相同，而不是其内容，所以两个空对象（两个空数组）是不相等的。

Set方法 + 展开运算符，不改变原数组。

let arr = [1,1,true,true,false,false,null,null,'af','af',undefined,undefined,{},{},[],[],NaN,NaN]
function func (arr) {
        return [...new Set(arr)]
      }
      const arr1 = func(arr)
      console.log(arr1)
      //[1, true, false, null, 'af', undefined, {…}, {…}, Array(0), Array(0), NaN]
      //问题：对于对象和数组不能去重
      //原因：因为js是判断对象和数组的地址是否相同，而不是其内容，所以两个空对象（两个空数组）是不相等的。

双层for循环，不改变原数组。

  let arr = [1,1,true,true,false,false,null,null,'af','af',undefined,undefined,{},{},[],[],NaN,NaN]
      let newArr = []
      for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length; j++) {
          if (!newArr.includes(arr[i])) {
            newArr.push(arr[i])
          }
        }
      }
      console.log(newArr) 
      // [1, true, false, null, 'af', undefined, {…}, {…}, Array(0), Array(0), NaN]
      //问题：对于对象和数组不能去重
      //原因：因为js是判断对象和数组的地址是否相同，而不是其内容，所以两个空对象（两个空数组）是不相等的。

双层for循环，利用splice，改变了原数组。

  let arr = [1,1,true,true,false,false,null,null,'af','af',undefined,undefined,{},{},[],[],NaN,NaN]
   function unique (arr) {
        for (let i = 0; i < arr.length; i++) {
          // 用j=i+1，第一个和其后者比较过后，后者就不用再和前者比较，减少比较次数。
          for (let j = i + 1; j < arr.length; j++) {
          // j=i+1,是因为，我需要下标为i的元素 和其后面的算有元素进行比较，若有相等的就用 splice 删除掉。
            if (arr[i] === arr[j]) {
              arr.splice(j, 1)
              j--
            }
          }
        }
        return arr
      }
      console.log(unique(arr))
      //[1, true, false, null, 'af', undefined, {…}, {…}, Array(0), Array(0), NaN, NaN]
      //问题：对于对象、数组和NaN不能去重
      //原因：因为js是判断对象和数组的地址是否相同，而不是其内容，所以两个空对象（两个空数组）是不相等的。而NaN用===或者==来判断相等，一直是false。

forEach+ includes，不改变原数组。

  let arr = [1,1,true,true,false,false,null,null,'af','af',undefined,undefined,{},{},[],[],NaN,NaN]
function unique(arr) {
            var newArr = []
            arr.forEach(item => {
                return newArr.includes(item) ? '' : newArr.push(item)
            });
            return newArr
        }
        console.log(unique(arr));
     //[1, true, false, null, 'af', undefined, {…}, {…}, Array(0), Array(0), NaN, NaN]
        //与includes去重原理一致

hasOwnProperty+filter (所有的都可去重)，改变原数组。

let arr = [1,1,true,true,false,false,null,null,'af','af',undefined,undefined,{},{},[],[],NaN,NaN]
function unique(arr) {
            var obj = {};
            return arr.filter(function (item, index, arr) {
                return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
            })
        }
        console.log(unique(arr));
       //[1, true, false, null, 'af', undefined, {…}, Array(0), NaN]
        //所有的都去重了

递归，不改变原数组。

let arr = [1,1,true,true,false,false,null,null,'af','af',undefined,undefined,{},{},[],[],NaN,NaN]
  function unique (arr) {
        let array = arr
        let len = array.length
        let arr1 = []
        array.sort(function (a, b) {
          //排序后更加方便去重
          return a - b
        })
        console.log(array)
        function loop (index) {
         // 递归终止的条件
          if (index <= len - 1) {
            if (!arr1.includes(array[index])) {
              arr1.push(array[index])
            }
            loop(index + 1) //递归loop，然后数组去重
          }
        }
        loop(0)
        return arr1
      }
      console.log(unique(arr))
      //[false, null, Array(0), Array(0), 1, true, 'af', {…}, {…}, NaN, undefined]
      //问题：对于对象和数组不能去重
      //原因：因为js是判断对象和数组的地址是否相同，而不是其内容，所以两个空对象（两个空数组）是不相等的。