fontend-app/lib/js/app.js

(function(owner) {
	//c2c微服务访问url前缀
	owner.C2CUrl = "http://www.zhixinchains.com/otc/";
	//币币微服务
	owner.CCTUrl = "http://www.zhixinchains.com/cct/";
	//user微服务访问url前缀
	owner.walletFileUrl = "http://www.zhixinchains.com/files/";
	owner.confBaseUrl = "http://www.zhixinchains.com/sysconf/";
	owner.currencyBaseUrl = "http://www.zhixinchains.com/currency/";
	//	 本地user地址
	owner.UserUrl = "http://www.zhixinchains.com/user/";
	owner.walletBaseUrl = "http://www.zhixinchains.com/user/";
	// 本地登录地址
	owner.loginBaseUrl = "http://www.zhixinchains.com/user/";
	// ########钱包模块的服务器#######
	owner.btcBaseUrl = "http://www.zhixinchains.com/btc/";
	owner.ethBaseUrl = "http://www.zhixinchains.com/eth/";
	owner.eosBaseUrl = "http://www.zhixinchains.com/eos/";

	// 本地user地址
    // 极光聊天本地地址
    owner.Host_jm = "http://www.zhixinchains.com/imjg/"
	//    	owner.UserUrl = "http://192.168.105.82:10121/";
	//	// 本地登录地址
	//	owner.loginBaseUrl = "http://192.168.105.52:8101/";
	//	// ########钱包模块的服务器#######
	//	owner.btcBaseUrl = "http://192.168.105.52:8301/";
	//	owner.ethBaseUrl = "http://192.168.105.52:8201/";
	//	owner.eosBaseUrl = "http://192.168.105.52:8401/";

	//自选行情
	owner.marketChoiceKey = "$market-choice";

	//默认打开页面方式
	owner.aniShow = "pop-in";

	//已经预加载的页面
	owner.preate = {};

	//预加载页面过期时间(ms)
	owner.preateTimeout = 1000 * 60 * 5;

	//	//预加载倒计时列表
	//	owner.timeouts = {};

	//避免快速点击打开多个页面
	owner.openw = null;

	/**
	 * 存储数据到本地
	 * @param {String} key : 数据标识
	 * @param {Object} values : 数据
	 */
	owner.setLocalStorage = function(key, values) {
		values = values || {};
		if(typeof values == 'object') {
			localStorage.setItem(key, JSON.stringify(values));
		} else {
			localStorage.setItem(key, values);
		}
	}

	/**
	 * 获取本地存储数据
	 * @param {String} key : 数据标识
	 */
	owner.getLocalStorage = function(key) {
		var settingsText = localStorage.getItem(key) || "{}";
		return JSON.parse(settingsText);
	}

	/**
	 * 根据key值删除存储数据
	 * @param {Object} key
	 */
	owner.removeLocalStorage = function(key) {
		localStorage.removeItem(key);
	}

	/**
	 * 不合法数据格式化
	 * @param {String} val
	 */
	owner.escapeString = function(val) {
		if(val) {
			val = val.replace(/\\/g, "\\\\");
			val = val.replace(/\"/g, "\\\"");
			val = val.replace(/\?/g, "？");
			val = val.replace(/\n|\r|\t/g, function() {
				var a = arguments[0];
				return(a == '\n') ? '\\n' : (a == '\r') ? '\\r' :
					(a == '\t') ? '\\t' : ""
			});
		}
		return val;
	}

	/**
	 * 不合法数据格式化
	 * @param {String} val
	 */
	owner.escapeValue = function(val) {
		if(val) {
			if($.isArray(val)) { // 数组类型
				for(var i = 0, len = val.length; i < len; i++) {
					var value = val[i];
					if(typeof value == 'string') {
						val[i] = owner.escapeString(value); // 设置新值
					}
				}
			} else if(typeof val == 'string') { // 字符类型
				val = owner.escapeString(val); // 设置新值
			} // 其他不处理
		}
		return val;
	}

	/**
	 * form表单序列化
	 * @param {Document} formDcument :　表单dcument对象
	 */
	owner.serialize = function(formDcument) {
		var valueList = []; //保存待处理的值，结构为： name , value
		var data = {}; //返回结果的json数组

		//唯一值的
		var queryCSS = "input[type='color'][name]" + ",input[type='date'][name]" + ",input[type='datetime'][name]" +
			",input[type='datetime-local'][name]" + ",input[type='email'][name]" + ",input[type='hidden'][name]" +
			",input[type='month'][name]" + ",input[type='number'][name]" + ",input[type='password'][name]" +
			",input[type='range'][name]" + ",input[type='search'][name]" + ",input[type='tel'][name]" +
			",input[type='text'][name]" + ",input[type='time'][name]" + ",input[type='url'][name]" +
			",input[type='week'][name]" + ",input[type='radio'][name]:checked" + ",textarea[name]";
		var onlyValList = formDcument.querySelectorAll(queryCSS);
		for(var i = 0; i < onlyValList.length; i++) {
			var dom = onlyValList[i];
			var name = dom.getAttribute("name"); //键名
			var value = owner.escapeString(dom.value); //值
			data[name] = value;
		}

		//checkbox
		var checkboxList = formDcument.querySelectorAll("input[type='checkbox'][name]:checked");
		var existCheckbox = {}; //已处理过的checkbox
		for(var i = 0; i < checkboxList.length; i++) {
			var name = checkboxList[i].getAttribute("name");
			//判断是否已处理
			if(existCheckbox[name]) {
				continue;
			}
			var value = new Array();
			//获取相同的checkbox
			var doms = formDcument.querySelectorAll("input[type='checkbox'][name='" + name + "']:checked");
			for(var j = 0; j < doms.length; j++) {
				var val = owner.escapeString(doms[j].value);
				value.push(val);
			}
			data[name] = value;
			existCheckbox[name] = true;
		}

		//select
		var selectList = formDcument.querySelectorAll("select[name]");
		for(var i = 0; i < selectList.length; i++) {
			var dom = selectList[i];
			var name = dom.getAttribute("name"); //键名
			//多选select
			if(dom.getAttribute("multiple")) {
				var value = new Array();
				for(j = 0; j < dom.length; j++) {
					if(dom.options[j].selected) {
						var val = owner.escapeString(dom[j].value);
						value.push(val);
					}
				}
				data[name] = value;
			} else {
				var index = dom.selectedIndex;
				var value = owner.escapeString(dom.options[index].value);
				data[name] = value;
			}
		}
		return data;
	}
	/**
	 *
	 * @param {Object} formDcument : form表单
	 * @param {Object} data : JS对象
	 */
	owner.formFilling = function(formDcument, data) {
		//输入值的
		var queryCSS = "input[type='color'][fillName]" + ",input[type='date'][fillName]" + ",input[type='datetime'][fillName]" +
			",input[type='datetime-local'][fillName]" + ",input[type='email'][fillName]" + ",input[type='hidden'][fillName]" +
			",input[type='month'][fillName]" + ",input[type='number'][fillName]" + ",input[type='password'][fillName]" +
			",input[type='range'][fillName]" + ",input[type='search'][fillName]" + ",input[type='tel'][fillName]" +
			",input[type='text'][fillName]" + ",input[type='time'][fillName]" + ",input[type='url'][fillName]" +
			",input[type='week'][fillName]" + ",textarea[fillName]";
		var fillOne = formDcument.querySelectorAll(queryCSS);
		for(var i = 0; i < fillOne.length; i++) {
			var dom = fillOne[i];
			var fillName = dom.getAttribute("fillName"); //键名
			var value = data[fillName]; //值
			if(value) { //若有此值则填充数据
				dom.value = data[fillName];
			}
		}

		//radio,checkbox
		var fillTwo = formDcument.querySelectorAll("input[type='radio'][fillName],input[type='checkbox'][fillName]");
		var existFillTwo = {}; //已处理过的
		for(var i = 0; i < fillTwo.length; i++) {
			var dom = fillTwo[i];
			var fillName = dom.getAttribute("fillName"); //键名
			//判断是否已处理
			if(existFillTwo[fillName]) {
				continue;
			}
			var value = data[fillName]; //值
			if(value) { //若有此值
				//判断是否是数组
				if(typeof value === 'object' && Array == value.constructor) {
					for(var j = 0; j < value.length; j++) {
						var val = value[j];
						//获取相同的radio,checkbox
						var domsCSS = "input[type='radio'][fillName='" + fillName + "'][value='" + val + "']" +
							",input[type='checkbox'][fillName='" + fillName + "'][value='" + val + "']"
						var doms = formDcument.querySelectorAll(domsCSS);
						for(var k = 0; k < doms.length; k++) { //选中
							doms[j].checked = true;
						}
					}
				} else {
					//获取相同的radio,checkbox
					var domsCSS = "input[type='radio'][fillName='" + fillName + "'][value='" + value + "']" +
						",input[type='checkbox'][fillName='" + fillName + "'][value='" + value + "']"
					var doms = formDcument.querySelectorAll(domsCSS);
					for(var j = 0; j < doms.length; j++) { //选中
						doms[j].checked = true;
					}
				}
			}
			existFillTwo[fillName] = true;
		}

		//select
		var selectList = formDcument.querySelectorAll("select[fillName]");
		for(var i = 0; i < selectList.length; i++) {
			var dom = selectList[i];
			var fillName = dom.getAttribute("fillName"); //键名
			var value = data[fillName]; //值
			if(value) { //若有此值
				//判断是否是数组
				if(typeof value === 'object' && Array == value.constructor) {
					for(j = 0; j < value.length; j++) {
						for(k = 0; k < dom.length; k++) {
							var opt = dom.options[k];
							if(opt.value == value[j]) {
								opt.selected = true;
							}
						}
					}
				} else {
					for(j = 0; j < dom.length; j++) {
						var opt = dom.options[j];
						if(opt.value == value) {
							opt.selected = true;
							break;
						}
					}
				}
			}
		}
	}

	/**
	 *
	 * @param {String} url : 页面地址
	 * @param {String} id ：窗口标识
	 * @param {Object} styles : 窗口样式
	 * @param {Object} extras ： 传递参数
	 * @param {String} aniShow ： 显示方式
	 * @param {String} isHide ： 是否显示
	 */
	owner.openWin = function(url, id, styles, extras, aniShow, isHide) {
		//避免快速点击打开多个页面
		if(owner.openw) {
			return null;
		}
		owner.openw = id;
		//默认是右进显示
		aniShow || (aniShow = owner.aniShow);
		styles || (styles = {});
		extras || (extras = {});
		var page = plus.webview.create(url, id, styles, extras);
		page.addEventListener("loaded", function() {
			if(!isHide) {
				var data2 = new Date();
				page.show(aniShow);
			}
		}, false);
		page.addEventListener("hide", function() {
			owner.openw = null;
		}, false);
		page.addEventListener("close", function() {
			owner.openw = null;
		}, false);
		return page;
	}

	/**
	 *
	 * @param {String} url : 页面地址
	 * @param {String} id ：窗口标识
	 * @param {Object} styles : 窗口样式
	 * @param {Object} extras ： 传递参数
	 * @param {String} aniShow ： 显示方式
	 * @param {String} isHide ： 是否隐藏
	 */
	owner.preloadWin = function(url, id, styles, extras, aniShow, isHide) {
		//避免快速点击打开多个页面
		if(owner.openw) {
			return null;
		}
		owner.openw = id;
		//默认是右进显示
		aniShow || (aniShow = owner.aniShow);
		styles || (styles = {});
		extras || (extras = {});
		var page = owner.preate[id];
		//若此页面已在预加载列表中
		if(page) {
			page.show(aniShow);
			//			delete owner.timeouts[id];
			//			clearTimeout(owner.timeouts[id]);
			return page;
		} else {
			styles.scrollIndicator = 'none'; //隐藏滚动条
			styles.scalable = false; //窗口不可缩放
			styles.popGesture = 'hide'; //右划隐藏
			//预加载页面
			page = mui.preload({
				url: url,
				id: id,
				styles: styles,
				extras: extras
			});
			page.addEventListener("loaded", function() {
				if(!isHide) {
					page.show(aniShow);
				} else {
					owner.openw = null;
				}
			}, false);
			owner.preate[id] = page;
			//页面隐藏监听，
			page.addEventListener("hide", function() {
				owner.openw = null;
				//默认页面隐藏过了一定时间后没有再次打开则关闭
				//				var timeout = setTimeout(function() {
				//					page.close();
				//				}, owner.preateTimeout);
				//				owner.timeouts[id] = timeout;
			}, false);
			//页面关闭监听
			page.addEventListener("close", function() {
				owner.openw == id ? owner.openw = null : "";
				delete owner.preate[id];
			}, false);
		}
		return page;
	}

	owner.formatDate = function(time) {
		var date = new Date(time);
		var year = date.getFullYear();
		var month = date.getMonth() + 1;
		var day = date.getDate();
		var hours = date.getHours();
		var minutes = date.getMinutes();
		var seconds = date.getSeconds();
		return year + "-" + (month < 10 ? ('0' + month) : month) + "-" +
			(day < 10 ? ('0' + day) : day) + " " +
			(hours < 10 ? ('0' + hours) : hours) + ":" +
			(minutes < 10 ? ('0' + minutes) : minutes) + ":" +
			(seconds < 10 ? ('0' + seconds) : seconds);
	}

	/**
	 * 格式化eth显示
	 * @param {Object} eth
	 */
	owner.formatEth = function(eth) {
		if(eth == '0') {
			return eth;
		}
		var index = eth.indexOf('.');
		if(index != -1) {
			var point = eth.substring(index + 1);
			if(point.length > 6) {
				eth = eth.substring(0, index + 7);
				eth = parseFloat(eth) + '';
			}
		}
		return eth;
	}

	/**
	 * 格式化cny显示
	 * @param {Object} cny
	 */
	owner.formatCny = function(cny) {
		if(cny == 0) {
			return cny;
		}
		cny += "";
		var index = cny.indexOf('.');
		if(index != -1) {
			var point = cny.substring(index + 1);
			if(cny.length > 2) {
				cny = cny.substring(0, index + 3);
			}
		} else {
			cny += '.00';
		}
		return cny;
	}

	/**
	 * 存储用户数据到本地
	 * @param {Object} values : 用户数据
	 */
	owner.setUserLocalStorage = function(values) {
		values = values || {};
		localStorage.setItem("userInfo", JSON.stringify(values));
	}

	/**
	 * 获取本地存储的用户数据
	 * @param {String} key : 数据标识
	 */
	owner.getUserLocalStorage = function() {
		var settingsText = localStorage.getItem("userInfo") || "{}";
		return JSON.parse(settingsText);
	}

	/**
	 * 根据key值删除存储数据
	 * @param {Object} key
	 */
	owner.removeUserLocalStorage = function(key) {
		localStorage.removeItem("userInfo");
	}

	/**
	 * 存储Token
	 * @param {Object} values : 用户数据
	 */
	owner.setTokenStorage = function(values) {
		values = values || '';
		localStorage.setItem("user_token", values);
	}

	/**
	 * 获取Token
	 * @param {String} key : 数据标识
	 */
	owner.getTokenStorage = function() {
		return localStorage.getItem("user_token");
	}

	/**
	 * 删除Token
	 * @param {Object} key
	 */
	owner.removeTokenStorage = function(key) {
		localStorage.removeItem("user_token");
	}

	/**
	 * 存储托管用户资金密码是否设置的标识
	 * @param {Object} values : 用户数据
	 */
	owner.setIsWalletPassLocalStorage = function(values) {
		values = values || false;
		localStorage.setItem("isWalletPass", values);
	}

	/**
	 * 获取托管用户资金密码是否设置的标识
	 * @param {String} key : 数据标识
	 */
	owner.getIsWalletPassLocalStorage = function() {
		var isStatus = (localStorage.getItem("isWalletPass") == null || localStorage.getItem("isWalletPass") == 'false');
		return isStatus ? false : true;
	}
	/**
	 * 根据key值删除托用户资金密码是否设置的标识
	 * @param {Object} key
	 */
	owner.removeIsWalletPassLocalStorage = function() {
		localStorage.removeItem("isWalletPass");
	}

	/**
	 * 存储托管用户数据到本地
	 * @param {Object} values : 用户数据
	 */
	owner.setCoinWalletInfoLocalStorage = function(values) {
		values = values || [];
		localStorage.setItem("ethWalletInfo", JSON.stringify(values));
	}

	/**
	 * 获取本地存储的托管用户数据
	 * @param {String} key : 数据标识
	 */
	owner.getCoinWalletInfoLocalStorage = function() {
		var settingsText = localStorage.getItem("ethWalletInfo") || "[]";
		return JSON.parse(settingsText);
	}
	/**
	 * 根据key值删除托管用户存储数据
	 * @param {Object} key
	 */
	owner.removeCoinWalletInfoLocalStorage = function() {
		localStorage.removeItem("ethWalletInfo");
	}

	/**
	 * 存储托管用户数据到本地
	 * @param {Object} values : 用户数据
	 */
	owner.setEthWalletTokenListLocalStorage = function(values) {
		values = values || [];
		localStorage.setItem("ethWalletTokenList", JSON.stringify(values));
	}
	/**
	 * 获取本地存储的托管用户数据
	 * @param {String} key : 数据标识
	 */
	owner.getEthWalletTokenListLocalStorage = function() {
		var settingsText = localStorage.getItem("ethWalletTokenList") || "[]";
		return JSON.parse(settingsText);
	}
	/**
	 * 根据key值删除托管用户存储数据
	 * @param {Object} key
	 */
	owner.removeEthWalletTokenListLocalStorage = function() {
		localStorage.removeItem("ethWalletTokenList");
	}

	/**
	 * 存储用户数据到本地
	 * @param {Object} values : 用户数据
	 */
	owner.setC2cUserLocalStorage = function(values) {
		values = values || {};
		localStorage.setItem("c2cUserInfo", JSON.stringify(values));
	}

	/**
	 * 获取本地存储的用户数据
	 * @param {String} key : 数据标识
	 */
	owner.getC2cUserLocalStorage = function() {
		var settingsText = localStorage.getItem("c2cUserInfo") || "{}";
		return JSON.parse(settingsText);
	}

	/**
	 * 根据key值删除存储数据
	 * @param {Object} key
	 */
	owner.removeC2cUserLocalStorage = function(key) {
		localStorage.removeItem("c2cUserInfo");
	}

	/**
	 * 存储托管用户数据到本地
	 * @param {Object} values : 用户数据
	 */
	owner.setC2CCoinWalletInfoLocalStorage = function(values) {
		values = values || [];
		localStorage.setItem("ethC2CWalletInfo", JSON.stringify(values));
	}

	/**
	 * 获取本地存储的托管用户数据
	 * @param {String} key : 数据标识
	 */
	owner.getC2CCoinWalletInfoLocalStorage = function() {
		var settingsText = localStorage.getItem("ethC2CWalletInfo") || "[]";
		return JSON.parse(settingsText);
	}
	/**
	 * 根据key值删除托管用户存储数据
	 * @param {Object} key
	 */
	owner.removeC2CCoinWalletInfoLocalStorage = function() {
		localStorage.removeItem("ethC2CWalletInfo");
	}

	/**
	 * 存储国际化标识
	 * @param {Object} values : 用户数据
	 */
	owner.setLanguageLocalStorage = function(values) {
		values = values || "zh_CN";
		localStorage.setItem("language", values);
	}

	/**
	 * 获取国际化标识
	 * @param {String} key : 数据标识
	 */
	owner.getLanguageLocalStorage = function() {
		var settingsText = localStorage.getItem("language") || "zh_CN";
		return settingsText;
	}

	/**
	 * 删除国际化标识缓存
	 * @param {Object} key
	 */
	owner.removeLanguageLocalStorage = function(key) {
		localStorage.removeItem("language");
	}

	/**
	 * 存储app汇率
	 * @param {Object} values : app最新版本
	 */
	owner.setExchangeRateLocalStorage = function(values) {
		values = values || "CNY";
		localStorage.setItem("$exchangeRate", values);
	}

	/**
	 * app汇率
	 */
	owner.getExchangeRateLocalStorage = function() {
		return localStorage.getItem("$exchangeRate") || "USD";
	}

	/**
	 * 存储app最新版本
	 * @param {Object} values : app最新版本
	 */
	owner.setVersionLocalStorage = function(values) {
		values = values || "";
		localStorage.setItem("$version", values);
	}

	/**
	 * app最新版本
	 */
	owner.getVersionLocalStorage = function() {
		return localStorage.getItem("$version") || "";
	}

	/**
	 * mui.toast重写
	 */
	owner.toast = function(msg) {
		plus.nativeUI.toast(msg, {
			verticalAlign: 'center'
		});
	}

	/**
	 * 格式化数据值
	 * @param {Object} value
	 */
	owner.formatValue = function(value) {
		if(value == 0) return '0.000000';
		var val = parseFloat(value);
		if(val < 0) {
			val = -val;
		}
		if(val < 0.0001) {
			value = compute.Mul(value, 1e8, 8);
			value = compute.Div(value, 1e8, 8);
			value = value.toFixed(8);
		} else if(val < 0.1) {
			value = compute.Mul(value, 1e6, 6);
			value = compute.Div(value, 1e6, 6);
			value = value.toFixed(6);
		} else if(val < 10) {
			value = compute.Mul(value, 1e4, 4);
			value = compute.Div(value, 1e4, 4);
			value = value.toFixed(4);
		} else {
			value = compute.Mul(value, 1e2, 2);
			value = compute.Div(value, 1e2, 2);
			value = value.toFixed(2);
		}
		return value;
	}

    /***
     * 格式化数据值 - 通过字符串截取方式
     * @param value 值
     * @param decimal 小数最大长度
     */
    owner.formatValueStr = function (value, decimal) {
        //默认长度为8
        if (decimal == null || decimal == '') {
            decimal = 8;
        }
        //防止NaN
        if (isNaN(value)) {
            return Number(0);
        }
        value = value.toString();
        //小数点索引
        var valueIndex = value.indexOf('.');
        //存在小数的情况
        if (valueIndex != -1) {
            //小数位数据
            var valueFloat = value.substring(valueIndex + 1);

            //判断格式化数据大小，保留小数
            value = parseFloat(value);
            if (value < 0.0001) {
                decimal = 8;
            } else if (value < 0.1) {
                decimal = 6;
            } else if (value < 10) {
                decimal = 4;
            } else {
                decimal = 2;
            }

            //小数位长度大于格式化长度
            if (valueFloat.length > decimal) {
                //需要保留的小数位 + 1
                var floatNum = parseFloat(value).toFixed(Number(decimal) + 1);
                //截取数据，保留小数并不用四舍五入
                value = floatNum.substring(0, floatNum.length - 1);
            }
        }
        return parseFloat(value);
    }

	/***
	 * 简单的小函数，只做了+ 、- 、* 、/四则运算，第一、二个参数为参与运算的两个数，第三个参数为运算符(+ - * /)
	 * 思路是运算前用字符串处理拿掉 '.' ，运算结束后还原倍数。
	 * https://www.cnblogs.com/superjsman/p/10049528.html
	 * @param {Object} one
	 * @param {Object} two
	 * @param {Object} str
	 */
	owner.floatPoint = function(one, two, str) {
		//转化为字符串
		one = '' + one
		two = '' + two
		//切割成整数部分和小数部分
		var oneStr = one.split('.')
		var twoStr = two.split('.')

		// 处理参数一或二为整数的情况
		if(!oneStr[1]) {
			oneStr[1] = ''
		}
		if(!twoStr[1]) {
			twoStr[1] = ''
		}

		var length = null
		//比较小数部分的长度，以确定剥离小数点后放大的倍数
		var oneFloatLength = oneStr[1].length
		var TwoFloatLength = twoStr[1].length
		if(oneFloatLength > TwoFloatLength) {
			length = oneFloatLength
			twoStr[1] = twoStr[1].padEnd(length, '0')
		} else if(TwoFloatLength > oneFloatLength) {
			length = TwoFloatLength
			twoStr[1] = oneStr[1].padEnd(length, '0')
		} else {
			length = TwoFloatLength
		}
		// 拼接成处理后的数字
		var oneBig = oneStr[0] + oneStr[1]
		var twoBig = twoStr[0] + twoStr[1]

		//根据运算符决定运算后缩小的倍数
		var result = null
		switch(str) {
			case '+':
				;
			case '-':
				result = eval(oneBig + str + twoBig) / (10 * length)
				break;
			case '*':
				result = eval(oneBig + str + twoBig) / (10 * (length * 2))
				break;
			case '/':
				result = eval(oneBig + str + twoBig)
		}
		return result
	}

	/***
	 * 数组排序
	 * @param data 数据源
	 * @param sort 排序规则 ASC升序 | DESC倒序
	 * @param field 排序字段
	 * @returns {sortData} 排序后的数据
	 */
	owner.sortArray = function(data, sort, field) {
		//数据源是否为空
		if(data == null) {
			throw new Error('数据源为空！');
		}
		//排序字段是否为空
		if(field == null || field == '') {
			throw new Error('排序字段为空！');
		}
		//默认排序为升序
		if(sort == null || sort == '') {
			sort = 'ASC'
		}
		//排序逻辑函数
		var sortFun = null;
		//升序排序逻辑函数
		if(sort == 'ASC' || sort == 'asc') {
			sortFun = function(a, b) {
				return a[field] - b[field];
			}
		}
		//倒序排序逻辑函数
		if(sort == 'DESC' || sort == 'desc') {
			sortFun = function(a, b) {
				return b[field] - a[field];
			}
		}
		//如果逻辑函数为空
		if(sortFun == null) {
			throw new Error('排序参数异常！');
		}
		//返回排序数据
		return data.sort(sortFun);
	}

}(window.app = {}));

