//Namespace.register("U.E"); //JSON操作的命名空间
//U.E.Entity = function (JT, EW) { } //实体

////方法原型 实际上呢我让Object基础了这一些属性 有好处有坏处 好处就是每一个Object操作方便 不好就是基础的太大 实际上我们只要Object（Json） Array拥有 个人认为我们需要改写js内核 写入专门Json对象 
////实体方法
//U.E.Entity = function (JT, EW) { }

//U.E.Entity.prototype = {
//    "Add": function (V) {//添加有添加集合的 有添加数组的
//        var _T = U.M.GetType(this);
//        if (_T == "Array") { this.push(V); } //数组的添加方法 因为数组有自带的方法 就直接添加
//        else { for (var i in V) { if (V.hasOwnProperty(i)) { this[i] = V[i] } } } //对象的添加方法
//    },
//    "Delete": function (V) {
//        var _T = U.M.GetType(this);
//        if (_T == "Object") { delete this[V]; } //删除集合
//        else if (_T == "Array") {
//            _T = U.M.GetType(_T);
//            if (_T == "int") { this.splice(V, 1); } //删除数组的一个
//            else if (_T == "Array") { this.splice(V[0], V[1]); } //删除多个
//            else if (_T == "Object") { for (var i = 0; i < this.length; i++) { if (this[i][V["key"]] == V["value"]) { this.splice(i, 1); } } } //删除数组里的集合
//        }
//    },
//    "Select": function (V, FT) {//查找一个 支持多条件 V为集合{"key1":"value1","key2":"value2"......} 多条件的搜索 
//        var i, j, C;
//        var _T = U.M.GetType(this);
//        if (_T == "Object") {
//            _T = U.M.GetType(V);
//            if (FT) { if (_T == "Object") { if (this.IsTF(V)) { C = this; } else { C = this[FT].Select(V, FT); } } }
//            else { C = this[V]; } //直接获取值 这个没有多大必要 就等于 {数据}["key"]
//        }
//        else if (_T == "Array") {//数组的搜索
//            C = [];
//            for (i = 0; i < this.length; i++) {
//                if (this[i].IsTF(V)) { C.push(this[i]); }
//            }
//            if (C.length == 0 && FT) { for (i = 0; i < this.length; i++) { this[i].Select(V); } } //跨层次搜索
//        }
//        return C;
//    },
//    "IsTF": function (V) {//判断集合是否匹配
//        var _T = false;
//        for (j in V) {//多条件的搜索
//            if (V.hasOwnProperty(j)) {
//                if (V[j] == this[j]) { _T = true; }
//                else { return false; }
//            }
//        }
//        return _T; //返回是否正确
//    },
//    "First": function () { //获取数组里第一个集合
//        return this[0];
//    },
//    "Change": function (V) {//改变值
//        var i, j;
//        var _T = U.M.GetType(this);
//        if (_T == "Object") {
//            for (var i in V) {
//                if (V.hasOwnProperty(i)) {
//                    this[i] = V[i];
//                }
//            }
//        }
//        else if (_T == "Array") {
//            for (i = 0; i < this.length; i++) {
//                if (V["value"] == this[i][V["key"]]) {
//                    for (j in V["ck"]) {
//                        if (V["ck"].hasOwnProperty(j)) {
//                            this[i][j] = V["ck"][j];
//                        }
//                    }
//                }
//            }
//        }
//    },
//    "List": function (ET) {//生成一个一样的实体
//        var _C; //得到的值
//        var _T = U.M.GetType(ET);
//        if (_T == "Object") {
//            _C = {};
//            for (var i in ET) {
//                if (ET.hasOwnProperty(i)) {
//                    _C[i] = List(ET[i]);
//                }
//            }
//            return _C;
//        }
//        else if (_T == "Array") {
//            _C = [];
//            for (var i = 0; i < ET.length; i++) {
//                _C[i] = List(ET[i]);
//            }
//            return _C;
//        }
//        else { return ""; }
//    },
//    "Merger": function () {//合并整个数组分支
//        var _T = U.M.GetType(this);
//        var _C = [];
//        if (_T == "Object") {
//            for (var i in this) { if (this.hasOwnProperty(i)) { _C = _C.concat(this[i].Merger()); return _C; } }
//        }
//        else if (_T == "Array") {
//            for (var i = 0; i < this.length; i++) {
//                if (this[i] != null) { _C = _C.concat(this[i].Merger()); }
//            }
//            return _C;
//        }
//        return this;
//    },
//    "CIndex": function (V) {//创建索引 这里的方法值得我们去思考

//    }
//}

//U.E.E = new U.E.Entity();

////U.M.Setprototype(Object, U.E.E); //让所有的属性都有增删查改 包括了字符串 数组 集合 函数 所以需要改写for in循环

//for (var i in U.E.E) {//让window下拥有这些方法
//    (function (j) {
//        window[j] = function (T, ARM) {
//            (ARM = [ARM]); //转化成数组
//            U.E.E[j].apply(T, ARM);
//        }
//    })(i)
//}

////实例
////US.User = { "UserId": "", "UserName": "", "Userkey": "", "Disk": { "c": "e" }, "Blog": [{ "a": "d", "b": "e"}] };
////创建一个新的列表
////var _e = new List(US.User);

////添加数据
////US.User.Disk.Add({ "a": "b" }); //相当于  US.User.Disk["a"] =  US.User.Disk["b"]
////US.User.Blog.Add({ "a": "d", "b": "d" });

////删除数据
////US.User.Disk["Delete"]("a");

////查找数据
////var _a = US.User.Blog.Select({ "a": "d", "b": "e" }); //这个适用于数组条件搜索
////var _a=US.User.Select({ "a": "d", "b": "e" });//这个还没做。。。。。。。。。。。。。。。
////var _r = US.User.Disk.Select({ "c": "g" }, "next"); //这个适用户集合搜索

////修改数据
////US.User.Disk.Change({ "c": "a" });
////US.User.Blog.Change({ "key": "b", "value": "e", "ck": { "a": "c"} });


////备注：
////1、另外建立一个干劲的处理json的文件，和这个文件分开？
////2、json要能找到父亲节点。
////3、json要能找到父亲节点所在的数组。
////4、json要能找到指定节点id
////5、json要能找到指定节点所在的数组。
////6、json要能添加孩子结点。
////7、json要能添加兄弟节点。
////8、json属性的遍历。
////9、删除拥有某一样属性所有节点，例如在编程树中，有些元素标记了删除，则不选取这些节点出来。
////10、清空数组。可以搜索一下清空数组的三个方案