/*
此函数区域用于常用的通用函数 如位置 大小 计时器等
*/
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;
}
}