CocoRoboDesktop/js/UC/U.MC.js

/*
此函数区域用于常用的通用函数 如位置 大小 计时器等
*/
Namespace.register("U.M");
//#region 通用函数区域

/**
* 属性添加处理 这里处理例如chrome取消innerText等
*
* @param  {object} 需要添加属性的对象
* @param  {string} 类型名字
* @param  {function} get函数处理
* @param  {function} set函数处理
*/
U.M.HEPropert = function (UDE, UDN, UGCB, USCB) {
    if (UDE.__defineGetter__) {//W3C兼容
        UDE.__defineGetter__(UDN, UGCB);
        UDE.__defineSetter__(UDN, USCB);
    }
    else if (Object.defineProperty) {//ie8+
        Object.defineProperty(UDE, UDN, { get: UGCB, set: USCB, configurable: true });
    }
    else { //ie6 7
        UDE[UDN] = UGCB; //[^\w]([A-Za-z_][\w]*)\s*\(\s*[\w]+\s*(,\s*[\w]+\s*)*\)
        UDE[UDN].toString = UGCB; //获取的时候自动执行用户调用
        UDE.attachEvent("onpropertychange", U.M.apply(UDE, [[U.M.HEPropert.OPJL, [UDE, UDN, UGCB, USCB]]]));
    }
}

/**
* 上述函数的子函数 用于ie兼容
*
* @param  {object} 需要添加属性的对象
* @param  {string} 类型名字
* @param  {function} get函数处理k
* @param  {function} set函数处理
*/
U.M.HEPropert.OPJL = function (UDE, UDN, UGCB, USCB) {
    if (event.propertyName == UDN) { //判断变化的属性
        var _UCB = arguments.caller.caller;
        UDE.detachEvent("onpropertychange", _UCB);
        USCB(UDE[UDN]);
        UDE[UDN] = UGCB;
        UDE[UDN].toString = USCB;
        UDE.attachEvent("onpropertychange", _UCB); //重新设置
    }
}

/**
* 对象添加原型方法,添加新的数据类型，或者在已有数据类型上扩充功能，例如：String,Number,Array,Object,Guid等
*
* @param  {object} 数据类型，例如String,Number等。
* @param  {string、 object} 当这个参数为string的时候下述函数有效
* @param  {function} string => function 原型对应的函数
*/
U.M.Setprototype = function (UDE, UAE, UCB) {
    if (typeof UAE == "string") {  //大量的添加原型方法
        UDE.prototype[UAE] = UCB;
    }
    else { //单个添加
        for (var i in UAE) {
            UDE.prototype[i] = UAE[i];
        }
    }
}

/**
* 获取元素的定位位置
*
* @param  {element} 元素
* @return  {array} 返回元素的位置 
----------[0] 元素的top
----------[1] 元素的left
*/
U.M.pageXY = function (UDOD) {
    var _UTP,
    _UDE = [0, 0]; //需要返回的元素的位置
    while (UDOD) {
        _UTP = U.M.GetStyle(UDOD, "position"); //元素的position
        if (_UTP != "static") {
            _UDE[0] += UDOD.offsetTop; //元素的上距
            _UDE[1] += UDOD.offsetLeft; //元素的左距
        }
        UDOD = UDOD.offsetParent;
    }
    return _UDE; //返回
}


/**
* 获取元素真实大小
*
* @param  {element} 元素
* @param  {string} 获取长或者宽的属性
---------[width] 长
---------[height] 宽
* @return  {} 返回元素的位置 
----------[0] 元素的top
----------[1] 元素的left
*/
U.M.GETHW = function (UDOD, UTF) {
    var i, //用于循环
    _UWH, //用于记录元素的offset属性
    _UCS, //用于记录元素的style属性
    _UCE = [0, 2], //用于设置循环的范围
    _UDE = ["Top", "Bottom", "Right", "Left"], //用于连接字符串 获得offset属性
    _UFN = U.M.GetStyle, //获取元素所使用的样式
    _UD = _UFN(UDOD, "display"), //获取元素的display属性
    _UH = _UFN(UDOD, UTF); //获取元素的UTF(width,height...)属性
    (_UD == "none" && _UH.indexOf("px") == -1) && (_UCS = UDOD.style.cssText, UDOD.style.cssText += ";display:block;visibility:hidden;", _UH = null);
    if (_UH == null || _UH.indexOf("%") > -1 || isNaN((_UH = Number(_UH.toInt())))) { //百分比和number使用
        _UWH = UDOD["offset" + (UTF.charAt(0).toUpperCase() + UTF.substr(1))]; //获取长获取宽
        if (UTF == "width") { //
            for (i = 0; i < _UCE.length; i++) {
                _UCE[i] += i;
            }
        }
        for (i = _UCE[0]; i < _UCE[1]; i++) {
            _UWH -= (((_UH = _UFN(UDOD, "padding" + _UDE[i]).toInt()).length ? 0 : _UH) + ((_UH = _UFN(UDOD, "border" + _UDE[i] + "Width").toInt()).length ? 0 : _UH));
        };
        (_UCS != null) && (UDOD.style.cssText = _UCS);
    }
    else { //非百分比处理
        _UWH = _UH;
    }
    return _UWH;
}

/**
* 获取元素的位置大小
*
* @param  {element} 元素
* @return  {object} 返回元素的位置  函数内有详细的注释
*/
U.M.GetElementAllInfo = function (UDOD) {
    //    UDOD要获取位置的元素    
    if (UDOD) {
        var i, //用于循环
        _USE, //存放所有数据的集合
        _UVE, //用于获取元素的border属性
        _UPE = [], //用于获取元素的padding属性
        _UBE = [], //储存变量 
        _UAE = ["Top", "Right", "Bottom", "Left"], //用于连接字符串 获得offset属性
        _UCE = UDOD.getBoundingClientRect(), //返回一个矩形对象
        _UDE = U.M.pageXY(UDOD), //获取UDOD的位置
        _UDPD = U.M.TOSP(UDOD); //获取元素offsetParent
        for (i = 0; i < _UAE.length; i++) {  //筛选 padding 和 border
            _UPE[i] = U.M.GetStyle(UDOD, "padding" + _UAE[i]).toInt();
            _UBE[i] = (_UVE = U.M.GetStyle(UDOD, "border" + _UAE[i] + "Width").toInt()).length ? 0 : _UVE;
        }
        _USE = {
            PD: _UPE, //元素的padding
            BD: _UBE, //元素的border
            PXT: (document.documentElement.scrollTop) + _UDPD.scrollTop, //滚动条top位置
            PXL: (document.documentElement.scrollLeft) + _UDPD.scrollLeft, //滚动条left位置
            SH: UDOD.scrollHeight,  //包含滚动掉的高度
            SW: UDOD.scrollWidth, //包含滚动条的长度
            SL: UDOD.scrollLeft, //滚动条向左的位置
            ST: UDOD.scrollTop, //滚动条向右的位置
            CH: UDOD.clientHeight, //页面不包含 border padding宽度
            CW: UDOD.clientWidth, //页面不包含 border padding长度
            CT: UDOD.clientTop, //页面margin + top的高度
            CL: UDOD.clientLeft, //页面margin + left的长度
            OH: UDOD.offsetHeight, ///页面包含 border padding宽度
            OW: UDOD.offsetWidth,  //页面包含 border padding长度
            OL: UDOD.offsetLeft, //页面left的长度 
            OT: UDOD.offsetTop, //页面top的高度
            BCRH: _UCE.bottom - _UCE.top, //元素的显示高度
            BCRW: _UCE.right - _UCE.left, //元素的显示长度
            BCRT: _UCE.top, //元素的显示top
            BCRL: _UCE.left, //元素的显示left
            BCRB: _UCE.bottom, //元素的显示bottom
            BCRR: _UCE.right, //元素的显示right
            TX: _UDE[1], //元素的显示高度
            TY: _UDE[0]//元素的显示高度
        };
        _USE.H = _USE["OH"] - _USE["PD"][1] - _USE["PD"][3] - _USE["BD"][1] - _USE["BD"][3]; //原宽度 不包含所有的border padding margin
        _USE.W = _USE["OW"] - _USE["PD"][0] - _USE["PD"][2] - _USE["BD"][0] - _USE["BD"][2]  //原长度 不包含所有的border padding margin

        //        U.Ut.AddObj(_USE, {
        //            H: _USE["OH"] - _USE["PD"][1] - _USE["PD"][3] - _USE["BD"][1] - _USE["BD"][3], //原宽度 不包含所有的border padding margin
        //            W: _USE["OW"] - _USE["PD"][0] - _USE["PD"][2] - _USE["BD"][0] - _USE["BD"][2]  //原长度 不包含所有的border padding margin
        //        });
        return _USE;
    }
    return {};
}


/**
* 获取元素的位置大小
*
* @param  {element} 元素
* @return  {object} 返回元素的位置  函数内有详细的注释
*/
U.M.GetElementInfo = function (UDOD) {
    var _UCE = UDOD.getBoundingClientRect(); //返回一个矩形对象
    return {
        SH: UDOD.scrollHeight,  //包含滚动掉的高度
        SW: UDOD.scrollWidth, //包含滚动条的长度
        SL: UDOD.scrollLeft, //滚动条向左的位置
        ST: UDOD.scrollTop, //滚动条向右的位置
        CH: UDOD.clientHeight, //页面不包含 border padding宽度
        CW: UDOD.clientWidth, //页面不包含 border padding长度
        CT: UDOD.clientTop, //页面margin + top的高度
        CL: UDOD.clientLeft, //页面margin + left的长度
        OH: UDOD.offsetHeight, ///页面包含 border padding宽度
        OW: UDOD.offsetWidth,  //页面包含 border padding长度
        OL: UDOD.offsetLeft, //页面left的长度 
        OT: UDOD.offsetTop, //页面top的高度
        BCRH: _UCE.bottom - _UCE.top, //元素的显示高度
        BCRW: _UCE.right - _UCE.left, //元素的显示长度
        BCRT: _UCE.top, //元素的显示top
        BCRL: _UCE.left, //元素的显示left
        BCRB: _UCE.bottom, //元素的显示bottom
        BCRR: _UCE.right //元素的显示right
    }
}

