js判断复杂类型数组或对象是否完全相等

复杂类型不能直接使用‘===’判断，所以写一个函数判断复杂类型是否相等，不能判断包含function、Date、正则类型的对象或数组

    export default function isSame(any1, any2){
      let type1 = Object.prototype.toString.call(any1).slice(8, -1)
      let type2 = Object.prototype.toString.call(any2).slice(8, -1)
      if(type1 !== type2) return false
      if(type1 === 'Object') return objIsSame(any1, any2)
      if(type1 === 'Array') return arrIsSame(any1, any2)
      throw new Error('参数不为对象或数组')
    }

    //判断两个数组是否完全一致
    function arrIsSame(arr1, arr2){
      if(arr1.length !== arr2.length) return false

      let strArr1 = filterEasyArr(arr1).sort()

      let strArr2 = filterEasyArr(arr2).sort()

      if(JSON.stringify(strArr1) !== JSON.stringify(strArr2)) return false

      let objArr1 = filterObjArr(arr1)

      let objArr2 = filterObjArr(arr2)

      let bool = objArr1.every(item1 => {
        let bool = objArr2.some(item2 => objIsSame(item1, item2))
        return bool
      })

      if(!bool) return false

      let array1 = filterArr(arr1)

      let array2 = filterArr(arr2)

      let arrBool = array1.every(item1 => {
        let bool = array2.some(item2 => {
          return arrIsSame(item1, item2)
        })
        return bool
      })

      return arrBool
    }

    //判断两个对象是否完全一致
    function objIsSame(obj1, obj2){
      let arr1 = Object.keys(obj1).sort()
      let arr2 = Object.keys(obj2).sort()

      if(JSON.stringify(arr1) !== JSON.stringify(arr2)) return false
      
      let bool = arr1.every(item => {
        let str1 = Object.prototype.toString.call(obj1[item]).slice(8, -1)
        let str2 = Object.prototype.toString.call(obj2[item]).slice(8, -1)

        if(str1 !== str2) return false

        if(str1 === 'Object'){
          return objIsSame(obj1[item], obj2[item])
        }else if(str1 === 'Array'){
          return arrIsSame(obj1[item], obj2[item])
        }else{
          return obj1[item] === obj2[item]
        }
      })

      return bool
    }

    //过滤数组元素所有简单数据类型
    function filterEasyArr(arr){
      return arr.filter(item => {
        let str = Object.prototype.toString.call(item).slice(8, -1)
        return str !== 'Object' && str !== 'Array'
      })
    }

    //过滤数组元素所有对象数据类型
    function filterObjArr(arr){
      return arr.filter(item => {
        let str = Object.prototype.toString.call(item).slice(8, -1)
        return str === 'Object'
      })
    }

    //过滤数组元素所有数组数据类型
    function filterArr(arr){
      return arr.filter(item => {
        let str = Object.prototype.toString.call(item).slice(8, -1)
        return str === 'Array'
      })
    }