util-10.JSON操作相关(jsonUtil)

/**
 * ========================10.json操作 s========================
 */
var jsonUtil = {
    /**
     * 对象||数组||json数组深拷贝
     */
    "objDeepCopy": function(source) {
        var sourceCopy = source instanceof Array ? [] : {};
        for (var item in source) {
            sourceCopy[item] = typeof source[item] === 'object' ? objDeepCopy(source[item]) : source[item];
        }
        return sourceCopy;
    },

    /**
     * clone对象
     */
    "cloneObj": function(obj) {
        var newObj = {};
        for (var prop in obj) {
            newObj[prop] = obj[prop];
        }
        return newObj;
    },
    /**
     * clone对象---深克隆
     */
    "deepClone": function(obj){
        var resObj = {};
        for(key in obj){/*key/in循环*/
            if(obj[key] instanceof Object){/*如果属性是对象，则再次调用clone（）（递归）*/
                resObj[key] = clone(obj[key]);
            }else{
                resObj[key] = obj[key];/*clone*/
            }
        }
        return resObj;/*返回resObj*/
    },
    /**
     * 计算json元素个数
     */
    "getJsonLen": function(obj) {
        var size = 0, key;
        for (key in obj) {
            if (obj.hasOwnProperty(key)) {
                size++;
            }
        }
        return size;
    },

    /**
     * 判断obj是否含有propertyName属性,该方法会忽略掉那些从原型链上继承到的属性
     * @param obj
     * @param propertyName
     * @returns {boolean}
     */
    "hasOwnProperty" : function(obj,propertyName){
        return obj.hasOwnProperty(propertyName);
    },

    /**
     * 返回所有属性名数组
     * @param obj
     * @returns {*}
     */
    "getPropertyNames" : function(obj){
        return Object.getPropertyNames(obj);
    },

    /**
     * 获取所有属性(可枚举属性&不可枚举属性)及对应值
     * @param obj
     */
    "getPropertyNamesVals" : function(obj){
        /**
         * propertyName元素的值，
         * ind元素的索引，
         * array被遍历的数组
         */
        Object.getPropertyNames(obj).forEach(function(propertyName,ind,array){
            console.log(propertyName + " -> " + obj[propertyName],ind,array);
        });
    },

    /**
     * 获取可枚举属性
     * @param obj
     * @returns {string[]}
     */
    "getEnumerableKeys" : function(obj){
        //Object.keys只能返回对象本身具有的可枚举属性，不包含prototype定义的属性，否则用for in
        return Object.keys(obj);
    },

    /**
     * 获取不可枚举属性
     * @param obj
     */
    "getUnEnumerableKeys" : function(obj){
        var allKeys = Object.getPropertyNames(obj);
        var enumerableKeys = Object.keys(obj);
        var UnEnumerableKeys = allKeys.filter(function(propertyName, ind, array){
            var idx = enumerableKeys.indexOf(propertyName);
            if(idx == -1){
                return true;
            }else{
                return false;
            }
        });
    },

    /**
     * 一维数组操作：增删排序
     */
    "oneArrayJsonUtil" : function(){
        var arr = ["A-option1","B-option2","C-option3","D-option4"];
        arr.push("E-option5");  //增
        //删增: 索引为1的选项开始删除1项，再在该位置添加一新项
        arr.splice(1,1,"B-New-option2");

        arr.sort(function(a,b){ //升序排序
            return a-b;  //或者: return a>b;
        });

        arr.sort(function(a,b){ //降序排序
            return b-a;  //或者: return a<b;
        });
    },

    /**
     * json二维数组操作：增删排序
     */
    "twoArrayJsonUtil" : function(){
        /*json增加删除*/
        var test = {};
        test["key1"] = "val1";  //增
        delete test["key1"];  //删

        var arr = [{"name":"name1","age":12},{"name":"name2","age":18},{"name":"name3","age":15}];
        arr.push({"name":"name4", "age":9});  //增
        //删增: 索引为1的选项开始删除1项，再在该位置添加一新项
        arr.splice(1,1,{"name":"name2","age":2});

        /**
         * 定义排序:
         * @param field  //排序字段
         * @param reverse //是否升序
         * @param primer  //排序字段数据类型
         * @returns {function(*=, *=)}
         */
        var sort_by = function(field, reverse, primer){

            var key = primer ?
                function(x) {return primer(x[field])} :
                function(x) {return x[field]};

            reverse = [-1, 1][+!!reverse];

            return function (a, b) {
                return a = key(a), b = key(b), reverse * ((a > b) - (b > a));
            }
        };

        //数组sort方法默认按升序排序
        arr_sort=arr.sort(sort_by('age', true, parseInt)); //根据age，升序
        arr_sort=arr.sort(sort_by('name', false, '')); //根据name，倒序  
    },

    /**
     * json对象合并(数组使用concat)
     需求：设有对象 o1 ,o2,需要得到对象o3
     var o1 = { a:'a' }, o2 = { b:'b' };
     // 则
     ===> var o3 = { a:'a', b:'b' };
     */
    "concatJson": function(){
        /**
         * 方法1：使用JQuery的extend方法
         * 方法定义**：jQuery.extend([deep], target, object1, [objectN])
         > 用一个或多个其他对象来扩展一个对象，返回被扩展的对象。
         > 如果不指定target，则给jQuery命名空间本身进行扩展。这有助于插件作者为jQuery增加新方法。 如果第一个参数设置为true，则jQuery返回一个深层次的副本，递归地复制找到的任何对象(递归合并)。否则的话，副本会与原对象共享结构。 未定义的属性将不会被复制，然而从对象的原型继承的属性将会被复制。
         * @type {{a: string}}
         */
        var o1 = { a:'a' },
            o2 = { b:'b' };

        o3 = $.extend(o1, o2);  // 合并 o1 和 o2， 将结果返回给 o3. 注意： 此时，o1 == o3! 即 o1 被修改
        // 或
        o3 = $.extend({}, o1, o2); // 合并 o1 和 o2， 将结果返回给 o3. 注意： 此时，o1 ！= o3! 即 o1 没有被修改

        /**
         * 方法2：用 Object.assign();
         * @type {{a: number}}
         */
        var o1 = { a: 1 };
        var o2 = { b: 2 };
        var o3 = { c: 3 };

        var obj = Object.assign(o1, o2, o3);
        console.log(obj); // { a: 1, b: 2, c: 3 }
        console.log(o1);  // { a: 1, b: 2, c: 3 }, 注意目标对象自身也会改变。

        /**
         * 方法3：遍历赋值法
         * @param o
         * @param n
         */
        var extend=function(o,n){
            for (var p in n){
                o[p]=n[p];
            }
        };
        //类似于直接赋值增加属性：
        o3=o1;
        o3['b']='b';
        // o3 ={ o1:'a', o2:'b' };
    }
};