window.addEventListener("resize", function() {
	if(document.activeElement.tagName == "INPUT" || document.activeElement.tagName == "TEXTAREA") {
		document.activeElement.scrollIntoViewIfNeeded();
	}
});

/**
 * @method js控制input框只能输入数字和一位小数点和小数点后面n位小数
 *
 * @param {Object} obj                           文本框对象
 * @param {Object} _decimals   小数点位数
 */
function formatNumber(obj, _decimals) {
	obj.value = obj.value.replace(/[^\d\.]/g, ""); //清除“数字”和“.”以外的字符
	if(/\d+\.\d*\./.test(obj.value)) {
		var secondPonitIndex = obj.value.indexOf(".", obj.value.indexOf(".") + 1);
		obj.value = obj.value.substring(0, secondPonitIndex); //只保留第一个.  清除多余的
	}
	//obj.value = obj.value.replace(/\.{2,}/g, "."); //只保留第一个. 清除多余的
	var reg = new RegExp("^(\\d+)\\.(\\d{" + _decimals + "}).*$");
	obj.value = obj.value.replace(reg, '$1.$2'); //只能输入n个小数
	if(obj.value.indexOf(".") < 0 && obj.value != "") { //以上已经过滤，此处控制的是如果没有小数点，首位不能为类似于 01、02的金额
		obj.value = parseFloat(obj.value);
	}
	if(obj.value.indexOf(".") == 0) { //如果输入类似.123   变为0.123
		obj.value = "0" + obj.value;
	}
}

