//去重该数组，检测多种类型
var arr = [1, 1, 'a', 'a', true, true, 'true', 'true', NaN, NaN, undefined, undefined, null, null, {}, {}]

1.使用array.indexOf()做一个判断，遍历数组，如果没有相同元素则返回-1，将符合条件的元素添加到新数组中并返回(缺点：无法检测NaN和{})

function removeDuplivate(arr) {
  let newArr = []  
  arr.forEach(item => {
    if (newArr.indexOf(item) === -1) {
      newArr.push(item)
    }
  });
  return newArr
}

let res = removeDuplivate(arr)

console.log(res); 
[
  1,         'a',
  true,      'true',
  NaN,       NaN,
  undefined, null,
  {},        {}
]

2.使用array.includes,与indexOf相似，如果找到指定值返回 true，否则返回 false。(可以检测NaN, 不能检测空对象)

function removeDuplivate(arr) {
  let newArr = []  
  arr.forEach(item => {
    if (newArr.includes(item) === false) {
      newArr.push(item)
    }
  });
  return newArr
}

let res = removeDuplivate(arr)

console.log(res); //[ 1, 'a', true, 'true', NaN, undefined, null, {}, {} ]

3.使用array.filter和indexOf，filter返回一个满足条件的新数组，利用indexOf做判断(不能判断NaN和空对象)

function removeDuplivate(arr) {
  return arr.filter((item, index) => {
    return arr.indexOf(item) === index  
  })
}

let res = removeDuplivate(arr)

console.log(res); //[ 1, 'a', true, 'true', undefined, null, {}, {} ]

4.使用Set()对象和Array.from()方法

Set 是唯一值的集合。
每个值在 Set 中只能出现一次。
一个 Set 可以容纳任何数据类型的任何值。
创建一个Set
let set = new Set()

Array.from()
from() 方法从具有 length 属性或可迭代对象的任何对象返回 Array 对象。

let res = Array.from(new Set(arr))

console.log(res); //[ 1, 'a', true, 'true', NaN, undefined, null, {}, {} ]

5.for嵌套for,利用splice去重

外层循环元素，内层循环比较值，值相同时删去
function removeDuplivate(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
}

[
  1,         'a',
  true,      'true',
  NaN,       NaN,
  undefined, null,
  {},        {}
]
不能检测NaN和{}

6.遍历比对相邻元素，不相同则push进新数组 (不能检测NaN和{})

function removeDuplivate(arr) {
  var array = [arr[0]]
  for(var i = 1; i < arr.length; i++) {
    if(arr[i] !== arr[i-1]) {
      array.push(arr[i])
    }
  }
  return array
}
[
  1,         'a',
  true,      'true',
  NaN,       NaN,
  undefined, null,
  {},        {}
]

7.利用Map数据结构键值唯一的特性 (可以检测NaN,不能检测{})

function removeDuplivate(arr) {
  let map = new Map()
  let array = []
  for(let i = 0; i< arr.length; i++) {
    if(map.has(arr[i])) { //如果有key值
      map.set(arr[i], true)
    } else {              //没有key值
      map.set(arr[i], false)  //当键值相同时，后面会覆盖前面，达到去重的效果
      array.push(arr[i])
    }
  }
  return array
}
[ 1, 'a', true, 'true', NaN, undefined, null, {}, {} ]

8.利用filter和hasOwnProperty (可以判断NaN和{}, 完美方法)

function removeDuplivate(arr) {
  var obj = {}
  return arr.filter(function(item) {
    /* typeof item + item 利用类型+元素唯一确定一个值，利用hasOwnProperty来判断obj中是否有该值
       第一次判断没有，将其设置为obj的属性值并赋值为true,代表通过过滤，第二次如果是相同元素，
       hasOwnProperty会通过判断，会通过多目运算符
       将其设置为false，表示没有通过过滤，以此达到去重的效果
    */
    return obj.hasOwnProperty(typeof item + item) ? false :
    (obj[typeof item + item] = true)
  })
}
[ 1, 'a', true, 'true', NaN, undefined, null, {} ]

整理自网络，当作学习笔记，欢迎指正和建议