/**
* 获取大小位置
*
* @param  {element} 元素
* @return  {object} 获取元素的大小 
*/
U.M.GetPDWH = function (UDOD) {
    var i, _UST,
    _UDTD = $(UDOD),
    _UPE = [],
    _UBE = [],
    _UAE = ["Top", "Right", "Bottom", "Left"];
    //获取padding border
    for (i = 0; i < _UAE.length; i++) {
        _UPE[i] = _UDTD.css("padding" + _UAE[i]).toInt();
        _UBE[i] = _UDTD.css("border" + _UAE[i] + "Width").toInt();
        (_UBE[i].length) && (_UBE[i] = 0);
    }
    //获取长宽
    _UAE = ["width", "height"];
    for (i = 0; i < _UAE.length; i++) {
        _UST = _UAE[i]; _UAE[i] = _UDTD[_UST]();
    }
    //返回大小处理
    return {
        "PD": _UPE, //padding 
        "BD": _UBE, //border
        "OW": _UAE[0] + _UPE[1] + _UPE[3] + _UBE[1] + _UBE[3], //包含padding border 的长
        "OH": _UAE[1] + _UPE[0] + _UPE[2] + _UBE[0] + _UBE[2], //包含padding border 宽
        "CW": _UAE[0], //不包含padding border 宽
        "CH": _UAE[1]//不包含padding border 宽
    };
}

/**
* 获取元素offsetParent 兼容ie8-
*
* @param  {element} 元素
* @param  {boolean} 是否从上级开始找起
* @param  {string}  规定的position值
* @return  {elememt}  offsetParent
*/
U.M.TOSP = function (UDOD, UTF, UPT) {
    var _UTP, _UDBD = document.body;
    (!UTF) && (UDOD = UDOD.offsetParent);
    while (UDOD && UDOD != _UDBD) {
        _UTP = U.M.GetStyle(UDOD, "position");
        if ((!UPT && _UTP != "static") || (_UTP == UPT)) {
            break;
        }
        UDOD = UDOD.offsetParent;
    }
    return UDOD || _UDBD;
}

/**
* 根据ID获取指定的子元素
*
* @param  {element} 父级元素
* @param  {string} 传进来的ID
* @return  {element} 获取子元素id相等的 
*/
U.M.GetCById = function (UDOD, UDID) {
    var i, //用于循环
    _UDAD = $(UDOD).Child(); //该UDOD元素的子元素
    for (i = 0; i < _UDAD.length; i++) {
        if (_UDAD[i].id == UDID) { return _UDAD[i]; }
    }
}

/**
* 根据ID获取自定的父亲元素
*
* @param  {element} 当前元素
* @param  {string} 父亲的id
* @return  {object} 获取元素的大小 
*/
U.M.GTPN = function (UDOD, UTID) {
    while (UDOD && !(UDOD == UTID || UDOD.id == UTID)) { //递归寻找父级
        UDOD = UDOD.parentNode;
    }
    return UDOD;
}

/**
* 获取children不为文本
*
* @param  {element} 当前元素
* @param  {string} 父亲的id
* @return  {array} 获取所有的子节点 
*/
U.M.GTCN = function (UAE, UTP) {
    var i, //用于循环
    _UDE = []; //用于存放数据且返回
    for (i = 0; i < UAE.length; i++) {
        if (UAE[i].nodeType == 1 && (!UTP || UTP.indexOf(UAE[i].tagName.toLowerCase()) == -1)) {
            _UDE.push(UAE[i])
        };
    }
    return _UDE;
}

/**
* 获取可编辑元素
*
* @param  {element} 当前元素
* @param  {string} 父亲的id
* @return  {element} 可编辑的元素 
*/
U.M.GetDE = function (UDOD) {
    var _UDBD = document.body;
    while (UDOD && _UDBD != UDOD) {
        if (UDOD.tagName) {
            if ("textarea,input".indexOf(UDOD.tagName.toLocaleLowerCase()) > -1 || UDOD.contentEditable == "true") { //可编辑元素
                break;
            }
        }
        UDOD = $(UDOD).Parent();
    }
    return UDOD;
}

/**
* 判断元素是否是制定的子元素
*
* @param  {element} 该元素为父元素
* @param  {element} 需要判断的元素
* @return  {boolean} 获取元素的大小 
*/
U.M.EISE = function (UDOD, UDTD) {
    if (UDOD && UDTD) {
        if (UDOD.contains) { //ie chrome 兼容
            if (UDOD.contains(UDTD)) {
                return true;
            }
        }
        else if (UDOD.compareDocumentPosition) { //firefox
            if (!(!!(UDOD.compareDocumentPosition(UDTD)))) {
                return true;
            }
        }
    }
    return false;
}

/**
* 判断元素的位于第几个
*
* @param  {element} 当前元素
* @return  {number} 位置 
*/
U.M.IndexOfParent = function (UDOD) {
    var _UDAD = $($(UDOD).Parent()).Child();
    return _UDAD.indexOf(UDOD); //判断元素在指定的位置第几个
}

/**
* 判断元素的属性是否是制定属性函数固有属性 true自定义 false固有
*
* @param  {element} 当前元素
* @param  {string} 为元素的各属性
* @return  {number} 位置 
*/
U.M.Arrt = function (UDOD, UTP) {
    UDOD = UDOD || $$("div");
    var _UAE = UDOD.attributes; //_UAE 为UDOD的属性集合
    if (_UAE) {
        if (_UAE[UTP]) { //IE6-7判断是否是自定义属性
            return _UAE[UTP].expando == true;
        }
        else { //是否为自定义属性
            return UDOD.getAttribute(UTP) !== null || UDOD[UTP] === void 0;
        }
    }
}

/**
* 浏览器全屏
*
* @param  {element} 需要全屏的元素，例如视频.
* @param  {string}  全屏或者取消全屏，true全屏，false是取消全屏
* @return  {number} 成功或者失败。

U.M.fullScreen(document,true);
U.M.cancelfullScreen(document,false);
*/
U.M.fullScreen = function () {
    var _funcname = U.M.GetFullSreeenName("requestFullScreen"); //全屏函数名
    if (_funcname != null)
        document[_funcname](); //执行全屏函数
}

//取消浏览器全屏
U.M.cancelfullScreen = function () {
    var _funcname = U.M.GetFullSreeenName("cancelFullScreen") || U.M.GetFullSreeenName("exitFullScreen"); //全屏函数名
    if (_funcname != null)
        document[_funcname](); //执行全屏函数
}



/**
* 获取各个浏览器全屏函数的名称
** @return  {string} 全屏功能的函数名 
*/
U.M.GetFullSreeenName = function (funcname) {
    var i, _functionname;
    //各个浏览器的全屏函数名称是不一样的，用数组把各个全屏函数包装起来。
    //注：各个浏览器全屏函数名如数组： _full = ["requestFullscreen", "mozRequestFullScreen", "webkitRequestFullscreen", "msRequestFullscreen", "oRequestFullscreen"];
    //各个浏览器还有不同的取消全屏，退出全屏功能"cancelFullScreen"，"exitFullScreen" 
    var _full = ["", "webkit", "moz", "ms", "o"]; //所有浏览器的兼容字符串集
    for (i = 0; i < _full.length; i++) {
        if (_full[i])
            _functionname = _full[i] + funcname.capitalizeFirstLetter();
        else
            _functionname = funcname;
        //判断拼接的浏览器兼容函数名在文档中是否存在。存在则返回函数，不存在返回null。
        if (_full[i] in document.documentElement || _full[i] in document) {
            return _full[i];
        }
    }
    return null;
}


/**
* 添加或者删除自定义属性
*
* @param  {array} 所有的需要变化的元素集 
* @param  {string} 全屏功能的函数名 
* @param  {boolean} 判断是删除属性还是添加属性 
* @param  {array} 二级属性 
*/
U.M.SRAttr = function (UDE, USN, UTV, UCE) {
    var i, //用于循环
    j, //用于循环
    _UAE,
    _UTP = UTV != null ? "setAttribute" : "removeAttribute"; //判断是设置还是删除属性
    for (i = 0; i < UDE.length; i++) {//
        _UAE = UDE[i];
        if (_UAE) {
            if (UCE && UCE.length) { //训话属性处理
                for (j = 0; j < UCE.length; j++) {
                    _UAE = _UAE[UCE[j]];
                }
            }
            _UAE[_UTP](USN, UTV); //执行删除获取添加属性
        }
    }
}

/**
* 修改设置制定样式后获取所有设置的元素
*
* @param  {element} 元素 
* @param  {string} 获取的类型 
* @param  {string} 是添加还是移除属性 
-----------De 移除属性
* @param  {object} 设置的属性 
* @return  {array} 通过参数2获取的元素 

*/
U.M.SetElement = function (UDE, UTP, URE, UTF) {
    if (UDE) {
        (typeof (UDE) == "string") && (UDE = $$("div", { "innerHTML": UDE }));
        UDE = UDE || document;
        var i, //用于循环
        _UFT,
        _UAE,
        _UDOD,
        _UMS = "",
        _UCE = [];
        UTP = (UTP == "*" || !UTP) ? "&*" : UTP; //需要获取的值
        if (UTF) {
            for (i in UTF) {
                UTP += ("[" + i + (UTF[i] ? ("=" + UTF[i]) : "") + "]"); //属性选择
            }
        }
        if ((_UAE = $(UTP, UDE)) && UTF !== false && URE) { //设置
            _UCE = _UAE[(_UFT = URE == "De") ? "remove" : "addAttrArray"](_UFT ? null : URE);
        }
        (URE == "De") && (_UCE = [_UCE.length > 0 ? _UCE : _UAE, UDE]); //如果为删除返回两个值  一个是选中的值 一个是传入的元素集
        return _UCE;
    }
    return [];
}