/**
 * splitValue 获取当前时间
 * @param value
 * @returns {array}
 */
function formatDate(date, fmt) {
  if (/(y+)/.test(fmt)) {
    fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length));
  }

  var o = {
    'M+': date.getMonth() + 1,
    'd+': date.getDate(),
    'h+': date.getHours(),
    'm+': date.getMinutes(),
    's+': date.getSeconds()
  };

  for (var k in o) {
    if (new RegExp("(".concat(k, ")")).test(fmt)) {
      var str = o[k] + '';
      fmt = fmt.replace(RegExp.$1, RegExp.$1.length === 1 ? str : ('00' + str).substr(str.length));
    }
  }

  return fmt;
}

var compute = {
	/*
	函数，加法函数，用来得到精确的加法结果  
	说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
	参数：arg1：第一个加数；arg2第二个加数；d要保留的小数位数（可以不传此参数，如果不传则不处理小数位数）
	调用：Calc.Add(arg1,arg2,d)  
	返回值：两数相加的结果
	*/
	Add: function(arg1, arg2, d) {
		arg1 = arg1.toString(), arg2 = arg2.toString();
		var arg1Arr = arg1.split("."),
			arg2Arr = arg2.split("."),
			d1 = arg1Arr.length == 2 ? arg1Arr[1] : "",
			d2 = arg2Arr.length == 2 ? arg2Arr[1] : "";
		var maxLen = Math.max(d1.length, d2.length);
		var m = Math.pow(10, maxLen);
		var result = Number(((arg1 * m + arg2 * m) / m).toFixed(maxLen));
		var d = arguments[2];
		return typeof d === "number" ? Number((result).toFixed(d)) : result;
	},
	/*
	函数：减法函数，用来得到精确的减法结果  
	说明：函数返回较为精确的减法结果。 
	参数：arg1：第一个加数；arg2第二个加数；d要保留的小数位数（可以不传此参数，如果不传则不处理小数位数
	调用：Calc.Sub(arg1,arg2)  
	返回值：两数相减的结果
	*/
	Sub: function(arg1, arg2, d) {
		return this.Add(arg1, -Number(arg2), arguments[2]);
	},
	/*
	函数：乘法函数，用来得到精确的乘法结果  
	说明：函数返回较为精确的乘法结果。 
	参数：arg1：第一个乘数；arg2第二个乘数；d要保留的小数位数（可以不传此参数，如果不传则不处理小数位数)
	调用：Calc.Mul(arg1,arg2)  
	返回值：两数相乘的结果
	*/
	Mul: function(arg1, arg2, d) {
		var r1 = arg1.toString(),
			r2 = arg2.toString(),
			m, resultVal, d = arguments[2];
		m = (r1.split(".")[1] ? r1.split(".")[1].length : 0) + (r2.split(".")[1] ? r2.split(".")[1].length : 0);
		resultVal = Number(r1.replace(".", "")) * Number(r2.replace(".", "")) / Math.pow(10, m);
		if(typeof d !== "number") {
			return Number(resultVal)
		} else {
			var beiTen = Math.pow(10, parseInt(d));
			resultVal = (parseInt(resultVal * beiTen) / beiTen).toFixed(parseInt(d));
			return Number(resultVal);
		}
	},
	/*
	函数：除法函数，用来得到精确的除法结果  
	说明：函数返回较为精确的除法结果。 
	参数：arg1：除数；arg2被除数；d要保留的小数位数（可以不传此参数，如果不传则不处理小数位数)
	调用：Calc.Div(arg1,arg2)  
	返回值：arg1除于arg2的结果
	*/
	Div: function(arg1, arg2, d) {
		var r1 = arg1.toString(),
			r2 = arg2.toString(),
			m, resultVal, d = arguments[2];
		m = (r2.split(".")[1] ? r2.split(".")[1].length : 0) - (r1.split(".")[1] ? r1.split(".")[1].length : 0);
		resultVal = Number(r1.replace(".", "")) / Number(r2.replace(".", "")) * Math.pow(10, m);
		if(typeof d !== "number") {
			return Number(resultVal)
		} else {
			var beiTen = Math.pow(10, parseInt(d));
			resultVal = (parseInt(resultVal * beiTen) / beiTen).toFixed(parseInt(d));
			return Number(resultVal);
		}
	}
};