聊聊json数组的去重和排序

首先，我们得明确一下json数组是什么呢？像[{key:1,data:1},{key:2,data:2}]这样得数组，每一个值都是由json对象组成得数组，我们可以称为json数组。

在进行json对象操作前我们需要了解以下几点内容

1.栈内存和堆内存

在js引擎中对变量的存储主要有两种位置，堆内存和栈内存。
栈内存主要用于存储各种基本类型的变量，包括Boolean、Number、String、Undefined、Null。栈内存中的变量一般都是已知大小或者有范围上限的，算作一种简单存储。

而堆内存主要负责像对象Object、Array这种引用数据类型的存储，对于存储的数据大小这方面，一般都是未知的。

栈内存是直接存取数据的，而堆内存是指向存取数据所在的地址，这点很重用！！！

2.浅拷贝和深拷贝

浅拷贝和深拷贝这也是一个非常常见的前端面试题。这两个概念主要是针对引用数据类型的。上面我们有说过引用数据类型是存取数据所在的地址，而平常我们修改数组、对象的时候是直接修改对应地址里面的数据。当我们让一个新的数据等于一个旧的数据如var newarr = oldarr，这时候我们直接对newarr进行修改时，就会直接修改newarr对应的内存地址里面的数据。这时候，我们可以发现oldarr也被更改了并且数据与newarr一样。为了不让这种情况出现，于是就有了与之对应的深拷贝。
深拷贝简单来说就是重新开辟一个新的内存空间，然后让我们的对象、数组指向这个新的内存空间，然后我们对这个新的内存空间进行修改时是不会影响到旧的数组、对象。因为他们指向了不同的内存空间

	/**
     * @description: 判断数据类型
     * @Date: 2020-04-30 00:42:17
     * @author: 小羽
     * @param {type} 
     * @return: 数据类型（如boolean，number，string等）
     */
    getType(obj) {
        let map = {
            '[object Boolean]': 'boolean',
            '[object Number]': 'number',
            '[object String]': 'string',
            '[object Function]': 'function',
            '[object Array]': 'array',
            '[object Date]': 'date',
            '[object RegExp]': 'regExp',
            '[object Undefined]': 'undefined',
            '[object Null]': 'null',
            '[object Object]': 'object'
        };
        return map[Object.prototype.toString.call(obj)];
    }

	/**
     * @description: 深拷贝
     * @Date: 2020-04-30 00:44:01
     * @author: 小羽
     * @param {type} 
     * @return: 进行深拷贝后的data
     */
    deepClone(data){
        let type = this.getType(data);
        let obj;
        if(type === 'array'){
            obj = [];
        } else if(type === 'object'){
            obj = {};
        } else {
            //不再具有下一层次
            return data;
        }
        if(type === 'array'){
            for(let i = 0, len = data.length; i < len; i++){
                obj.push(this.deepClone(data[i]));
            }
        } else if(type === 'object'){
            for(let key in data){
                obj[key] = this.deepClone(data[key]);
            }
        }
        return obj;
    }
    

3.json数组的去重和排序

json数组的去重和排序，其实与普通数组思路基本一样，只是多了一个json的健值。关键点就在于深拷贝，因为不使用深拷贝的话则会直接操作原始数组所指向的内存数据，导致排序的异常。

	/**
     * @description: json对象数组，根据key值去重
     * @Date: 2020-05-04 22:55:38
     * @author: 小羽
     * @param {type} 
     * arr json对象数组
     * key json对象的健值，根据该健值进行去重
     * @return: 
     */
    uniqueJsonArr(arr,key){
        let newObj = []
        for(let item of arr){
            let tag = true
            for(let item1 of newObj){
                if(item[key]==item1[key]){
                    tag = false
                }
            } 
            if(tag){
                newObj.push(item)
            }
        }
        return newObj
    }

    /**
     * @description: json对象数组，根据key值排序
     * @Date: 2020-05-04 23:06:18
     * @author: 小羽
     * @param {type} 
     * arr json对象数组
     * key json对象的健值，根据该值进行去重
     * type 排序方式，默认为asc，即升序
     * @return: 
     */
    sortJsonArr(arr,key,type="asc"){
        let newArr = this.deepClone(arr)
        if(type ==="desc"){
            for(let item of newArr){
                for(let item1 of newArr){
                    if(item[key]<item1[key]){
                        let newObj = this.deepClone(item[key])
                        item[key] = this.deepClone(item1[key])
                        item1[key] = newObj
                    }
                }
            }
        }else{
            for(let item of newArr){
                for(let item1 of newArr){
                    if(item[key]>item1[key]){
                        let newObj = this.deepClone(item[key])
                        item[key] = this.deepClone(item1[key])
                        item1[key] = newObj
                    }
                }
            }
        }
        return newArr
        
    }