CocoRoboDesktop/js/UForm/Json.js


//json综述。此类主要处理以下两种情况的数据。
//1、后台返回的数据形如：{"id":"1","name":"zhangsan"}  称为json数据，在js中称为对象。
//  元素Elements，包括div，a，input等在前端的表现形式是：{"tagname":"input","className":""}
//                                                        {"tagname":"div","className":""}
//2、[
//     {"id":"1","name":"zhangsan"}
//     {"id":"2","name":"lisi"}
//  ]
//
//综上所述，前端元素，数据基本都是{}.所以本数据处理类是针对前端所有对象。

//#region 这里是json操作区域

Namespace.register("U.Json");


//兼容JSON
U.Json.init = function () {
    if (!window.JSON) {
        window.JSON = {
            stringify: U.Json.stringify,
            parse: U.Json.parse
        };
    }
}





//JSON类操作,如果不存在json类，则自己创建一个window.JSON。只有一个地方使用了此函数的parse方法

U.Json.stringify = function (json) {//转化成字符串
    return U.UF.C.jsonToStr(json);
}

U.Json.parse = function (str) {//转化成实体
    return str.parseJSON();
}

/**
* 判断数据是否符合条件
*
* @param  {object || array} 被添加的json对象或者数组
* 
* @param  {object} 比较的对象
* 
* @return  {object} 比较的对象
*/
U.Json.ifExists = function (key1, key2) {
    if (key2 === key1) {
        return true;
    }
    for (var i in key1) {
        if (key1[i] != key2[i]) {
            return false;
        }
    }
    return true;
}

//#region json对象处理类，处理类似下面的json数据
/*{
"_id" : ObjectId("532eab25aa01ee01e2297676"),
"UserID" : "83ddf636-7266-4d15-be11-a7ef89bcac55",
"TNode" : [{
"Name" : "根目录",
"CreateDate" : ISODate("2014-03-23T09:36:37.376Z"),
"Type" : "folder",
"ID" : "e6f3963e-6087-b772-8e54-561353832f7b",
"Deep" : 1.0,
"IsDelete" : false,
"TNode" : [{
"Name" : "Test",
"CreateDate" : ISODate("2014-03-23T09:36:43.526Z"),
"Type" : "folder",
"ID" : "0fb91d00-7c5b-dd79-4f3e-1c2d405611e2",
"IsDelete" : false,
"Deep" : 2.0,
"TNode" : [{
"Name" : "index.htm",
"CreateDate" : ISODate("2014-03-23T09:36:43.548Z"),
"Type" : "file",
"ID" : "929bb945-ca3b-dedd-7077-88d1ce0492e3",
"IsDelete" : false,
"Deep" : 3.0,
"Content" : ""
}],
"IsPublic" : true
}]
}]
}*/
/**
* 添加json对象
*
* @param  {object || array} 被添加的json对象或者数组
* 
* @param  {object} 需要添加的对象值
* 
* @return  {object} 返回添加后新的对象值
实例一
var a = [{username:"a"},{username:"b"},{username:"c"}];
var b = {test:'1'}
U.Json.add(a,b);
    
实例二
var a = {username:"cxs"}
var b = {id:'1'}
U.Json.add(a,b);
*/
U.Json.add = function (obj1, obj2) {
    var i; //循环初始值
    //判断参数obj1是否为对象或者数组，如果是对象，循环添加。
    if (!Array.isArray(obj1)) {//判断是否为数组
        for (i in obj2) {//循环参数obj2对象
            obj1[i] = obj2[i]; //对参数obj1赋值
        }
    }
    //如果参数obj1是数组，为数组中的每一个对象都添加赋值
    else {
        for (i = 0; i < obj1.length; i++) {//循环obj1数组
            U.UF.C.AddObj(obj1[i], obj2); //为数组中的每一个对象元素都添加对象obj2的值。
        }
    }
    //返回添加后新的对象值
    return obj1;
}

//少一个跨层搜索的方法。
//obj json格式 为类似mongodb中的数据，
//key 字符串 是关键字
//value 字符串 是值
U.Json.find = function (obj, key, value) {


}


//#endregion

//#region 处理jsonArray的数据，实质是数组

/**
* 根据条件，删除json数组中指定的json
*
* @param  {array} 被删除的json数组。
* 
* @param  {object} 删除json的数据。
* 
* @return  {object} 返回的删除数据。
            
实例一
var a = [{parentid:1, username:"a"},{parentid:1,username:"b"},{parentid:2,username:"c"}]
var b = {parentid:2,username:"c"}
U.Json.delete(a,b);
*/
U.Json.del = function (obj, key, data) { //删除 允许递归
    data = data || obj; //传递进来的json数据
    var i,
        _deldata,
        _delarray = []; //返回的删除数据。
    //数组删除指定obj条件的元素
    if (Array.isArray(data)) {//数组使用
        for (i = 0; i < data.length; i++) {
            //循环删除 获取移除的元素
            _deldata = U.Json.del(obj, key, data[i]);
            if (_deldata.length) { //判断是否移除了元素，length大于0相当于移除超过一个元素。
                data.splice(i, 1); //数组的系统移除方法
                _delarray = _delarray.concat(_deldata); //把移除的元素添加到变量中
                i--; //由于上面用了循环i++ 移除元素后 数组的下标减一了，所以这里用i--让i回到前面一个循环，这样即使数组删除了一个元素也不会直接跳过下一个元素的循环
            }
        }
    }
    else if (typeof data == "object") { //对象删除
        if (U.Json.ifExists(key, data)) {
            delete data;
            _delarray.push(data);
        }
        else if (key === true) { //递归删除
            for (i in data) {
                _deldata = U.Json.del(obj, key, data[i]); //递归删除该数据
                _delarray = _delarray.concat(_deldata); //把删除的数据追加到变量中
            }
        }
        else if (key && data[key]) { //根据指定的key进行递归删除
            _deldata = U.Json.del(obj, key, data[key]); //根据指定的key递归删除该数据
            _delarray = data.concat(_deldata);
        }
    }
    return _delarray;
}

