js变态数组去重(多类型item、复杂嵌套)

声明一个比较杂乱的数组：

let arr = [1, 'a', 1, '1', '1', undefined, null, undefined, null, { a: 1 }, { b: 1 }, { a: 1 }, { a: '1' }, { a: [1, 2, 3] }, { a: [1, '2', 3] }, [{a: 123, b: 234}], [{a: 123, b: 234}]]

这个数组中包含了较为丰富的数据类型：Object、Array、Number、String、null、undefined，其中的Object还有多层嵌套

解法：

let arr = [1, 'a', 1, '1', '1', undefined, null, undefined, null, { a: 1 }, { b: 1 }, { a: 1 }, { a: '1' }, { a: [1, 2, 3] }, { a: [1, '2', 3] }, [{a: 123, b: 234}], [{a: 123, b: 234}]]

function unique (arr) {
  let obj = {}
  let ret = []
  for (let i = 0; i <= arr.length - 1; i++) {
    const cur = arr[i]
    if (cur instanceof Object && cur.constructor === Object) {
      let isEqual = ret.some(item => {
        if (item instanceof Object && cur.constructor === Object) { // 防止Array、null、undefined
          return assertObj(item, cur)
        }
        return false
      })
      if (!isEqual) {
        ret.push(cur)
      }
      continue
    }

    if (!obj[typeof cur + cur]) {
      obj[typeof cur + cur] = true
      ret.push(cur)
    }
  }
  return ret
}

function assertObj (cur, next) {
  if (Object.keys(cur).length !== Object.keys(next).length) {
    return false
  }

  for (let key in cur) {
    if (cur[key] instanceof Object && cur.constructor === Object) {
      return assertObj(cur[key], next[key])
    }
    if (cur[key] !== next[key]) {
      return false
    }
  }

  return true
}

console.log(unique(arr))