原生JavaScript 工具函数 json数据去重 对象数组去重

自己摸索封装了一个json数据去重的工具函数 目前测试没出现问题

思路是判断json里面的对象冒泡跟后面的对象匹配
判断对象的字段名和对象的字段值是否一一匹配

function clear_repetition_ObjArr_Y(ObjArr){
    var ObjArr = ObjArr? ObjArr:[]
    var chongfu_indArr = []  // 重复数据的下标数组
    var chongfu_index =[]   // 去重后的重复数据的下标数组
    var new_Objarr = null;  // 消除重复数据后的心对象数组  json数据

    for(var i =0; i<ObjArr.length; i++){
        var arr_name = get_objNameValue_arr_Y(ObjArr[i])[0]  // 每个对象的键名数组
        var arr_value = get_objNameValue_arr_Y(ObjArr[i])[1] // 每个对象的键值数组
        is_key_same(ObjArr,arr_name,arr_value,i) // 比较两个字段名数组是否相等
    }
    chongfu_index=clear_repetition_arr_Y(chongfu_indArr)  // 数据重复的下标
    new_Objarr = del_sel_index_arr_Y(chongfu_index,ObjArr)
    console.log(new_Objarr)
    return new_Objarr
    
    // 比较两个字段名数组是否相等
    function is_key_same(ObjArr,arr,arr_value,i){
        var arr =arr? arr: []  //传入的字段名数组
        var arr_value =arr_value? arr_value: []  //传入的字段名数组
        for(var j = i+1; j<ObjArr.length; j++){
            var arr_bei =  get_objNameValue_arr_Y(ObjArr[j])[0]   // 字段名数组
            var arr_value_bei =  get_objNameValue_arr_Y(ObjArr[j])[1]   // 字段值数组
            if(is_same_arr_Y(arr,arr_bei)){  
                if(is_same_arr_Y(arr_value,arr_value_bei)){ 
                    chongfu_indArr.push(j)  //  把重复的下标存起来  后面去重
                }
            } 
        }
        return true // 数据不重复 ok了
    }

    // 数组去重（最优）  性能爆炸好 利用对象不能重复的属性
    function clear_repetition_arr_Y(arr){
        var arr = arr? arr :[]
        var exportData=[]
        var obj ={}
        for(var i of arr){
            if(!obj[i]){
                exportData.push(i)
                obj[i] = 1
            }
        }
        return exportData
        /* 
        参数:   arr(Array)          要被去除重复的数组          eg：[1,2,5,2,1]
        返回:   exportData(Array)   已经去除重复的数组          eg：[1,2,5]
        */
    }
    
    // 传入一个对象 返回字段名数组 和字段值数组
    function get_objNameValue_arr_Y(obj){
        var obj = obj? obj:{}
        var arr =[[],[]]
        for(var i in obj){
            arr[0].push(i)
            arr[1].push(obj[i])
        }
        return arr
        /* 
            参数:   obj(Object)    传入的对象        eg：{id:"123":pwd:"123456789"}
            返回:   arr(Array)     arr[0]是对象的键名数组
                                   arr[1]是对象的键值数组
        */
    }

    // 判断两个对象的键名数组 和键值数组是否相等
    function is_same_arr_Y (arr1,arr2){
        var arr1 = arr1 
        var arr2 = arr2
        if(arr1.length===arr2.length){
            for(var c of arr1){
                if(validation_field_count_Y(c,arr2)>0){
                    var index2 = arr2.indexOf(c)
                    arr2.splice(index2,1)
                }
            }
            if(arr2.length==0) return true  
            return false 
        }
        return false  
        /* 
            参数:   arr1(ObjectArr)   比较的对象数组1     eg：["a","s","5",1,2,2]
                    arr2(ObjectArr)   比较的对象数组2     eg：["qss","s","5",1,2,2]
            返回:   true(bool)        两个数组相等
                    false(bool)       两个数组不相等
        */
    }

    // 判断传入字段 在对象的键名/键值数组中出现几次
    function validation_field_count_Y(num,arr){  //  校验不严格  1 可以等于 "1"
        var arr=arr? arr:[]
        var count = 0 // 存放出现几次
        for(var i in arr) if(arr[i]==num) count++   // 问题 如果两个一样的呢
        return count
        /* 
            参数:   num(string/num)    要校验的字段         eg："s"
                    arr(ObjectArr)    是带入判断的数组      eg：["qss","s","5",1,2,2]
            返回:   count(num)         改字段在传入的数组中出现几次
        */
    }

    // 带入一个下标数组和对象数组   剔除符合下标的数据
    function del_sel_index_arr_Y(arr,ObjArr){
        var arr=arr? arr:[]
        var ObjArr=ObjArr? ObjArr:[]
        var exportData=[]
        for(var a in ObjArr){
            var state=""
            arr.forEach(function(item){
                if(a==item) state="匹配到下标相等"
            });
            if(state==="匹配到下标相等") continue
            exportData.push(ObjArr[a])
        }
        return exportData
        /* 
        参数:   arr(Array)              要删除的下标数组          eg：[1,2,5]
        ObjArr(ObjectArr)      要去重的对象数组         eg：[{aaa:'111',bbb:"222"},{aaa:"111",bbb:"222"}]
            返回:   exportData(ObjectArr)   已经去除重复的对象数组
        */
    }

    //  一个对象 遍历比较后面的 对象数组
    function is_value_same(ObjArr,arr,i){
        var arr =arr? arr: []  // 传入的字段名数组
        var arr_length=arr.length
        for(var j = i+1; j<ObjArr.length; j++){
            var arr_bei = get_objNameValue_arr_Y(ObjArr[i])[1]   // 字段值数组
            if(is_same_arr_Y(arr,arr_bei)) return false //"数据重复了"
        }
        return true // 数据不重复 ok了
    }
}

clear_repetition_ObjArr_Y([{aaa:'111',bbb:"222"},{aaa:"111",bbb:"222"},{a:'11',b:"222"},
{aaa:"111",bbb:"222"},{aaa:'111',bbb:"222"},{aaa:"111",bbb:"222"},{a:'666',b:"222"},{a:'666',b:'222'},{q:"q"}])