/**
* 根据条件，查找json数组中指定的json
*
* @param  {array} 需要进行选择的json数组。
* 
* @param  {object} 选择的条件
*
* @param  {number} 选择的个数
* 
* @return  {array} 选择后的结果
实例一
var a = [{ parentid: 1, username: "a" }, { parentid: 1, username: "b" }, { parentid: 2, username: "c" }]
var b = { parentid: 1 }
U.Json.select(a,b,2);
*/
U.Json.select = function (arr, obj, num) {//条件获取
    var i, //判断初始化
        _bool, //用于参数判断
        _res = []; //用于存放选择后的结果
    //判断需要选择的对象是否为数组            
    if (Array.isArray(arr)) {
        //循环json数组
        for (i = 0; i < arr.length; i++) {
            //设置判断默认值
            _bool = true;
            //循环条件
            for (var j in obj) {
                //如果是其中有一个条件不符合要求，修改判断值。
                if (arr[i][j] != obj[j]) {
                    _bool = false;
                }
            }
            //如果所有的条件都成立，则记录数组
            if (_bool) {
                _res.push(arr[i]);
            }
            //判断程序选择的个数是否大于用户的选择个数,如果大于选择个数，跳出循环
            if (_res.length == num) {
                break;
            };
        }
    }
    //返回结果集
    return _res;
}

/**
* 根据条件，查找json数组中指定的json,只获取一个结果集
*
* @param  {array} 需要进行选择的json数组。
* 
* @param  {object} 选择的条件
* 
* @return  {array} 选择后的结果
            
实例一
var a = [{ parentid: 1, username: "a" }, { parentid: 1, username: "b" }, { parentid: 2, username: "c" }]
var b = { parentid: 1 }
U.Json.selectOne(a,b);
*/
U.Json.selectOne = function (arr, obj) {
    return (U.Json.select(arr, obj, 1))[0];
}


/**
* 根据条件，对json数组进行排序,此函数需要移动到数组中。
*
* @param  {array} 需要进行选择的json数组。 
* @param  {number} 排序方式 1正序 -1倒序
* @return  {string} 排序的条件，json数组中的键名  
实例一
var a = [{id:3},{id:1},{id:2}]; 
U.Json.sort(a,"id");
*/
U.Json.sort = function (arr, key, isreverse) { //排序

    isreverse = isreverse || 1;
    //采用数组本身的排序sort方法，此方法比较奇特。
    arr = arr.sort(function (obj1, obj2) {
        var _value,
            _type, //比较大小的类型
            _value1 = obj1[key],
            _value2 = obj2[key],
            _isobj = U.UF.C.isObject(obj1); //判断比较的大小是否为对象


        //对象的大小匹配
        if (_isobj) {
            _type = (typeof (obj1[key] || obj2[key])).capitalizeFirstLetter(); //由于类型的值有可能是null或者是undefined，判断两种比较安全
        }
        //非对象的处理方式 U.UF.Ut.compare+type 是一些列的对象比较大小的方法
        else {
            _type = (typeof obj1).capitalizeFirstLetter();
        }
        //数字大小比较  
        if (_type == "Number") {
            _value = _value1 > _value2;
        }
        //时间大小比较
        else if (_type == "Date") {
            _value = U.UF.D.SizeComparison(_value1, _value2);
        }
        //字符串大小比较
        else if (_type == "String") {
            _value = _value1.localeCompare(_value2) == 1;
        }
        //服务器的值可能是null，没有类型比较默认第一个比第二个大
        else {
            _value = true;
        }
        //isreverse 用于判断倒序还是正序，如果是-1就是倒序，如果是1就是正序,需要返回这个值给数组的sort函数，比较奇特
        _value = isreverse * (_value ? 1 : -1);
        return _value;
    });
    return arr;
}


/**
* 根据条件，对json数组进行排序，此函数注释有问题
*
* @param  {array} obj数组
* @param  {string} 关键字 
*/
U.Json.toKeyArray = function (arr, key) {
    var i,
        _returnarr = []; //数组存储数据
    //循环写入数据
    for (i = 0; i < arr.length; i++) {
        _returnarr.push(arr[i][key]);
    }
    //返回数组
    return _returnarr;
}

/**
* 根据条件，对json数组进行排序，此函数注释有问题
*
* @param  {array} obj数组
* @param  {object} key value的条件 
* @param  {number} 关键字 
*/
U.Json.like = function (arr, obj, num) {
    var i, //判断初始化
        _bool, //用于参数判断
        _res = []; //用于存放选择后的结果
    //判断需要选择的对象是否为数组            
    if (Array.isArray(arr)) {
        //循环json数组
        for (i = 0; i < arr.length; i++) {
            //设置判断默认值
            _bool = false;
            //循环条件
            for (var j in obj) {
                //如果是其中有一个条件不符合要求，修改判断值。
                if (arr[i][j] && (arr[i][j].indexOf(obj[j]) > -1 || obj[j].indexOf(arr[i][j]) > -1)) {
                    _bool = true;
                }
            }
            //如果所有的条件都成立，则记录数组
            if (_bool) {
                _res.push(arr[i]);
            }
            //判断程序选择的个数是否大于用户的选择个数,如果大于选择个数，跳出循环
            if (_res.length == num) {
                break;
            };
        }
        //返回结果集
        return _res;
    }
}
//#endregion