/**
* 获取元素所使用的样式
*
* @param  {element} 需要获取样式的元素 
* @param  {string} 样式的key 
*/
U.M.GetStyle = function (UDOD, UVE) {
    if (UDOD && UDOD.style) {
        UVE = U.M.CssTHH(UVE);
        return (UDOD.style[UVE] || UVE == "cssText") ? UDOD.style[UVE] : (UDOD.currentStyle ? UDOD.currentStyle[UVE] || "" : "");
    }
    return ""; //获取js对应的style值
}

/**
* 添加删除获取class
*
* @param  {array} 进行操作的对象 
* @param  {string} 确定循环范围 
* @param  {element} 正则表达式 获取字符 
* @param  {string} 获取或删除指令
* @return  {boolean} 是否存在改样式
*/
U.M.ARClass = function (UDE, UIE, UCN, UTF) {
    var _UCT, //储存对象样式名
    _UFT, //储存索引值
    _UIF, //储存索引值
    i = UIE || 0; //循环初始化
    _UL = UIE + 1 || UDE.length, //确定循环范围
    _UL = Math.min(_UL, UDE.length);
    _UCE = new RegExp("(\\s|^)" + UCN + "(\\s|$)"); //需要索引的值
    for (; i < _UL; i++) {
        _UCT = UDE[i].className;
        _UFT = _UCT.match(_UCE);
        if (UTF == "Add") { (!_UFT) && (UDE[i].className += (_UCT ? " " : "") + UCN); } //添加class
        else if (UTF == "RE") { //删除class
            (_UFT) && (_UIF = _UCT.indexOf(UCN) + UCN.length, UDE[i].className = _UCT.replace(_UCE, (_UIF == _UCT.length || !_UIF) ? "" : " "));
        }
    }
    return _UFT;
}

/**
* style样式转换 如 text-align => textAlign 或者相反的换
*
* @param  {array} 进行操作的对象 
* @param  {string} 确定循环范围 
*/
U.M.CssTHH = function (UST, UTF) {
    UTF = UTF ? [/[A-Z]/g, "-", 0, "toLowerCase"] : [/-[a-z ]/g, "", 1, "toUpperCase"]; //转换的样式或者属性
    return UST.replace(UTF[0], function (UMS) { //利用正则转换
        return UTF[1] + UMS.charAt(UTF[2])[UTF[3]]();
    });
}

/**
* 获取 rgb颜色值
*
* @param  {array} 进行操作的对象 
* @return  {string} 确定循环范围 
*/
U.M.HexBack = function (UCS) {
    var i, //循环初始化
    _UAE = "#", //rgb颜色前缀
    _USE = UCS.match(U.MS.rgb); //索引值
    if (_USE) {
        for (i = 1; i < _USE.length; i++) {
            _UAE += ("0" + _USE[i].toInt().toString(16)).slice(-2); //转换的方式
        }
        return _UAE;
    }
    return UCS;
}

/**
* 获取css3过渡属性
*
* @return  {array} 过渡属性的值
-----------[0] 过渡的css 
-----------[1] 过渡的回调函数 
-----------[2] 兼容的前缀 
-----------[3] 浏览器过渡的监视属性 
-----------[4] 浏览器结束的属性 
*/
U.M.GCssAe = function () {
    var i, //遍历初始化
    _USE = $$("div").style, //获取div的样式
    //css兼容的形式
    _UDE = {
        "WebkitTransition": ["-webkit-transition", "webkitTransitionEnd", "-webkit-", "webkitRequest", "webkitCancel"], //webkit浏览器的兼容
        "OTransition": ["-o-transition", "oTransitionEnd", "-o-", "oRequest", "oCancel"], //Op 浏览的兼容
        "MozTransition": ["-moz-transition", "transitionend", "-moz-", "mozRequest", "mozCancel"], //火狐浏览器的兼容
        "MsTransform": ["-ms-transition", "transitionend", "-ms-"], //ie低版本的兼容
        "transition": ["transition", "transitionend", "", "r", "cancel"] //html5的兼容
    }
    //循环判断获取
    for (i in _UDE) {
        if (_UDE.hasOwnProperty(i) && _USE[i] !== undefined) {
            _UDE[i].push(i);
            return _UDE[i];
        }
    }
}

/**
* css动画
*
* @return  {array} 过渡属性的值
-----------[0] 动画的css 
-----------[1] 动画的回调函数 
-----------[2] 兼容的前缀 
-----------[3] 浏览器过渡的监视属性 
-----------[4] 浏览器结束的属性 
*/
U.M.CssAm = function () {
    var i, //遍历初始化
    _USE = $$("div").style; //获取div的样式
    //_UDE css动画属性名数组
    var _UDE = {
        "animation": ["animation", "animationEnd", "", "webkitRequest", "webkitCancel"],
        "OTransition": ["-o-transition", "oTransitionEnd", "-o-", "oRequest", "oCancel"],
        "MozTransition": ["-moz-transition", "transitionend", "-moz-", "mozRequest", "mozCancel"],
        "MsTransform": ["-ms-transition", "transitionend", "-ms-"],
        "transition": ["transition", "transitionend", "", "r", "cancel"]
    }
    for (i in _UDE) { //循环判断兼容
        if (_UDE.hasOwnProperty(i) && _USE[i] !== undefined) {
            _UDE[i].push(i);
            return _UDE[i];
        }
    }
}

/**
* css动画异步
*

*/
U.M.AsynCssEM = function (UDID, UDSD, UCB, UIF, UIF) {
    this.removeClass(UDID, UIF);
    $(UDSD).remove();
    (UCB) && (UCB(UIF));
}