function Person(){
    this.name = "xxx";
}
Person.prototype.sex = "男";
Person.prototype = {
    "grade" : "1年级",
    "age" : 12
};

var person1 = new Person();
Object.defineProperty(person1,"favorites",{
    "value" : "fa",
    "enumerable" : true
})

for(var i in person1){
    console.log(i,person1[i]);
}
console.log(Object.keys(person1));
console.log(Object.getPropertyNames(person1));


/**
 *   jQuery之$.extend()的js实现方法
 eg:
 var options=window.extend(defaultObj,optionsObj);
 */
void function(global){
    var _isObject = function(o){
        return Object.prototype.toString.call(o) === '[object Object]';
    }

    var _extend = function self(destination, source) {
        var property;
        for (property in destination) {
            if (destination.hasOwnProperty(property)) { // 若destination[property]和source[property]都是对象，则递归
                if (_isObject(destination[property]) && _isObject(source[property])) {
                    self(destination[property], source[property]);
                } // 若source[property]已存在，则跳过
                if (source.hasOwnProperty(property)) {
                    continue;
                } else {
                    source[property] = destination[property];
                }
            }
        }
    }

    var extend = function(){
        var arr = arguments;
        var result = {};
        var i;
        if (!arr.length)
            return {};
        for (i = arr.length - 1; i >= 0; i--) {
            if (_isObject(arr[i])) {
                _extend(arr[i], result);
            };
        }

        arr[0] = result; return result;
    }

    global.extend = extend;
}(window)

/**
 * ========================10.json操作 e========================
 */