数组去重

0. 由对象组成的数组去重

var o = {};

[{name: '33'}, {name: '55'}].forEach(item => {
    o[item.name] = item;
})

Object.values(o)

1. 去重：遍历数组法

var arr = [2, 8, 5, 0, 5, 2, 6, 7, 2]
var newArr = []
for (var i = 0; i < arr.length; i++) {
    if (newArr.indexOf(arr[i]) === -1) {
           newArr.push(arr[i])
     }
}
console.log(newArr) // 结果：[2, 8, 5, 0, 6, 7]

2. 去重：数组下标判断法

var arr = [2, 8, 5, 0, 5, 2, 6, 7, 2]
var newArr = []
for (var i = 0; i < arr.length; i++) {
     if (arr.indexOf(arr[i]) === i) {
       newArr.push(arr[i])
     }
}
console.log(newArr) // 结果：[2, 8, 5, 0, 6, 7]
看 if 这里，在遍历 arr 的过程中，如果在 arr 数组里面找当前的值，返回的索引等于当前的循环里
面的 i 的话，那么证明这个值是第一次出现，所以推入到新数组里面，如果后面又遍历到了一个出现过
的值，那也不会返回它的索引，indexof() 方法只返回找到的第一个值的索引，所以重复的都会被
pass 掉，只出现一次的值都被存入新数组中，也达到了去重的目的。

3. 去重：排序后相邻去除法

这种方法用到了sort()方法，代码如下：
 var arr = [2, 8, 5, 0, 5, 2, 6, 7, 2]
 arr.sort()
 var newArr = [arr[0]]
 for (var i = 1; i < arr.length; i++) {
    if (arr[i] !== newArr[newArr.length - 1]) {
       newArr.push(arr[i])
    }
 }
console.log(newArr) // 结果：[0, 2, 5, 6, 7, 8]

这种方法的思路是：
先用 sort() 方法把arr排序，那么排完序后，相同的一定是挨在一起的，
把它去掉就好了，首先给新数组初始化一个 arr[0]，因为我们要用它和arr数组进行比较，
所以，for 循环里面i也是从1开始了，我们让遍历到的arr中的值和新数组最后一位进行比较，如果相等，
则 pass 掉，不相等的，push 进来，因为数组重新排序了，重复的都挨在一起，那么这就保证了重复
的这几个值只有第一个会被 push 进来，其余的都和新数组的被 push 进来的这个元素相等，会被 
pass 掉，也达到了去重的效果。

4. 去重：利用ES6 Set去重

Set 数据结构，它类似于数组，其成员的值都是唯一的。
利用 Array.from 将 Set 结构转换成数组

function unique (arr) {
  return Array.from(new Set(arr))
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))
 //[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {}, {}]


let c = [...(new Set([1,1,2,2,3,3,4,4,5]))];  // [1,2,3,4,5]

5. 去重：优化的遍历数组法

var arr = [2, 8, 5, 0, 5, 2, 6, 7, 2, 8]
var newArr = []
for (var i = 0; i < arr.length; i++) {
      for (var j = i + 1; j < arr.length; j++) {
        if (arr[i] === arr[j]) {
          i++
          j = i
        }
      }
     newArr.push(arr[i])
   }
console.log(newArr) // 结果：[0, 5, 6, 7, 2, 8]

思路：
两层for循环，外面一层是控制遍历到的前一个arr中的元素，里面一层控制的是第一层访问到
的元素后面的元素，不断的从第0个开始，让第0个和他后面的元素比较，如果没有和这个元素相等的，
则证明没有重复，推入到新数组中存储起来，如果有和这个元素相等的，则pass掉它，直接进入下一次
循环。从第1个开始，继续和它后面的元素进行比较，同上进行，一直循环到最后就是：不重复的
都被推入新数组里面了，而重复的前面的元素被pass掉了，只留下了最后面的一个元素，这个时候也就
不重复了，则推入新数组，过滤掉了所有重复的元素，达到了去重的目的。

6. 去重：数组遍历法

var arr = ['a', 'a', 'b', 'c', 'b', 'd', 'e', 'a']
var newArr = []
for (var i = 0; i < arr.length; i++) {
      var bl = true
      for (var j = 0; j < newArr.length; j++) {
        if (arr[i] === newArr[j]) {
          bl = false
          break
        }
     }
     if (bl) {
       newArr.push(arr[i])
     }
}
console.log(newArr) // 结果：["a", "b", "c", "d", "e"]

思路：
也是两层 for 循环，外层 for 循环控制的是 `arr` 数组的遍历，内层 for 循环控制的是新数组的
遍历，从第 0 位开始，如果新数组中没有这个 `arr` 数组中遍历到的这个元素，那么状态变量 `bl` 
的值还是 `true`，那么自然进入到了 if 中把这个值推入到新数组中，如果有这个元素，那么代表重复，
则把状态变量 `bl` 取值改为`false`，并且跳出当前循环，不会进入到 if 内部，而进入下一次
外层开始的循环。这样循环往复，最后也达到了去重的效果。