906 lines
25 KiB
JavaScript
906 lines
25 KiB
JavaScript
"use strict";
|
||
cc._RF.push(module, '693baLcvz1DyrnZJgdT0PMM', 'nx.math');
|
||
// Scripts/nx/kernel/nx.math.js
|
||
|
||
"use strict";
|
||
|
||
/*******************************************************************************
|
||
*
|
||
* Nx数据结构相关方法
|
||
*
|
||
*
|
||
*
|
||
* 2021.12.10
|
||
******************************************************************************/
|
||
|
||
require("base64");
|
||
require("rseed");
|
||
var md = require("md5");
|
||
|
||
// 默认小数位数
|
||
var DefPN = 2;
|
||
var NxMath = cc.Class({
|
||
name: "NxMath",
|
||
// 创建
|
||
ctor: function ctor() {
|
||
this.uuTracker = 1000;
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：基本的数据类型判断
|
||
// ------------------------------------------------------------
|
||
|
||
// 数字
|
||
numGood: function numGood(_n) {
|
||
return _n === +_n;
|
||
},
|
||
// 正数
|
||
numPositive: function numPositive(_n, _inZero /* true */) {
|
||
if (!this.numGood(_n)) {
|
||
return false;
|
||
}
|
||
return _inZero !== false ? _n >= 0 : _n > 0;
|
||
},
|
||
// 为X的数
|
||
numEqual: function numEqual(_n, _t) {
|
||
return this.numGood(_n) && _n == _t;
|
||
},
|
||
// 大于X的数
|
||
numGreater: function numGreater(_n, _t) {
|
||
return this.numGood(_n) && _n > _t;
|
||
},
|
||
// 小于X的数
|
||
numLess: function numLess(_n, _t) {
|
||
return this.numGood(_n) && _n < _t;
|
||
},
|
||
// 范围内的数
|
||
numInRange: function numInRange(_n, _range /* [x,y] */) {
|
||
if (!this.arrGood(_range) || _range.length != 2) {
|
||
return false;
|
||
}
|
||
return this.numGood(_n) && _n >= _range[0] && _n <= _range[1];
|
||
},
|
||
// 数字修正
|
||
numFix: function numFix(_num, _def) {
|
||
if (_def === void 0) {
|
||
_def = 0;
|
||
}
|
||
var ret = _num;
|
||
if (!nx.dt.numGood(ret)) {
|
||
ret = _def;
|
||
}
|
||
return ret;
|
||
},
|
||
// 浮点精确度
|
||
toFixedDecimal: function toFixedDecimal(_n) {
|
||
if (!this.numGood(_n)) {
|
||
return 0;
|
||
}
|
||
|
||
// 多保留一位来保证浮点数精度
|
||
var fixedNumber = (_n * 100).toFixed(1);
|
||
return Number((parseInt(fixedNumber) / 100).toFixed(2));
|
||
},
|
||
// 布尔
|
||
isBool: function isBool(_b) {
|
||
return _b === !!_b;
|
||
},
|
||
// 字节数格式化
|
||
formatBytes: function formatBytes(bytes, decimals) {
|
||
if (decimals === void 0) {
|
||
decimals = 2;
|
||
}
|
||
if (bytes === 0) return '0 Bytes';
|
||
var k = 1024;
|
||
var dm = decimals & lt;
|
||
0 ? 0 : decimals;
|
||
var sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
|
||
var i = Math.floor(Math.log(bytes) / Math.log(k));
|
||
return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：方法的方法
|
||
// ------------------------------------------------------------
|
||
|
||
// 有效方法
|
||
fnGood: function fnGood(_f) {
|
||
return _f != null && typeof _f === "function";
|
||
},
|
||
// 空方法
|
||
fnEmpty: function fnEmpty() {},
|
||
// 空方法报错
|
||
fnEmptyError: function fnEmptyError(_fn) {
|
||
if (this.fnGood(_fn)) {
|
||
nx.error("方法已经存在:", _fn.name);
|
||
}
|
||
},
|
||
// 安全回调
|
||
fnInvoke: function fnInvoke(_fn) {
|
||
if (!this.fnGood(_fn)) {
|
||
return;
|
||
}
|
||
if (CC_DEBUG) {
|
||
_fn.apply(null, Array.prototype.slice.call(arguments, 1));
|
||
} else {
|
||
try {
|
||
_fn.apply(null, Array.prototype.slice.call(arguments, 1));
|
||
} catch (e) {
|
||
nx.error("[异常]:" + (e ? e.message + "\n" + e.stack : "未知错误!"));
|
||
if (e && cc.sys.isNative && window && window.__errorHandler) {
|
||
window.__errorHandler(e.message, "", "", e.stack);
|
||
}
|
||
}
|
||
}
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：字符串的方法
|
||
// ------------------------------------------------------------
|
||
|
||
// 字符串
|
||
strGood: function strGood(_s) {
|
||
return _s === _s + "";
|
||
},
|
||
// 非空字符串
|
||
strNEmpty: function strNEmpty(_s) {
|
||
return this.strGood(_s) && _s != "";
|
||
},
|
||
// 空字符串
|
||
strEmpty: function strEmpty(_s) {
|
||
return !this.strNEmpty(_s);
|
||
},
|
||
// 字符串去空格
|
||
strTrim: function strTrim(_s) {
|
||
if (this.strNEmpty(_s)) {
|
||
return _s.replace(/^(\s|\u00A0)+/, "").replace(/(\s|\u00A0)+$/, "");
|
||
}
|
||
return "";
|
||
},
|
||
// 获取字节长度
|
||
strBytes: function strBytes(_s) {
|
||
if (!this.strNEmpty(_s)) {
|
||
return 0;
|
||
}
|
||
var len = 0;
|
||
for (var i = 0; i < _s.length; i++) {
|
||
var a = _s.charAt(i);
|
||
if (a.match(/[^\x00-\xff]/ig) != null) {
|
||
len += 2;
|
||
} else {
|
||
len += 1;
|
||
}
|
||
}
|
||
return len;
|
||
},
|
||
// 字符串省略截取
|
||
strCut: function strCut(str, len) {
|
||
if (!str || !len) {
|
||
return "";
|
||
}
|
||
var build = "";
|
||
for (var i = 0; i < str.length && len > 0; i++) {
|
||
build += str.substr(i, 1);
|
||
len -= str.charCodeAt(i) > 127 ? 2 : 1;
|
||
}
|
||
if (build.length < str.length) build += "..";
|
||
return build;
|
||
},
|
||
// 字符串省略截取(逆向)
|
||
strCutR: function strCutR(str, len) {
|
||
if (!str || !len) {
|
||
return "";
|
||
}
|
||
var build = "";
|
||
for (var i = str.length - 1; i >= 0 && len > 0; i--) {
|
||
build = str.substr(i, 1) + build;
|
||
len -= str.charCodeAt(i) > 127 ? 2 : 1;
|
||
}
|
||
if (build.length < str.length) {
|
||
build = "****" + build;
|
||
}
|
||
return build;
|
||
},
|
||
/**
|
||
* key#value属性串转数组
|
||
* @param {*} _sp
|
||
*/
|
||
pairSplit: function pairSplit(_sp) {
|
||
var _ref;
|
||
var a = _sp.split('#');
|
||
if (a.length != 2) {
|
||
nx.error("pairSplit失败,格式无效!", _sp);
|
||
return null;
|
||
}
|
||
var k = a[0];
|
||
var v = a[1];
|
||
|
||
// 如果值是数字,那么转为数字
|
||
if (Number(v) == v) {
|
||
v = Number(v);
|
||
}
|
||
return _ref = {}, _ref[k] = v, _ref;
|
||
},
|
||
/**
|
||
* 特定key#value属性串转数组
|
||
* 用于统一拆分Array[String]数据
|
||
* @param {*} _arr
|
||
*/
|
||
arrPairSplit: function arrPairSplit(_arr) {
|
||
var _this = this;
|
||
var ret = [];
|
||
if (this.arrEmpty(_arr)) {
|
||
return ret;
|
||
}
|
||
_arr.forEach(function (_sp) {
|
||
var d = _this.pairSplit(_sp);
|
||
if (d) {
|
||
ret.push(d);
|
||
}
|
||
});
|
||
return ret;
|
||
},
|
||
/**
|
||
* 补零
|
||
* @param num： 被操作数
|
||
* @param n： 固定的总位数
|
||
*/
|
||
prefixZero: function prefixZero(num, n) {
|
||
return (Array(n).join(0) + num).slice(-n);
|
||
},
|
||
/**
|
||
* 字符串替换
|
||
* replaceAll
|
||
*/
|
||
replace: function replace(_str, _old, _new) {
|
||
return _str.replace(new RegExp(_old, "gm"), _new);
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：数组的方法
|
||
// ------------------------------------------------------------
|
||
|
||
// 数组
|
||
arrGood: function arrGood(_a) {
|
||
return Object.prototype.toString.call(_a) === "[object Array]";
|
||
},
|
||
// 非空数组
|
||
arrNEmpty: function arrNEmpty(_a) {
|
||
return this.arrGood(_a) && _a.length > 0;
|
||
},
|
||
// 空数组
|
||
arrEmpty: function arrEmpty(_a) {
|
||
return !this.arrNEmpty(_a);
|
||
},
|
||
// 是不是数组成员
|
||
arrMember: function arrMember(_a, _m, _fn) {
|
||
if (!this.arrNEmpty(_a)) {
|
||
return false;
|
||
}
|
||
_fn = _fn || function (_v) {
|
||
return _v == _m;
|
||
};
|
||
for (var i = 0; i < _a.length; ++i) {
|
||
if (_fn(_a[i])) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
// 合并数据[带关键字且不能重复]
|
||
arrConcat: function arrConcat(_a1, _a2) {
|
||
if (!this.arrGood(_a1) || !this.arrGood(_a2)) {
|
||
nx.error("合并失败,参数不能为空!");
|
||
return null;
|
||
}
|
||
|
||
// 合并Table绑定列表
|
||
if (CC_DEBUG) {
|
||
var _exist = function _exist(_key) {
|
||
for (var k in _a1) {
|
||
var m = _a1[k];
|
||
if (m[0] == _key) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
for (var i in _a2) {
|
||
var binder = _a2[i];
|
||
if (_exist(binder[0])) {
|
||
nx.error("合并失败: %s,有重复关键字项!", binder[0]);
|
||
return null;
|
||
}
|
||
}
|
||
}
|
||
return _a1.concat(_a2);
|
||
},
|
||
// 从数组中删除
|
||
arrDelete: function arrDelete(_a, _fn, _once) {
|
||
if (!this.arrNEmpty(_a) || !this.fnGood(_fn)) {
|
||
return _a;
|
||
}
|
||
var i = _a.length;
|
||
while (i--) {
|
||
if (_fn(_a[i])) {
|
||
_a.splice(i, 1);
|
||
if (_once != false) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return _a;
|
||
},
|
||
// 对象转数组对
|
||
arrFromMap: function arrFromMap(_map) {
|
||
if (!this.objGood(_map)) {
|
||
nx.warn("对象为空,转换失败!");
|
||
return [];
|
||
}
|
||
var pairs = [];
|
||
for (var i in _map) {
|
||
pairs.push([i, _map[i]]);
|
||
}
|
||
return pairs;
|
||
},
|
||
// 数组比较(成员相同)
|
||
arrCompare: function arrCompare(_a, _b) {
|
||
if (!this.arrGood(_a) || !this.arrGood(_b) || _a.length != _b.length) {
|
||
return false;
|
||
}
|
||
for (var i in _a) {
|
||
if (!this.arrMember(_b, _a[i])) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：对象的方法
|
||
// ------------------------------------------------------------
|
||
|
||
// 创建一个UUID(运行时唯一)
|
||
newUUID: function newUUID(_key) {
|
||
if (!this.strNEmpty(_key)) {
|
||
_key = "OBJ";
|
||
}
|
||
return _key + ++this.uuTracker;
|
||
},
|
||
// 创建永不重复的Tag
|
||
newTag: function newTag(_key) {
|
||
var tag = this.md5(cc.sys.now().toString());
|
||
if (this.strEmpty(_key)) {
|
||
return tag;
|
||
}
|
||
return _key + "." + tag;
|
||
},
|
||
// 空对象
|
||
objGood: function objGood(_o) {
|
||
return _o != null && typeof _o === "object" && Array.isArray(_o) === false;
|
||
},
|
||
// 非空对象
|
||
objNEmpty: function objNEmpty(_o) {
|
||
if (!this.objGood(_o)) {
|
||
return false;
|
||
}
|
||
return Object.keys(_o).length > 0;
|
||
},
|
||
// 空对象
|
||
objEmpty: function objEmpty(_o) {
|
||
return !this.objNEmpty(_o);
|
||
},
|
||
// 对象合并
|
||
objConcat: function objConcat(_dic1, _dic2) {
|
||
if (!this.objGood(_dic1)) {
|
||
return this.objClone(_dic2);
|
||
}
|
||
if (!this.objGood(_dic1)) {
|
||
return this.objClone(_dic1);
|
||
}
|
||
var dic = this.objClone(_dic1);
|
||
for (var k in _dic2) {
|
||
dic[k] = this.objClone(_dic2[k]);
|
||
}
|
||
return dic;
|
||
},
|
||
// 获取对象成员数量
|
||
objLen: function objLen(_dic) {
|
||
if (!this.objGood(_dic)) {
|
||
return 0;
|
||
}
|
||
return Object.keys(_dic).length;
|
||
},
|
||
// 深复制
|
||
objClone: function objClone(_obj) {
|
||
// 非对象直接使用返回
|
||
if (!_obj || typeof _obj !== "object") {
|
||
return _obj;
|
||
}
|
||
var out = _obj.constructor === Array ? [] : {};
|
||
var _clone = function _clone(o, c) {
|
||
for (var i in o) {
|
||
if (o[i] && typeof o[i] === "object") {
|
||
if (o[i].constructor === Array) {
|
||
c[i] = [];
|
||
} else {
|
||
c[i] = {};
|
||
}
|
||
_clone(o[i], c[i]);
|
||
} else {
|
||
c[i] = o[i];
|
||
}
|
||
}
|
||
return c;
|
||
};
|
||
return _clone(_obj, out);
|
||
},
|
||
// 复制属性到对象
|
||
copyProperties: function copyProperties(_object, _dic, _log) {
|
||
if (_log === void 0) {
|
||
_log = false;
|
||
}
|
||
if (!this.objGood(_object) || !this.objGood(_dic)) {
|
||
return false;
|
||
}
|
||
if (_log) {
|
||
nx.debug("[DT]属性更新:");
|
||
}
|
||
for (var k in _dic) {
|
||
_object[k] = this.objClone(_dic[k]);
|
||
if (_log) {
|
||
nx.debug("\t\t键值: %s", k);
|
||
}
|
||
}
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：随机数的方法
|
||
// ------------------------------------------------------------
|
||
// 范围随机数
|
||
randomRange: function randomRange(_min, _max) {
|
||
var Range = _max - _min;
|
||
var Rand = Math.random();
|
||
var num = _min + Math.round(Rand * Range); //四舍五入
|
||
return num;
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：加密的方法
|
||
// ------------------------------------------------------------
|
||
|
||
// 获取md5
|
||
md5: function md5(key) {
|
||
return md.hex_md5(key);
|
||
},
|
||
// 加密
|
||
encode64: function encode64(str, pwd) {
|
||
str = Base64.encode(str); //Base64加密
|
||
var prand = "";
|
||
for (var i = 0; i < pwd.length; i++) {
|
||
prand += pwd.charCodeAt(i).toString();
|
||
}
|
||
var sPos = Math.floor(prand.length / 5);
|
||
var mult = parseInt(prand.charAt(sPos) + prand.charAt(sPos * 2) + prand.charAt(sPos * 3) + prand.charAt(sPos * 4) + prand.charAt(sPos * 5));
|
||
var incr = Math.ceil(pwd.length / 2);
|
||
var modu = Math.pow(2, 31) - 1;
|
||
if (mult < 2) {
|
||
alert("Please choose a more complex or longer password.");
|
||
return null;
|
||
}
|
||
var salt = Math.round(Math.random() * 1000000000) % 100000000;
|
||
prand += salt;
|
||
while (prand.length > 10) {
|
||
prand = (parseInt(prand.substring(0, 10)) + parseInt(prand.substring(10, prand.length))).toString();
|
||
}
|
||
prand = (mult * prand + incr) % modu;
|
||
var enc_chr = "";
|
||
var enc_str = "";
|
||
for (var i = 0; i < str.length; i++) {
|
||
enc_chr = parseInt(str.charCodeAt(i) ^ Math.floor(prand / modu * 255));
|
||
if (enc_chr < 16) {
|
||
enc_str += "0" + enc_chr.toString(16);
|
||
} else enc_str += enc_chr.toString(16);
|
||
prand = (mult * prand + incr) % modu;
|
||
}
|
||
salt = salt.toString(16);
|
||
while (salt.length < 8) salt = "0" + salt;
|
||
enc_str += salt;
|
||
return enc_str;
|
||
},
|
||
// 解密
|
||
decode64: function decode64(str, pwd) {
|
||
var prand = "";
|
||
for (var i = 0; i < pwd.length; i++) {
|
||
prand += pwd.charCodeAt(i).toString();
|
||
}
|
||
var sPos = Math.floor(prand.length / 5);
|
||
var mult = parseInt(prand.charAt(sPos) + prand.charAt(sPos * 2) + prand.charAt(sPos * 3) + prand.charAt(sPos * 4) + prand.charAt(sPos * 5));
|
||
var incr = Math.round(pwd.length / 2);
|
||
var modu = Math.pow(2, 31) - 1;
|
||
var salt = parseInt(str.substring(str.length - 8, str.length), 16);
|
||
str = str.substring(0, str.length - 8);
|
||
prand += salt;
|
||
while (prand.length > 10) {
|
||
prand = (parseInt(prand.substring(0, 10)) + parseInt(prand.substring(10, prand.length))).toString();
|
||
}
|
||
prand = (mult * prand + incr) % modu;
|
||
var enc_chr = "";
|
||
var enc_str = "";
|
||
for (var i = 0; i < str.length; i += 2) {
|
||
enc_chr = parseInt(parseInt(str.substring(i, i + 2), 16) ^ Math.floor(prand / modu * 255));
|
||
enc_str += String.fromCharCode(enc_chr);
|
||
prand = (mult * prand + incr) % modu;
|
||
}
|
||
return Base64.decode(enc_str);
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：JSON
|
||
// ------------------------------------------------------------
|
||
|
||
// 安全执行(异常捕获)
|
||
trycatch: function trycatch(_dosth, _error) {
|
||
try {
|
||
_dosth();
|
||
} catch (e) {
|
||
nx.error("[异常]:" + (e ? e.message + "\n" + e.stack : "未知错误!"));
|
||
if (_error) {
|
||
_error(e);
|
||
}
|
||
if (e && cc.sys.isNative && window && window.__errorHandler) {
|
||
window.__errorHandler(e.message, "", "", e.stack);
|
||
}
|
||
}
|
||
},
|
||
// JSON压缩
|
||
enjson: function enjson(_object) {
|
||
try {
|
||
return JSON.stringify(_object);
|
||
} catch (e) {
|
||
nx.error("[异常]:" + (e ? e.message + "\n" + e.stack : "未知错误!"));
|
||
// if( e && cc.sys.isNative && window && window.__errorHandler ) {
|
||
// window.__errorHandler( e.message, "", "", e.stack );
|
||
// }
|
||
return "";
|
||
}
|
||
},
|
||
// JSON解析
|
||
dejson: function dejson(_str) {
|
||
// 空返回
|
||
if (!this.strNEmpty(_str)) {
|
||
return null;
|
||
}
|
||
try {
|
||
return JSON.parse(_str);
|
||
} catch (e) {
|
||
nx.error("[异常]:" + (e ? e.message + "\n" + e.stack : "未知错误!"));
|
||
// if( e && cc.sys.isNative && window && window.__errorHandler ) {
|
||
// window.__errorHandler( e.message, "", "", e.stack );
|
||
// }
|
||
return null;
|
||
}
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：时间的方法
|
||
// ------------------------------------------------------------
|
||
|
||
// 秒级时间戳
|
||
timeStamp: function timeStamp() {
|
||
return Math.floor(cc.sys.now() / 1000);
|
||
},
|
||
// 格式化日期
|
||
fmtDate: function fmtDate(_date, _year) {
|
||
if (_year === void 0) {
|
||
_year = true;
|
||
}
|
||
_date = _date ? _date : new Date();
|
||
if (this.numGood(_date)) {
|
||
_date = new Date(_date);
|
||
}
|
||
var _format = function _format(v) {
|
||
return v < 10 ? "0" + v : v;
|
||
};
|
||
if (!_year) {
|
||
return nx.text.formatS("%s:%s", _format(_date.getMonth() + 1), _format(_date.getDate()));
|
||
}
|
||
return nx.text.formatS("%s-%s-%s", _format(_date.getFullYear()), _format(_date.getMonth() + 1), _format(_date.getDate()));
|
||
},
|
||
// 格式化日期
|
||
fmtDateLoc: function fmtDateLoc(_date, _year) {
|
||
if (_year === void 0) {
|
||
_year = true;
|
||
}
|
||
_date = _date ? _date : new Date();
|
||
if (!_year) {
|
||
return nx.text.formatS("%s%s", nx.text.format("month", _date.getMonth() + 1), nx.text.format("day", _date.getDate()));
|
||
}
|
||
return nx.text.formatS("%s%s%s", nx.text.format("year", _date.getFullYear()), nx.text.format("month", _date.getMonth() + 1), nx.text.format("day", _date.getDate()));
|
||
},
|
||
// 格式化时间
|
||
fmtTime: function fmtTime(_date) {
|
||
_date = _date ? _date : new Date();
|
||
var _format = function _format(v) {
|
||
return v < 10 ? "0" + v : v;
|
||
};
|
||
return nx.text.formatS("%s:%s:%s", _format(_date.getHours()), _format(_date.getMinutes()), _format(_date.getSeconds()));
|
||
},
|
||
// 格式化时间
|
||
fmtTimeFromSecs: function fmtTimeFromSecs(_secs, _full) {
|
||
if (_full === void 0) {
|
||
_full = false;
|
||
}
|
||
if (!this.numPositive(_secs, false)) {
|
||
return _full ? "00:00:00" : "00:00";
|
||
}
|
||
var f = function f(v) {
|
||
return v < 10 ? "0" + v : v;
|
||
};
|
||
var h = Math.floor(_secs / 3600);
|
||
_secs = _secs % 3600;
|
||
var m = Math.floor(_secs / 60);
|
||
var s = Math.floor(_secs % 60);
|
||
|
||
// 完整版本
|
||
if (_full) {
|
||
return nx.text.formatS("%s:%s:%s", f(h), f(m), f(s));
|
||
}
|
||
|
||
// 时:分:秒
|
||
if (h > 0) {
|
||
return nx.text.formatS("%d:%s:%s", h, f(m), f(s));
|
||
}
|
||
|
||
// 分:秒
|
||
if (m > 0) {
|
||
return nx.text.formatS("%s:%s", f(m), f(s));
|
||
}
|
||
|
||
// 秒
|
||
return '00:' + f(s);
|
||
},
|
||
// 计算剩余天数(向上取整)
|
||
// _ts: 秒级时间戳
|
||
getDaysFromNow: function getDaysFromNow(_ts) {
|
||
var secs = Math.max(0, _ts - cc.sys.now() / 1000);
|
||
var days = Math.ceil(secs / (24 * 3600));
|
||
return days;
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：URL的方法
|
||
// ------------------------------------------------------------
|
||
|
||
// 格式化URL
|
||
formatURL: function formatURL(_url, _args) {
|
||
if (!this.strNEmpty(_url)) {
|
||
nx.error("WebTask:URL参数不能为空！");
|
||
return "";
|
||
}
|
||
if (!this.objGood(_args)) {
|
||
return encodeURI(_url);
|
||
}
|
||
var aline = "";
|
||
for (var k in _args) {
|
||
aline += aline == "" ? "?" : "&";
|
||
var v = _args[k];
|
||
var o = this.objGood(v) || this.arrGood(v);
|
||
aline += k + "=" + (o ? nx.dt.enjson(v) : v);
|
||
}
|
||
return encodeURI(_url + aline);
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：数量方法
|
||
// ------------------------------------------------------------
|
||
|
||
/**
|
||
* 数量千分化
|
||
* @param {*} _count : 数量
|
||
* @param {*} _pn : 小数位数
|
||
* @returns
|
||
*/
|
||
fmtCount: function fmtCount(_count, _pn) {
|
||
if (!nx.dt.numPositive(_pn) || _pn < 0 || _pn > 20) {
|
||
_pn = DefPN;
|
||
}
|
||
_count = parseFloat((_count + "").replace(/[^\d\.-]/g, "")).toFixed(_pn) + "";
|
||
var l = _count.split(".")[0].split("").reverse();
|
||
var r = _count.split(".")[1];
|
||
var t = "";
|
||
for (var i = 0; i < l.length; i++) {
|
||
t += l[i] + ((i + 1) % 3 == 0 && i + 1 != l.length ? "," : "");
|
||
}
|
||
if (r) {
|
||
var ret = t.split("").reverse().join("") + "." + r;
|
||
} else {
|
||
var ret = t.split("").reverse().join("");
|
||
}
|
||
if ((ret.charAt(0) == "-" || ret.charAt(0) == "+") && ret.charAt(1) == ",") {
|
||
ret = ret.charAt(0) + ret.slice(2);
|
||
}
|
||
return ret;
|
||
},
|
||
/**
|
||
* 数量简化
|
||
* @param {*} _count 数量
|
||
* @param {*} _sdd 强制+号
|
||
* @param {*} _pn 小数位数
|
||
* @param {*} _trimZero 忽略尾部0
|
||
* @returns
|
||
*/
|
||
shortCount: function shortCount(_count, _sdd, _pn, _trimZero) {
|
||
if (_sdd === void 0) {
|
||
_sdd = false;
|
||
}
|
||
if (_pn === void 0) {
|
||
_pn = 2;
|
||
}
|
||
if (_trimZero === void 0) {
|
||
_trimZero = true;
|
||
}
|
||
// 转数字
|
||
_count = parseInt(_count);
|
||
if (!this.numGood(_count)) {
|
||
_count = 0;
|
||
}
|
||
var lessZero = false;
|
||
if (_count < 0) {
|
||
lessZero = true;
|
||
_count *= -1;
|
||
}
|
||
if (!this.numPositive(_pn)) {
|
||
_pn = DefPN;
|
||
}
|
||
var value = "";
|
||
var unitKey = "";
|
||
|
||
// 国际通用KM小数点后保留2位来展示
|
||
// 小于1K
|
||
// if( _count < 1000 ) {
|
||
if (_count < 100000000) {
|
||
value = "" + this.toFixedDecimal(_count);
|
||
if (!_trimZero) {
|
||
value = this.fmtCount(value, _pn);
|
||
}
|
||
}
|
||
// // 1M > _count >= 1K
|
||
// else if( _count >= 1000 && _count < 1000000 ) {
|
||
// value = this.toFixedDecimal( _count / 1000 ).toFixed( _pn );
|
||
// unitKey = "K";
|
||
// }
|
||
// 1B > _count >= 1M
|
||
else if (_count >= 100000000 && _count < 1000000000) {
|
||
value = this.toFixedDecimal(_count / 1000000).toFixed(_pn);
|
||
unitKey = "M";
|
||
}
|
||
// >= 1B
|
||
else {
|
||
value = this.toFixedDecimal(_count / 1000000000).toFixed(_pn);
|
||
unitKey = "B";
|
||
}
|
||
|
||
// 末尾0忽略
|
||
if (_trimZero) {
|
||
value = Number(value) + unitKey;
|
||
} else {
|
||
value += unitKey;
|
||
}
|
||
if (lessZero) {
|
||
value = "-" + value;
|
||
} else {
|
||
if (_sdd === true) {
|
||
value = "+" + value;
|
||
}
|
||
}
|
||
return value;
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：WEB参数解析
|
||
// ------------------------------------------------------------
|
||
|
||
// 获取URL网址参数
|
||
parseURLArgs: function parseURLArgs() {
|
||
var theRequest = {};
|
||
|
||
// 非浏览器不处理
|
||
if (!cc.sys.isBrowser || !location) {
|
||
return theRequest;
|
||
}
|
||
|
||
// 获取url中"?"符后的字串
|
||
var url = location.search;
|
||
if (url.indexOf("?") != -1) {
|
||
var str = url.substr(1);
|
||
var strs = str.split("&");
|
||
for (var i = 0; i < strs.length; i++) {
|
||
theRequest[strs[i].split("=")[0]] = unescape(strs[i].split("=")[1]);
|
||
}
|
||
}
|
||
return theRequest;
|
||
},
|
||
// 针对URL不正规的参数解析
|
||
queryURLArg: function queryURLArg(_key) {
|
||
// 非浏览器不处理
|
||
if (!cc.sys.isBrowser || !window.location) {
|
||
return null;
|
||
}
|
||
var reg = new RegExp('(^|&)' + _key + '=([^&]*)(&|$)', 'i');
|
||
var serach = '';
|
||
if (window.location.search.length > 0) {
|
||
serach = window.location.search.substr(1);
|
||
} else {
|
||
serach = window.location.href.split('?')[1] ? window.location.href.split('?')[1] : '';
|
||
}
|
||
var r = serach.match(reg);
|
||
if (r != null) {
|
||
return unescape(r[2]);
|
||
}
|
||
return null;
|
||
},
|
||
// ------------------------------------------------------------
|
||
// 方法集：距离的方法
|
||
// ------------------------------------------------------------
|
||
|
||
// 格式化距离
|
||
formatDistance: function formatDistance(_meters) {
|
||
if (typeof _meters != "number") {
|
||
return nx.text.format("distance_none");
|
||
}
|
||
if (_meters < 1000) {
|
||
return nx.text.format("distance_m", _meters);
|
||
}
|
||
var km = Math.floor(_meters / 1000);
|
||
return nx.text.format("distance_km", km);
|
||
},
|
||
// 文件大小字节转K,M,G
|
||
formatFileSize: function formatFileSize(_size) {
|
||
if (!_size) {
|
||
return "";
|
||
}
|
||
var num = 1024.00; //byte
|
||
|
||
if (_size < num) return _size + "B";
|
||
if (_size < Math.pow(num, 2)) return (_size / num).toFixed(2) + "K"; //kb
|
||
if (_size < Math.pow(num, 3)) return (_size / Math.pow(num, 2)).toFixed(2) + "M"; //M
|
||
if (_size < Math.pow(num, 4)) return (_size / Math.pow(num, 3)).toFixed(2) + "G"; //G
|
||
return (_size / Math.pow(num, 4)).toFixed(2) + "T"; //T
|
||
},
|
||
|
||
// 检测账号是否包含中文
|
||
formatAccount: function formatAccount(str) {
|
||
if (typeof str !== 'string') {
|
||
return false;
|
||
}
|
||
|
||
//去除字符串的左右两边空格
|
||
//+表示匹配一次或多次，|表示或者，\s和\u00A0匹配空白字符，/^以……开头，$以……结尾，/g全局匹配,/i忽略大小写
|
||
str = (str || "").replace(/^(\s|\u00A0)+|(\s|\u00A0)+$/g, "");
|
||
//匹配中文，match返回包含中文的数组
|
||
var chinese = str.match(/[\u4e00-\u9fa5]/g);
|
||
//计算字符个数
|
||
return !!chinese;
|
||
},
|
||
// 检测姓名是否是中文
|
||
formatChineseName: function formatChineseName(str) {
|
||
if (str.length <= 1) {
|
||
return false;
|
||
}
|
||
var re = /[^\u4e00-\u9fa5]/;
|
||
return !re.test(str);
|
||
},
|
||
// 随机字符串生成
|
||
randomStr: function randomStr(min, max, strRange) {
|
||
var rd = function rd(_l, _r) {
|
||
if (_r > _l) {
|
||
return Math.round(Math.random() * (_r - _l)) + _l;
|
||
} else {
|
||
return _l;
|
||
}
|
||
};
|
||
var str = "";
|
||
strRange = strRange || '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
|
||
var n = rd(min, max);
|
||
var len = strRange.length;
|
||
for (var i = 0; i < n; i++) {
|
||
var pos = rd(1, len) - 1;
|
||
str += strRange.charAt(pos);
|
||
}
|
||
return str;
|
||
}
|
||
});
|
||
|
||
// 模块导出
|
||
module.exports = NxMath;
|
||
|
||
cc._RF.pop(); |