/**
* css动画异步
*
* @return  {array} 过渡属性的值
*/
U.M.JsEM = function (UDOD, UDE, UHK, UTF) {
    var i, //遍历初始化
    j, //循环初始化
    _UCE, //储存字符串
    _USE = [], //初始化数组
    _UME = {}, //初始化对象
    _UM = /[^\d-|.]+/ig, //正则表达式
    _UNUM = /[\d-|.]+/ig; //正则表达式
    for (i in UDE) {
        if (UDE.hasOwnProperty(i)) {
            if (i == "style") {//style的制作
                _UCE = U.MS.jsonToStr(U.M.JsEM(UDOD[i], UDE[i], UHK, true));
                (_UCE.length > 2) && (_UME[i] = { "cssText": _UCE.replace(/["|{|}]+/ig, "").replace(/,/ig, ";") });
            }
            else {//普通动画
                _USE[0] = UDOD[i] || 0; _USE[1] = UDE[i]; for (j = 0; j < _USE.length; j++) {
                    (typeof _USE[j] != "number") && (_USE[j] = Number(_USE[j].replace(_UM, "")));
                } //生成位置
                if (!isNaN(_USE[0])) { //动画获取
                    j = UTF ? U.M.CssTHH(i, true) : i;
                    _UME[j] = _USE[0] + ((_USE[1] - _USE[0]) * UHK); _USE[1] = UDOD[i] ? UDOD : UDE;
                    (typeof _USE[1][i] == "string") && (_UME[j] = _USE[1][i].replace(_UNUM, _UME[j]));
                }
            }
        }
    }
    return _UME;
}

/**
* 获取鼠标位置
*
* @param  {element} 相对对象 
* @param  {element} 进暂无使用行操作的对象 
* @return  {array} 过渡属性的值
*/
U.M.GetMousep = function (UDOD, UDTD) {
    var _UE = U.M.GetEvent(), //获取MouseEvent
    _UET = (_UE.touches && _UE.touches[0]) ? _UE.touches[0] : _UE, //如果是手机点击则获取touches[0]对象
    _UDE = { "X": _UET.clientX || _UET["pageX"] || 0, "Y": _UET.clientY || _UET["pageY"] || 0 }, //储存坐标的对象
    _UGE = { BCRL: 0, PXL: 0, BCRT: 0, PXT: 0 }; //用于储存数据sss

    (UDTD || UDOD) && (_UGE = UDTD || U.M.TOSP(UDOD, true),
    _UGE = U.M.GetElementAllInfo(_UGE)); //获取相对元素的位置
    U.Ut.AddObj(_UDE, { "TX": _UGE.BCRL - _UGE.PXL, "TY": _UGE.BCRT - _UGE.PXT }); //获取位置与上级相对位置
    U.Ut.AddObj(_UDE, { "X": _UDE["X"] - (_UDE["TX"] || 0), "Y": _UDE["Y"] - (_UDE["TY"] || 0), "MX": _UDE.X, "MY": _UDE.Y }); //设置值
    return _UDE;
}

//获取事件源 跨iframe搜索
U.M.GetEvent = function () {
    var i, //循环初始化
    _UDOD, //用于储存数据
    _UDFD = window.frames; //获取window.frames
    var _UE = window.event; //获取window.event
    if (!_UE) {
        for (i = 0; i < _UDFD.length; i++) { //循环所有的iframe 获取事件源
            _UDOD = _UDFD[i];
            try {
                _UE = _UDOD.event;
                if (_UE) { break; }
            }
            catch (e) { continue; };
        }
    }
    return _UE;
}

/**
* 阻止冒泡
*/
U.M.StopBubble = function () {
    var _UE = U.M.GetEvent(); //获取Event
    if (_UE) {
        if (_UE.stopPropagation) { _UE.stopPropagation(); } // 停止DOM事件层次传播
        else { _UE.cancelBubble = true; } //停止向上冒泡传播
        return true;
    }
}

/**
* 动画初始化
*
* @param  {object} 动画设置对象 
*/
U.M.Animation = function (UDE) { //基础对象
    return new U.M.Animation.init(UDE, U.M.Animation.get());
}

U.M.Animation.get = function () {
    var i, j, //循环变量
    _UFE,
    _UDE = [["r", "cancel"], ["", "moz", "webkit", "o"]]; //兼容
    //获取兼容字符串
    for (i = 0; i < _UDE[0].length; i++) {
        for (j = 0; j < _UDE[1].length; j++) {
            if (_UFE = window[_UDE[1][j] + (j ? _UDE[0][i].replace(/\b(\w)|\s(\w)/g, function (e) { //通过循环和获取 每次获取的时候利用首字母大写设置
                return e.toUpperCase();
            }) : _UDE[0][i]) + "AnimationFrame"]) { _UDE[0][i] = _UFE; break; };
        }
    }
    _UDE = _UDE[0];
    (typeof _UDE[0] == "string") && (_UDE[0] = _UDE[1] = null);
    return _UDE;
}

/**
* 获取鼠标位置
*
* @param  {object} 对象 
*/
U.M.Animation.init = function (UDE, USE) {//动画初始化
    U.Ut.AddObj(this, UDE); //添加动画对象
    this.type = USE || U.M.Animation.get();
    this.sm = (USE && USE[0]) ? new Date() : Math.ceil(this.ti / 20); //动画开始的时间  
    this.start(USE); //开始动画
}

//动画方法
U.M.Animation.init.prototype = {
    start: function (USE) {//这里开始了动画 
        var _UFN = (USE || this.type)[0];
        this.tm = (_UFN ? _UFN(U.M.apply(this, this.time)) : window.setInterval(U.M.apply(this, [[this.time, [true]]]), 20)); //动画使用开始
    },
    time: function (UTF) {//动画运行
        var _UTI, _UJT, _UST;
        if (UTF == true) { //普通计时器动画
            _UTI = 20 / this.ti;
            (this.ti <= 0) && (this.stop(), _UTI = null);
            this.cb(_UTI); this.ti -= 20;
        }
        else {//利用重绘动画使用
            _UTI = new Date(); //据偶去当前的时间
            _UJT = _UTI - this.sm;
            _UST = _UJT / this.ti;
            this.sm = _UTI; //时间的变化
            this.ti -= _UJT; //总时间的减少
            (this.ti <= 0) && (_UST = null, this.stop()); //调用停止函数
            (_UST !== 0) && (this.cb(_UST)); //结束的回调
            (_UST !== null) && (this.start()); //重复调用
        }
    },
    stop: function () {//动画结束
        (this.type[1] || window.clearInterval)(this.tm);
    }
}

/**
* 执行mouseout mouseover不冒泡情况
*
* @param  {element} 需要执行的元素 
*/
U.M.mouseLE = function (UCB) {
    if (!U.M.onmouseout(this)) { UCB(); }
}

/**
* mouseout||mouseover 冒泡解决
*
* @param  {element} 需要执行的元素 
* @return  {boolean} 是否是冒泡元素 
*/
U.M.onmouseout = function (UDOD) {
    if (event && "mouseover,mouseout".indexOf(event.type) > -1) { //判断事件源
        var _UDTD = (event.type == "mouseover" ? event.fromElement : event.toElement) || event.relatedTarget; //事件对象
        return U.M.EISE(UDOD, _UDTD); //判断是否在该元素下
    }
    return false;
}

/**
* resize变化处理 包含了resizestart endresize 由于resize会出发多次 所有这里可分为 start 和 end
*
* @param  {object} resize对象
*/
U.M.resize = function (UDE) {
    var _UGE = new U.M.resize.init(UDE); //初始化监视
    return U.M.apply(_UGE, _UGE.exec); //设置执行的方式
}

//resize方法函数
U.M.resize.init = function (UDE) {
    U.Ut.AddObj(this, this.u = UDE); //添加事件监视
}

//resize方法
U.M.resize.init.prototype = {
    exec: function () { //执行resize处理
        this.start(); //onresize回调处理
        (this.ti) && (clearTimeout(this.ti)); //取消end监视
        this.ti = setTimeout(U.M.apply(this, this.end), 0); //end处理 
        (U.Ut.isFunction(this.u)) && (this.u()); //end事件等待
    },
    start: function () {
        this.iss = true; //设置已经start
        (!this.iss && this.s) && (this.s()); //函数回调
    },
    end: function () {
        this.iss = false; //end结束
        (this.e) && (this.e()); //resizeend处理
    }
}

/**
* 阻止浏览器的默认行为，例如右键菜单，左键选择
*
*/
U.M.StopDefault = function () {
    var _UE = _UE || window.event; //获取window.event对象
    if (_UE) {
        if (document.all) { _UE.returnValue = false; } //IE中阻止函数器默认动作的方式 
        else { _UE.preventDefault(); } //阻止默认浏览器动作(W3C) 
        return false;
    }
}

/**
* 当你点击enter键时触发的函数
*
* @param  {object} resize对象
*/
U.M.returnkeylogin = function (UEL, UFN) {
    var i; //循环初始化
    if (event.keyCode == 13 || event.keyCode == 10) {
        if (UFN) {//执行函数
            U.M.apply(UEL || this, UFN)();
        }
        else if (UEL) {//元素触发使用
            for (i = 0; i < UEL.length; i++) {
                UEL[i]["obj"][UEL[i]["event"]]();
            }
        }
        U.M.StopDefault(); //阻止浏览器默认事件
    }
}

/**
* 自动触发HTMLElement事件 Mouse事件
*
* @param  {element} 触发的元素
* @param  {string} 事件类型
* @return  {object} resize对象
*/
U.M.IEVENT = function (UDOD, UTF) {
    if (UDOD.fireEvent) { return UDOD.fireEvent("on" + UTF, window.event); } //触发事件           //注销原事件源
    else if (document.createEvent) {
        var _UE = document.createEvent("MouseEvents"), _UEV = window.event;  //创建事件事件
        _UEV ? _UE.initMouseEvent(UTF, true, true, window, _UEV.detail, _UEV.screenX, _UEV.screenY, _UEV.clientX, _UEV.clientY, _UEV.ctrlKey, _UEV.altKey, _UEV.shiftKey,
        _UEV.metaKey, _UEV.button, _UEV.relatedTarget) : _UE.initMouseEvent(UTF, true, true, document.defaultView, 0, 0, 0, 0, 0, false, false, false, false, 0, UDOD); //初始化事件
        return UDOD.dispatchEvent(_UE);  //分发事件
    }
}

/**
* 自动触发HTMLElement Touch事件
*
* @param  {element} 触发的元素
* @param  {string} 事件类型
* @return  {object} resize对象
*/
U.M.TouchE = function (UDOD, UTF, UDE) {
    if (UDOD.fireEvent) { UDOD.fireEvent("on" + TF); } //ie事件触发处理
    else if (document.createEvent) { //h5事件处理
        var i, _USE,
        _UEV = UDE || window.event,
        _UE = TouchEvent ? new TouchEvent(UTF, _UEV) : document.createEvent("TouchEvent"), //创建一个touch时间的处理
        //获取当前touch事件
        _UTF = _UE.initTouchEvent ? "initTouchEvent" : "initEvent";
        //chrome
        _USE = [
        //chrome
                         [event.touches,
                            event.targetTouches,
                            event.changedTouches,
                            UTF,
                            event.view,
                            event.screenX,
                            event.screenY,
                            event.clientX,
                            event.clientY,
                            event.ctrlKey,
                            event.alrKey,
                            event.shiftKey,
                            event.metaKey],
        //safari
                          [UTF,
                                true,
                                event.cancelable,
                                event.view,
                                event.detail,
                                event.screenX,
                                event.screenY,
                                event.clientX,
                                event.clientY,
                                event.ctrlKey,
                                event.altKey,
                                event.shiftKey,
                                event.metaKey,
                                event.touches,
                                event.targetTouches,
                                event.changedTouches,
                                event.scale,
                                event.rotation
                                ],
        //firefox
                                    [UTF,
                                    true,
                                    event.cancelable,
                                    event.view,
                                    event.detail,
                                    event.ctrlKey,
                                    event.altKey,
                                    event.shiftKey,
                                    event.metaKey,
                                    event.touches,
                                    event.targetTouches,
                                    event.changedTouches],

            ];

        for (i = 0; i < _USE.length; i++) {
            try { _UE[_UTF].apply(_UE, _USE[i]); }
            catch (e) { }
            if (_UE.type == UTF) { break; }
        }

    }
    return UDOD.dispatchEvent(_UE); //分发事件
}

/**
* 注册函数事件 Internet Explorer 8 及更早IE版本不支持 addEventListener() 方法，，Opera 7.0 及 Opera 更早版本也不支持。 但是，对于这些不支持该函数的浏览器，你可以使用 attachEvent() 方法来添加事件句柄 
*
* @param  {string} 事件名称
* @param  {element} 添加事件的元素
* @param  {function} 事件触发后调用的函数
* @param  {string} 指定事件是否在捕获或冒泡阶段执行
*/
U.M.AddEvent = function (UTP, UDOD, UCB, UTF) {
    if (UDOD.addEventListener) { //非IE使用
        UDOD.addEventListener(UTP, UCB, UTF || false);
    }
    else if (UDOD.attachEvent) { //IE
        UDOD.attachEvent("on" + UTP, UCB);
    }
    else {//html5处理
        UDOD["on" + UTP] = U.M.apply(UDOD, [[UDOD["on" + UTP]], [UCB]]);
    }
}

/**
* 取消函数事件
*
* @param  {string} 事件名称
* @param  {element} 添加事件的元素
* @param  {function} 事件触发后调用的函数
* @param  {string} 指定事件是否在捕获或冒泡阶段执行
*/
U.M.ReEvent = function (UTP, UDOD, UCB, UTF) {
    if (UCB) {
        UCB = UCB[0] || UCB; //绑定函数默认
        if (UDOD.removeEventListener) { //非IE使用
            UDOD.removeEventListener(UTP, UCB, UTF || false);
        }
        else if (UDOD.detachEvent) {//IE使用
            UDOD.detachEvent("on" + UTP, UCB);
        }
        else { UDOD["on" + UTP] = null; } //非元素
    }
}

/**
* 对象转化成数组
*
* @param  {object} 需要转换成数组的对象
* @return  {string} 指定事件是否在捕获或冒泡阶段执行
*/
U.M.toArray = function (UDE) {
    try {
        return Array.prototype.slice.call(UDE);
    }
    catch (e) {
        var i = 0, _UCE = []; //循环创建
        for (; UDE[i]; i++) {
            _UCE.push(UDE[i]);
        }
        return _UCE;
    }
}

/**
* 屏调ie菜单
*
* @param  {object} 需要转换成数组的对象
*/
U.M.ShieldedRightAndSelect = function () {
    if (window.print) { //判断是否有右键菜单
        document.oncontextmenu = U.M.StopDefault; //阻止桌面右键默认菜单
        document.onselectstart = function () { //禁止元素选择文字
            var _UDOD = U.M.GetDE(event.srcElement), //获取一个可编辑元素
            _UTF = !(_UDOD && ((_UDOD.nodeType == 3 || (_UDOD.contentEditable == "true"))) || ((("textarea,input".indexOf(_UDOD.tagName.toLocaleLowerCase()) > -1))));
            (_UTF) && (U.M.StopBubble(), U.M.StopDefault());
            return (!_UTF);
        }
        var _UDE = function () {
            if (event.keyCode == 8) { //禁止后退网页
                if (U.M.GetDE((event.srcElement)) == document.body && !document.body.isContentEditable) { //不允许按下后台键
                    U.M.StopDefault();
                }
            }
            (U.M[event.type]) && (U.M[event.type]()); //判断是否具有事件处理
        };
        U.M.AddEvent("keydown", document, _UDE); //设置键盘事件处理
        U.M.AddEvent("keyup", document, _UDE); //设置键盘事件处理
    }
}

/**
* 统一处理函数,解决闭包添加事件的问题
* 使用apply，把事件与属性添加到对象上，而不是添加到window顶级对象。使用apply而不是call，是因为apply第二个参数可以传递参数数组，代码更少。
* 调用方法 U.M.apply(this,'执行函数的事件')  例如 U.M.apply(this,'this.style.display="none"');
*
* @param  {object} 将要绑定事件与属性的对象,如没有，可以传递null或者this，此处还需要优化，很多地方都会调用此函数，会导致速度降低。
* @param  {object} 时间和属性组成的参数数组。
*/
U.M.apply = function (retElement, UDE) {
    //retElement 将要绑定事件与属性的对象,如没有，可以传递null或者this，此处还需要优化，很多地方都会调用此函数，会导致速度降低。
    //UDE 时间和属性组成的参数数组
    return function () {
        if (UDE) {
            var i, //循环初始化
            j, //循环初始化
            _URE,
            _UAE,
            _UTE = (retElement) || this,
            _UME = Array.prototype.slice.apply(arguments); //arguments 转化成数组
            if (typeof UDE == "string") { _URE = (new Function(UDE)).apply(_UTE, _UME); }
            else if (typeof UDE == "function") { _URE = UDE.apply(_UTE, _UME); }
            else {
                for (i = 0; i < UDE.length; i++) {
                    if (UDE[i] && UDE[i][0]) { //函数存在
                        _UAE = UDE[i][1];
                        (!_UAE) && (_UAE = []);
                        (!U.Ut.isEvent(_UME[0]) || _UME.length > 1) && (_UAE = _UAE.concat(_UME)); //event == null ||
                        //循环添加至
                        for (j = 0; j < _UAE.length; j++) {
                            if (typeof _UAE[j] == "string") {
                                try {
                                    if (_UAE[j].indexOf("this") > -1 || _UAE[j].indexOf("retElement") > -1 || _UAE[j].indexOf("event") > -1) { _UAE[j] = eval("0,(" + _UAE[j] + ")"); } //制定参数解析
                                    else if (U.MS.Num.test(_UAE[j])) { _UAE[j] = Number(_UAE[j]); } //数字转化
                                } catch (e) { U.M.Console(e); }
                            }
                        }
                        try {
                            if (U.Ut.isString(UDE[i][0])) {
                                _URE = eval(UDE[i][0]).apply(_UTE, _UAE); //eval效率不高 特殊情况才用
                            }
                            else if (U.Ut.isFunction(UDE[i][0])) { _URE = UDE[i][0].apply(_UTE, _UAE); }
                        }
                        catch (e) { U.M.Console(e); } //函数执行错误
                    }
                }
            }

            return _URE;
        }
        //直接掉U.M.apply(),不传递UDE参数时，返回false。
        else { return false; }
    }
}

/**
* 图片错误处理
*
* @param  {element} 图片元素
* @param  {number} 判断的类型
*/
U.M.ImgError = function (UDOD, UTF) {
    var _UIE, //存放参数
    _UURL, //存放图片的src
    UDOD = UDOD && !UDOD.srcElement ? UDOD : (event ? event.srcElement || this : this); //获取出错的对象
    if (UDOD.src != "/img/error.png") { //如果是错误图片就不执行
        if (UTF == 2) { //重复请求图片 用于初始上传的图片
            _UURL = UDOD.src; //图片的路径
            _UIE = _UURL.indexOf("?&n="); //判断是否添加获取
            if (_UIE < 0 || _UURL.length - _UIE < 10) {
                UDOD.src += (_UIE == -1 ? "?&n=" : "") + 1; //添加缓存过滤
                return
            }
            else {
                UTF = 1;
            }
        }
        if (UTF == 1) { //错误图像处理
            $(UDOD).addAttrArray({ "src": "/img/error.png", "width": "111px", "height": "111px" });
        }
        else { //错误头像处理 
            UDOD.src = UTF || "/img/UserHead/UseHead.jpg";
        }
    }
}

/**
* 获取头像图片的正确地址
*
* @param  {string}  需要生成正常地址的 由于1473的地址 需要带上 http://fs.1473.cn 无需 这里同时处理了 1473和外链地址
* @return  {string} 过滤过的
*/
U.M.GetImgU = function (url) {
    return (!url ? "/img/UserHead/UseHead.jpg" : !url.indexOf("http") ? url : ((url.indexOf("www.1473.cn") > -1 ? url : US.fs + url.replace(new RegExp(US.fs, "gm"), ""))));
}

/**
* 判断是否支持播放
*
* @param  {string}  指定的格式
* @return  {number}  是否支持改格式播放
-----------[0] 不支持
-----------[1] 支持
*/
U.M.isPlay = function (UTP) {
    var _UDE = U.PL.vi(); //获取h5视频播放对象
    if (_UDE) {
        if (_UDE.isPlay(UTP, $$("video"))) {
            return 1;
        };
        return 0;
    }
    return _UDE;
}

/**
* 图片预加载方法
*
* @param  {string}  需要加载的图片地址
* @param  {function}  预加载回调函数
* @param  {function}  加载成功回调
* @param  {function}  错误处理回调
* @return  {element}  图片元素
*/
U.M.imgReady = function (url, URD, ULD, UE) {
    var _UW,
    _UH,
    _UNW, //image对象的width属性
    _UNH, //image对象的height属性
    _UIMG = new Image(); //image对象
    _UOR = function () { //预加载
        _UIMG = _UIMG || this;
        _UNW = _UIMG.width;
        _UNH = _UIMG.height; //获取加载图片的长宽
        if ((_UNW !== _UW || _UNH !== _UH) || _UNH !== 0) {
            (URD) && (URD.call(_UIMG));
            _UOR.end = true;
        }
    };
    $(_UIMG).addAttrArray({ "src": url,
        "onload": function () { //成功加载回调
            setTimeout(function () {
                !_UOR.end && _UOR(); (_UIMG) && (_UIMG.onload = _UIMG.onerror = null);
                (_UIMG && ULD) && (ULD.call(_UIMG));
                _UIMG = null;
            }, 0);
        },
        "onerror": function () { //错误图片处理
            if (U.M.IsNetwork()) {
                UE && UE.call(_UIMG);
            }
        }
    });
    if (_UIMG) { //说明图片还在加载中
        _UOR(); //执行预加载处理
        if (_UIMG.complete == true) { //判断是否已经成功加载过了 缓存图片处理
            _UIMG.onload(); return;
        }
    }
    if (!_UOR.end) { //添加进入图片大小加载事件
        U.M.imgReady._UL.push(_UOR);
        if (U.M.imgReady._UIT == null) {
            U.M.imgReady._UIT = setInterval(U.M.imgReady._URT, 40); //每40毫秒进入
        }
    }
    return _UIMG;
}

U.M.imgReady._UIT; //计时器初始化
U.M.imgReady._UL = []; //需要预加载的图片集

//去除预加载计时
U.M.imgReady._US = function () {
    clearInterval(U.M.imgReady._UIT);
    U.M.imgReady._UIT = null;
};

//计时加载逐个加载处理
U.M.imgReady._URT = function () {
    for (var i = 0; i < U.M.imgReady._UL.length; i++) {
        U.M.imgReady._UL[i].end ? U.M.imgReady._UL.splice(i--, 1) : U.M.imgReady._UL[i]();
    }
    !U.M.imgReady._UL.length && U.M.imgReady._US();
}

/**
* 滚动条滚动到制定的位置
*
* @param  {string}  指定scrollTop的数值
* @param  {function}  需要调整滚动条位置的对象
* @param  {function}  加载成功回调
* @return  {element}  图片元素
*/
U.M.SCT = function (UT, UDOD, UTF) {
    var _UTP = U.Ut.isNumber(UT); //判断UT是否是数字true 或者 false
    if (_UTP && UTF) {
        $(UDOD).animate({ "scrollTop": UT }, UTF);
    } //动画移动具体的位置
    else {
        if (typeof UT == "number") {
            UDOD.scrollTop = UT;
        }
        else { UT.scrollIntoView(); }
    } //直接移动过
}

/**
* 获取url参数
*
* @param  {string}  QueryString key
* @param  {string}  QueryString 默认为window.document.location.search ，可以自己选择字符串进行拆分
* @return  {string}  获取key对应的值
*/
U.M.QueryString = function (UK, USE) {
    //UK 获取url的key
    var i, //循环初始化
    j, //循环初始化
    _UV, //储存值的数组
    _USV = "", //作为返回值
    _USE = (USE || window.document.location.search).substr(1), //获取传参
    _UTV = _USE.split("&"); //生成传参数组
    if (!UK) { //判断是否传入key
        return _UTV;
    }
    for (i = 0; i < _UTV.length; i++) { //循环传参数组获取值
        _UV = _UTV[i].split("=");
        if (_UV[0].toUpperCase() == UK.toUpperCase()) { //判断key是否相等
            for (j = 1; j < _UV.length; j++) { //返回值
                _USV += _UV[j] + (j == _UV.length - 1 ? "" : "=");
            }
            break;
        }
    }
    return _USV;
}

/**
* 获取用户获取的地址
*
*/
U.M.GetUF = function () {
    var _UURL = document.location.hash; //地址传参
    return _UURL.split("/");
}

/**
* 页面活动监视,当用户离开页面休息时，停止页面活动（计时器）
*
* @param  {function} 页面聚焦回调函数
* @param  {function} 页面非聚焦回调函数
* @return  {string}  获取key对应的值
*/
U.M.IsActivity = function (UOE, UTE) {
    if (UOE) {
        //鼠标在当前body上 说明现在是活动 \(\[(\s*[a-z]+\s*(,\s*[a-z]+\s*)*)\]\) \({\[+[\w]+\]}\)
        $(document.body).mouseenter(U.M.apply(null, [[U.M.IsActivity.UFC, [UOE]]]));
        U.M.AddEvent("focusin", document, U.M.apply(null, [[U.M.IsActivity.UFC, [UOE]]])); //页面聚焦同时为活动页面
    }
    if (UTE) {
        U.M.AddEvent("focusout", document, U.M.apply(null, [[U.M.IsActivity.UBC, [UTE]]])); //页面休眠中
    }
}

U.M.IsActivity.UTF; //页面变化变量

/**
* 页面活动监视
*
* @param  {function} 页面聚焦回调函数
*/
U.M.IsActivity.UFC = function (UCB) {
    (!U.M.IsActivity.UTF) && (U.M.IsActivity.UTF = true, UCB());
}

/**
* 离开页面休眠
*
* @param  {function} 页面非聚焦回调函数
*/
U.M.IsActivity.UBC = function (UCB) {
    var _UDTD,
    _UX = event.clientX,  //页面x坐标
    _UY = event.clientY; //获取event对象的y坐标
    if ((!browser.msie || ((_UX < 0 || _UX > US.Width || _UY < 0 || _UY > US.Height))) && U.M.IsActivity.UTF) { //判断鼠标不在页面中
        U.M.IsActivity.UTF = false;
        UCB();
    }
}

/**
* cookie解决方案
*
*/
U.M.Cookies = {};

/**
*在iframe中调用此函数，会把主页的cookie传递到子域， 跨域加载cookie，1473子域用，其他跨域不能用,为了兼容ie6，ie7，暂时未用。
*
* @param  {string} 跨域的url
* @param  {function} 成功记载后的回调函数
*/
U.M.Cookies.crossdomain = function (url, cb) {
    U.MD.DynamicLoad(url, "js", cb, null, true);
    //U.MD.DynamicLoad("/uform.js", "js", cb, null, true);
}


/**
*1473cookie格式专用
* 把形如："userid=72854d28-f45c-48d7-92b7-3cd933e03022&username=13928417148&Loginid=fd02976d-993b-4437-bbd9-5efa99802c8f&UserStamp=1364812396"的cookie转换为json对象。函数名有问题。
得到的形式为：_UAE.Loginid可得到用户id。
*
* @param  {string} 获取cookie的key对应的值 如usestudio=aa=ff&ss=aa 的usestudio里的 aa=ff&ss=aa
* @return  {object} {key：[value1,value2]}
*/
U.M.Cookies.getarray = function (key) { //获取cookie
    var i, //循环初始化
    _UAE = {}, //初始化对象 作为返回值
    _UCE = U.M.GetCookie("usestudiosso"); //获取用户指定的Cookie值
    if (_UCE) { //是否存在
        _UCE = _UCE.split("&");
        for (i = 0; i < _UCE.length; i++) { //循环对应的值
            _UCE[i] = _UCE[i].split("="); //切分key和value
            //如果定义了cookie值的接受数组，则不再重复定义。_UCE[i][0]相当于key，例如userid
            if (!_UAE[_UCE[i][0]]) {
                _UAE[_UCE[i][0]] = [];
            }
            _UAE[_UCE[i][0]].push(decodeURIComponent(_UCE[i][1])); //生成{key：[value1,value2]}
        }
    }
    return _UAE;
}

/**
* 设置cookie
*
* @param  {string || object} cookie 字符串或者cookie集合。参见例一，例三。
* 
* @param  {object} cookie 的key
----------path: null, //cookie地址
----------domain: null, //cookie域
----------expires: 365, //cookie过期时间
----------secure: null //cookie来源
* @return  {string}
*例一：U.M.Cookies.set("usestudiossso=UserId=aa&UserName=zhangsan");net java模式
*例二：U.M.Cookies.set("15hulianwang=userid=123456&username=zhangsan");net java模式
*例三：U.M.Cookies.set({15hulianwang:{userid:123456,username:'zhangsan'}});nodejs模式
*/
U.M.Cookies.set = function (UKE, UDE) {
    var i, //循环初始化
    j, //循环初始化
    k = 0, //用于计数
    _UST = ""; //最终的cookie字符串
    //如果UKE是字符串，则直接设置cookie，如果为集合，则转换为字符串进行处理。
    if (U.Ut.isString(UKE)) {//判断设置的是否是字符串 
        _UST = UKE; document.cookie = this.setpn(UDE, _UST); //直接设置
    }
    //以下没有检验，用于nodejs的集合类cookie
    else {
        for (i in UKE) {
            _UST = i + "=";
            for (j in UKE[i]) {
                //把集合拆分成字符串。
                //如果k>0，则添加&号分割符
                if (k > 0) {
                    _UST += "&";
                }
                _UST += j + "=" + encodeURIComponent(UKE[i][j]);
                k++;
            }
            //
            document.cookie = this.setpn(UDE, _UST);
        }
    }
    return (document.cookie);
}

/**
* 设置指定参数(添加)
*
* @param  {object} cookie 的key
----------path: null, //cookie地址
----------domain: null, //cookie域
----------expires: 365, //cookie过期时间
----------secure: null //cookie来源
* @param  {string} 需要写入的cookie usestudio=aa=cc
* @return  {string} 返回写入的cookie值
*/
U.M.Cookies.setpn = function (UDE, UST) {
    var _UCE = {
        path: "/", //cookie地址
        domain: document.domain, //cookie域
        expires: 365, //cookie过期时间
        secure: null //cookie来源
    };
    //一般不传递第二个参数，这里为空会报错，所以转换为集合
    UDE = UDE || {};
    for (i in _UCE) { //循环设置
        //不去找原型，直接找_UCE中定义的变量和方法
        if (i == "expires" && (UDE[i] || _UCE[i])) { //时间过期处理
            _UKE = new Date();
            //如果用户设置了时间，则用用户的时间，否则默认过期时间为一年
            var _etime = (UDE[i] || _UCE[i]) * 24 * 60 * 60 * 1000;
            _UKE.setTime(_UKE.getTime() + _etime); //时间变化处理
            UDE[i] = _UKE.toUTCString();
        }
        //判断是否设置cookie属性，如果用户不设置，系统默认为null，则不设置，例如secure: null 
        if (UDE[i] || _UCE[i]) {
            var _pj;
            //如果用户设置属性为null，则用系统的，否则用用户设置的属性
            if (UDE[i] == null) {
                _pj = _UCE[i];
            }
            else {
                _pj = UDE[i];
            }
            //拼接cookie。
            UST += "; " + i + "=" + _pj; //添加cookie
        }
    };
    return UST; //返回cookie
}

/**
* 移除cookie(删除)
*
* @param  {string} cookie 的key
* @return  {string}
*/
U.M.Cookies.del = function (key) {
    var i, _UAE, _UST = "",
    _UCE = document.cookie.split("; "); //cookie值
    //过滤指定的cookie值
    for (i = 0; i < _UCE.length; i++) {
        _UAE = _UCE[i].split("=");
        //如果符合用户传递的cookie的key值，则转换为字符串
        if (!key || _UAE[0] == key) {
            //多cookie情况下，用分号分割，否则不分割
            var _cut = _UST.length ? "; " : "";
            _UST += _cut + _UAE[0] + "=";
        }
    }
    //删除指定的cookie
    if (_UST) {
        U.M.Cookies.set(_UST, { expires: -1 });
    }
    else {
        console.log("not found cookie!");
    }
}

/**
* 功能：获取用户指定的Cookie值
描述：浏览器cookie形如："pgv_pvid=3156364456; usestudiosso=userid=72854d28-f45c-48d7-92b7-3cd933e03022&username=13928417148&Loginid=fd02976d-993b-4437-bbd9-5efa99802c8f&UserStamp=1364812396; __qc_wId=563; amvid=319501000bca68c1adab006842344f44"
第一步：根据分号拆分成数组.
第二部：按照"="拆分
第三部：找到"usestudiosso",usestudiosso=userid=72854d28-f45c-48d7-92b7-3cd933e03022&username=13928417148&Loginid=fd02976d-993b-4437-bbd9-5efa99802c8f&UserStamp=1364812396
第四步：去掉"usestudiosso",得到userid=72854d28-f45c-48d7-92b7-3cd933e03022&username=13928417148&Loginid=fd02976d-993b-4437-bbd9-5efa99802c8f&UserStamp=1364812396
参数一：UKY为cookie名字,云端cookie名为："usestudiosso"
*
* @param  {string} 获取cookie的key对应的值 如usestudio=aa=ff&ss=aa 的usestudio里的 aa=ff&ss=aa
* @param  {string} aa=ff&ss=aa里面的aa对应的值 [ff]
* @return  {string, array} 上述参数里说明返回 
---------第二个参数不存在的时候返回string
---------第二个参数存在的时候返回array
*/
U.M.GetCookie = U.M.Cookies.get = function (UKY, UKN) {
    var i, //循环初始化
    _UAT, //储存字符串的数组
    _UTV = "",
    _UCK = (document.cookie || document.wincookie || "").split("; "); //从cookie中获取指定的cookie集
    for (i = 0; i < _UCK.length; i++) {
        _UAT = _UCK[i].split("=");
        //如果找到名为"usestudiosso"的cookie，则
        if (_UAT[0] == UKY) {
            _UAT.splice(0, 1);
            _UTV = _UAT.join("=");
            break;
        } //生成指定的Cookie
    }
    if (UKN) {//从指定的cookie集里获取cookie值
        _UCK = _UTV.split("&");
        _UTV = [];
        for (i = 0; i < _UCK.length; i++) {
            _UAT = _UCK[i].split("=");
            if (_UAT[0] == UKN) { _UTV.push(decodeURIComponent(_UAT[1])); } //获取指定的cookie值
            else if (_UAT[1] == UKN) { return true; } //判断是否是指定的cookie存在
        }
    }
    return (_UTV.length ? _UTV : false);
}

/**
* 判断Url是否合法
*
* @param  {string} url值
* @return  {boolean} 是否盒饭的url
*/
U.M.IsUrl = function (url) {
    if (U.Ut.isString(url)) {
        var _UDAD, //新建a标签
        _UTF = false; //boolean值
        url = ((url.indexOf("://") > 0 ? "" : "http://") + url);
        if (U.MS.Url.test(url)) { //正则判断是否是有效的url
            _UDAD = $$("a", { "href": url });
            _UTF = _UDAD.href ? url : false; //a标签判断 indexOf(url) == 0
        }
        return _UTF;
    }
}

/**
* 获取url
*
* @param  {string} url值
* @return  {object} 返回url对象
----------[host] 返回域的地址
----------[search] 返回search
*/
U.M.getUrl = function (url) {
    //UURL url
    var _UDAD = $$("a", { "href": url }); //新建a标签
    return { "host": _UDAD.href.replace(_UDAD.search, ""), "search": _UDAD.search };
}

/**
* iframe写入数据
*
* @param  {element} iframe
* @param  {string} 写入iframe的值
* @param  {function} 成功的回调函数
* @return  {element} 返回iframe
*/
U.M.IFO = function (UIF, UHT, UCB) {
    U.MD.IframeLoad(UIF, [[U.M.AsynIFO, [UIF, UHT, UCB]]]); //设置回调
    UIF.src = "javascript:void((function(){document.open();document.domain='" + document.domain + "';document.close()})())"; //添加链接 "about:blank";
    return UIF;
}

/**
* iframe异步处理
*
* @param  {element} iframe
* @param  {string} 写入iframe的值
* @param  {function} 成功的回调函数
*/
U.M.AsynIFO = function (UIF, UHT, UCB) {
    (UHT) && (UIF.contentWindow.document.body.innerHTML = UHT);
    (UCB) && (U.M.apply(UIF, UCB)()); //回调 
}

/**
* ajax中文加密
*
* @param  {array} 需要加密的字符串数组 这个为url加密
* @return  {array} 返回加密成功的url数组
*/
U.M.SplitArray = function (UDE) {
    var i; //循环初始化
    for (i = 0; i < UDE.length; i++) {
        UDE[i] = encodeURIComponent(encodeURIComponent(UDE[i]));
    }
    return UDE.join(",");
}

/**
* 文字复制
*
* @param  {string} 需要复制的元素
*/
U.M.Copy = function (UTH) {
    if (window.clipboardData) { //ie
        window.clipboardData.setData("text", UTH);
    }
    else if (event && event.clipboardData) {//html5兼容
        event.clipboardData.setData("text/HTML", UTH);
    }
    else if (event && event.originalEvent && event.originalEvent.clipboardData) { //firfox兼容
        event.originalEvent.clipboardData("Text", UTH);
    }
    else if (document.execCommand) { //基本全兼容除了手机端的safari
        document.execCommand("copy");
    }
    else {
        U.Alert("请手动选择复制");
    }
}

/**
* 文字粘贴
*
* @param  {string} 需要复制的元素
*/
U.M.UrlPaste = function () {
    if (window.clipboardData) { //ie
        return window.clipboardData.getData("text");
    }
    else if (event.clipboardData) { //html5
        return event.clipboardData.getData("text/HTML");
    }
    else if (event && event.originalEvent && event.originalEvent.clipboardData) { //firfox兼容
        return event.originalEvent.clipboardData("Text")
    }
    else if (document.execCommand) {//基本全兼容除了手机端的safari
        document.execCommand("paste");
    }
    else {
        U.Alert("无法粘贴");
    }

    //http://static.zhihu.com/static/js/v2/ui/editor_plugin_code.js

    /*
    var _ = this.getStateTuple(), state = _.state, range = _.range, code = _.code
    if (state !== Plugin.State.EDITABLE) return

    var text, textType = 'text/plain'
    var clipboard = e.getBrowserEvent().clipboardData
    if (clipboard) { // w3c(webkit,opera...)
    if (clipboard.types && goog.array.contains(clipboard.types, textType)) {
    e.preventDefault()
    text = clipboard.getData(textType)
    this.replaceText(range, text)
    }
    } else if (window.clipboardData) { // IE
    text = window.clipboardData.getData('Text')
    if (text) {
    e.preventDefault()
    this.replaceTextIE(range, text)
    }
    } else { // FF
    // TODO：rewrite
    var offset = range.getStartOffset()
    var selectedLength = range.getText().length
    var codeLength = function () {
    return code.firstChild ? goog.editor.node.getLength(code.firstChild) : 0
    }
    var endLength = codeLength() - offset - selectedLength
    setTimeout(function () {
    Plugin.cleanup(code)
    var caretOffset = codeLength() - endLength
    if (code.firstChild) {
    goog.dom.Range.createCaret(code.firstChild, Math.max(offset, caretOffset)).select()
    }
    })
    }

    */


}

/**
* 右键菜单定位
*
* @param  {string} 需要定位的右键菜单
*/
U.M.RLocate = function (UDOD) {
    //UDOD 需要定位的元素
    var _UDPD = U.M.TOSP(UDOD), //获取元素offsetParent
    _UEV = U.M.GetMousep(_UDPD), //当前鼠标位置
    _UW = [UDOD.offsetWidth, _UDPD.offsetWidth], //记录UUOD的offsetWidth属性
    _UH = [UDOD.offsetHeight, _UDPD.offsetHeight]; //记录UUOD的offsetHeight属性
    _UEV["X"] = ((_UW[0] + _UEV["X"]) > _UW[1]) ? _UEV["X"] - _UW[0] : _UEV["X"]; //设置top最大范围
    _UEV["Y"] = ((_UH[0] + _UEV["Y"]) > _UH[1]) ? _UEV["Y"] - _UH[0] : _UEV["Y"]; //设置left最大范围
    $(UDOD).addAttrArray({ "style": { "cssText": "top:" + _UEV["Y"] + "px;left:" + _UEV["X"] + "px"} }); //右键菜单的位置
}


/**
* 冒泡排序法的封装
*
* @param  {array} 排序数组
* @param  {string} 排序类型
* @param  {function} 判断执行函数
* @param  {number} 是否是升序降序
----------[-1] 升序
----------[1] 降序
*/
U.M.Sequence = function (UDE, UTP, UCB, UIE) {
    (UDE) && (UDE.sort(function (UO, UT) {
        return ((UCB(UO[UTP], UT[UTP]) ? -1 : 1) * (UIE || 1));
    }));
}

//判断是否支持svg
U.M.isSupportSvg = function () {
    return !!(document.createElementNS && document.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGRect);
}

/**
*浮点数运算函数
JavaScript浮点运算的一个bug。 比如：7*0.8 JavaScript算出来就是：5.6000000000000005
* 数字计算 解决浮点的bug
*
* @param  {number} 数字1
* @param  {number} 数字2
* @param  {string} 连系符号 + - * /
*/
U.M.floatOperate = function (number1, number2, operator) {
    var i, //循环初始化
    _pow, ////用于存放数据的变量
    _strArr = [String(number1), String(number2)]; //用于存放数据的数组
    for (i = 0; i < 2; i++) {
        _strArr[i + 2] = _strArr[i].length - _strArr[i].indexOf(".") - 1;
    }
    _pow = Math.pow(10, Math.max(_strArr[2], _strArr[3]));
    return (eval("0," + _strArr[0] * _pow + operator + _strArr[1] * _pow)) / _pow;
}

/**
* 获取对象类型
*
* @param  {object} 需要判断的对象
* @return  {string} Number,String,Array,Object,Symbol
*/
U.M.GetType = function (UDOD) {
    //UDO D需要判定类型的变量
    if (UDOD) {
        try {
            var _UCE = UDOD.constructor; //求元素的构造函数。
            //把构造函数按照字符串格式输出，结果形如："function String() { [native code] }"。对结果执行执行字符串匹配，得到结果数组，判断结果数组中是否包含"String"，得出类型。
            var _UDE = (_UCE || UDOD).toString().match(_UCE ? /function\s*(\w+)/ : /\[object (.*?)\]/);
            if (_UDE && _UDE.length == 2) {
                return _UDE[1].toLowerCase();
            }
            else {
                return typeof UDOD;
            }
        } catch (e) { }
    }
}

/**
* 把json字符串转化成使用对象
*
* @param  {string} 需要判断的对象
* @return  {object} 返回成功过生成后的对象 支持无线树
*/
U.M.toList = function (UDE) {
    //UDE json字符串
    var i; //循环初始化
    (U.Ut.isString(UDE)) && (UDE = UDE.parseJSON()); //转化成Json
    if (U.Ut.isArray(UDE)) { //设置数组  
        for (i = 0; i < UDE.length; i++) {
            (U.Ut.isString(UDE[i])) && (UDE[i] = UDE[i].parseJSON());
            U.Ut.isArray(UDE[i]) && (U.M.toList(UDE[i]));
        }
    }
    return UDE;
}

/**
* 返回制定的对象类型名
*
* @param  {object} 需要判断的对象
* @return  {string} 返回object转化后的的
*/
U.M.objectToString = function (UDE) {
    return Object.prototype.toString.call(UDE);
}

/**
* 判断浏览器是否联网
*
* @param  {function} 需要判断的对象
* @return  {boolean} 是否联网
*/
U.M.IsNetwork = function (UCB) {
    //UCB 回调函数 暂未使用
    var i, //循环初始化
    j, //循环初始化
    _UOE = [window, document.body], //存放数据的数组
    _UDE = ["offline", "online"]; //存放数据的数组
    if (UCB) {
        for (i = 0; i < _UOE.length; i++) {
            for (j = 0; j < _UDE.length; j++) {
                U.M.AddEvent(_UDE[j], _UOE[i], U.M.apply(this, [[U.M.StopBubble], [UCB, [j]]]));
            }
        }
    }
    return navigator.onLine;
}

/**
* 错误函数控制台处理,,
*
* @param  {string} 输入控制台的类型 默认log
* @return  {object} 输出控制台的值
*/
U.M.Console = function (err) {
    try {
        console.log(err);
    } catch (e) { }
}

/**
* 滚动到底部处理
*
* @param  {object} 滚动值
----------[AF] 回调函数
* @return  {object} 滚动对象
*/
U.M.SSCH = function (UDE) {
    //UDE 对象
    return new U.M.SSCH.init(UDE);
}

U.M.SSCH.init = function (UDE) {//滚动方法执行
    this.UDOD; //滚动元素
    this.CT; //处理多次处理 用来设置 srcollend函数
    this.P = 0; //最底部的次数
    this.UTF = true;
    this.Top = UDE["Top"]; //是否为顶部
    this.UCB = UDE["AF"]; //回调函数
}

U.M.SSCH.init.prototype = {
    /**
    * 滚动初始使用
    *
    * @param  {object} 滚动对象 原对象的this
    */
    SZX: function (UTE) {
        UTE.UDOD = this; //滚动对象
        clearTimeout(this.CT);
        this.CT = setTimeout(U.M.apply(UTE, [[UTE.ZSCH]]), 0); //滚动开始
    },
    //获取方法
    SCH: function () {
        return U.M.apply(null, [[this.SZX, [this]]]); //滚动执行
    },
    /**
    * 滚动处理
    *
    * @param  {object} 滚动对象 原对象的this
    */
    ZSCH: function () {//执行
        var _UDOD = this.UDOD, //滚动掉元素
        _UT = _UDOD.scrollTop || document.documentElement.scrollTop; //当前滚动高度
        if (this.Top != null) {
            if (this.Top == _UT) { //滚动大小是否到底部判断
                (this.UCB) && (this.UCB.call(this));
                this.P++;
            }
        }
        else {
            if (_UT + _UDOD.offsetHeight >= _UDOD.scrollHeight - 2) { //滚动大小是否到底部判断
                (this.UCB) && (this.UCB.call(this));
                this.P++;
            }
        }
    }
}

/**
* html加载，存储一篇文章，javascritp可以放在任何地方，当把文章追加到div等元素中时，由于没有刷新，导致javascript不能执行。需要把javascript重新移动到head头部才会加载。
*
* @param  {element} 任何html元素 
* @param  {string} 文章内容 
@return  返回文章内容
*/
U.M.loadHtml = function (UDOD, UTH) {
    if (UTH != null) {
        UDOD.innerHTML = UTH;
    }
    // UDOD.innerHTML += "";
    var i, //循环初始化
    _UDHD = $("head")[0],
    _UDE = $("script", UDOD); //获取script标签
    for (i = 0; i < _UDE.length; i++) {
        if (_UDE[i].src == "/uform.js") {
            U.MD.DynamicLoad(_UDE[i].src, "js");
        }
        else {
            $$("script", { "type": _UDE[i].type, "src": _UDE[i].src }, UDOD, _UDE[i]).text = _UDE[i].text;
        }
    }
    return UTH;
}


/**
* 获取文字简写
*
* @param  {element、 string} 传入的对象或者文字
* @param  {number} 截图的长度
* @param  {string} 后缀的添加
*/
U.M.Shorttext = function (UDOD, UL, UST) {
    UDOD = U.Ut.isString(UDOD) ? $$("div", { "innerHTML": UDOD }) : UDOD; //截取的对象
    UL = UL || 200; //截取的长度
    UST = UST || ""; //省略号
    return UDOD.innerText.substring(0, UL) + (UDOD.innerText.length > 200 ? UST : "") + $("img", UDOD).outerHTML;
}

/**
* 随机产生一个函数 调用后销毁 类似委托
解决跨域问题，以及ajax多个请求，多份实例的问题。
*
* @param  {array} 滚动对象 原对象的this
----------[0] 回调函数
----------[.....] 传送的参数
* @return  {object} 委托对象
*/
U.M.getFun = function () {
    if (arguments.length) {
        return new U.M.getFun.init(arguments);
    }
    else {
        throw new Error("cb is null");
    }
}

/**
*上述函数的初始化函数
*
* @param  {object} 滚动对象 原对象的this
*/
U.M.getFun.init = function (UDE) { //初始化对象保存
    UDE = Array.prototype.slice.call(UDE); //转化成数组
    U.Ut.AddObj(this, { //参数
        cb: UDE[0], //回调函数
        id: "a" + Guid.guidNoDash(), //唯一识别id
        isremove: true, //是否移除
        parame: UDE.slice(1) //传参
    });
    window[this.id] = U.M.apply(this, [[this.Invoke, this.parame]]); //设置唯一识别函数使用
}

U.M.getFun.init.prototype = {
    set: function (UDE) { //设置传参
        var i; //遍历初始化
        for (i in UDE) {
            (UDE.hasOwnProperty(i)) && (this[i] = UDE[i]);
        }
        return this;
    },
    toString: function () { //返回对象
        return this.id;
    },
    //执行 同时销毁对象
    Invoke: function () {
        try {
            if (U.Ut.isFunction(this.cb)) { //判断是否有回调函数
                this.cb.apply(this, arguments);
            }
            if (this.isremove) { //是否移除对象
                window[this.getId()] = null; //设置对象移除
                delete window[this.getId()]; //清理对象
                delete this;
            }
        } catch (e) { }
    },
    //获取ID
    getId: function () {
        return this.id;
    }

};

/**
* HTML模版页面 支持js内置 类似于js上的php ejs
*
* @param  {element} 需要变化的元素
* @param  {object} 传参对象
*/
U.M.Simulation = function (UDOD, UDE) {
    new U.M.Simulation.init(UDOD, UDE).exec();
}

/**
* 初始化HTML模版页面 支持js内置 类似于js上的php ejs
*
* @param  {element} 需要变化的元素
* @param  {object} 传参对象
*/
U.M.Simulation.init = function (UDOD, UDE) {
    this.el = UDOD; //
    U.Ut.AddObj(this, UDE);
    return this;
}

U.M.Simulation.init.prototype = {
    //正则配置
    config: { m: /^\\<{+([\s\S])+\\}>$/, //  /\+=([\s\S])+?\+$/g
        zs: "+=", ze: "+", c: /\\/g,
        d: /(?=["])/g, s: "<{", e: "}>",
        f: "%",
        t: "([\\s\\S])*?"
    },
    //执行
    exec: function () {
        try {
            var i, _UCS = "",
            _UPE = [],
            _UT = this,
            _UKE = this.key,
            _UCE = this.config,
            _USE = (this.el.innerHTML || this.el).trim(" ").replace(_UCE.c, "\\\\").replace(_UCE.d, "\\").replace(this.getConfig("\\\\", "", "", "\\\\"),
            function (UST) { //配置输出查看 
                return UST.replace("\\" + _UCE.s, _UCE.s.replaceHtmlSign()).replace("\\" + _UCE.e, _UCE.e.replaceHtmlSign());
            });

            //函数匹配区域
            _USE = _USE.replace(this.getConfig("", "", _UCE.f), function (UST) {
                return UST.replace(_UCE.s + _UCE.f, "\";").replace(_UCE.e, ";uhtml+=\"");
            });

            _USE = _USE.replace(this.getConfig(), function (UST) {
                return "\"+" + ((UST.replace(_UCE.s, "").replace(_UCE.e, "").replace(_UT.re("\\" + _UCE.zs + _UCE.t + "\\" + _UCE.ze),
                function (UST) {
                    return UST.replace(_UCE.zs, "").replace(_UCE.ze, "").replaceHtmlSign();
                })) || "\"\"") + "+\"";
            }); //配置html输出区域
            _USE = 'var uhtml="' + _USE + '"; return uhtml;';

            //变量传参
            if (_UKE) {
                for (i in _UKE) {
                    (_UKE.hasOwnProperty(i)) && (_UCS += (_UCS ? "," : "") + i, _UPE.push(_UKE[i]));
                }
            };
            _USE = Function(_UCS, _USE).apply(this.that || this, _UPE); //利用函数执行回调处理
            (this.cb) && (this.cb(_USE)); //获取模版回调
        }
        catch (e) { throw new Error(e); }
    },
    /**
    * 获取正则
    *
    * @param  {string} 正则字符串
    */
    re: function (URE) {
        return new RegExp(URE, "g");
    },
    /**
    * 初始化HTML模版页面 支持js内置 类似于js上的php ejs
    *
    * @param  {string} 正则开头
    * @param  {string} 正则结束
    * @param  {string} 正则中间的内容
    * @param  {string} 正则结束的内容
    * @return  {string} 正则内容
    */
    getConfig: function (US, UE, UOS, UOE) { //获取系统配置
        var _UCE = this.config;
        return this.re((US || "") + _UCE.s + (UOS || "") + _UCE.t + (UOE || "") + _UCE.e + (UE || ""));
    },
    getHtml: function () { //获取生成的html代码

    },
    /**
    * 正则对象
    *
    * @param  {object} 正则设置
    */
    set: function (UDE) { //设置config
        var i, _UCE = this.config;
        for (i in _UCE) {
            (UDE.hasOwnProperty(i)) && (UDE[i] = _UCE[i]);
        }
        return this;
    }
}