ouyang/fc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
8005de5bee5f100663542d2da47326260c1a0961
fc/dev/project/assets/Scripts/nx/kernel/nx.math.js
T

1079 lines
23 KiB
JavaScript
Raw Normal View History

首次提交
2026-05-23 22:10:14 +08:00
/*******************************************************************************
*
* Nx数据结构相关方法
*
*
*
* 2021.12.10
******************************************************************************/
require( "base64" );
require( "rseed" );
const md = require( "md5" );
// 默认小数位数
const DefPN = 2;
var NxMath = cc.Class( {
name: "NxMath",
// 创建
ctor: function() {
this.uuTracker = 1000;
},
// ------------------------------------------------------------
// 方法集：基本的数据类型判断
// ------------------------------------------------------------
// 数字
numGood: function( _n ) {
return _n === +_n;
},
// 正数
numPositive: function( _n, _inZero /* true */ ) {
if( !this.numGood( _n ) ) {
return false;
}
return ( _inZero !== false ) ? ( _n >= 0 ) : ( _n > 0 );
},
// 为X的数
numEqual: function( _n, _t ) {
return this.numGood( _n ) && ( _n == _t );
},
// 大于X的数
numGreater: function( _n, _t ) {
return this.numGood( _n ) && ( _n > _t );
},
// 小于X的数
numLess: function( _n, _t ) {
return this.numGood( _n ) && ( _n < _t );
},
// 范围内的数
numInRange: function( _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( _num, _def = 0 ) {
let ret = _num;
if( !nx.dt.numGood( ret ) ) {
ret = _def;
}
return ret;
},
// 浮点精确度
toFixedDecimal: function( _n ) {
if( !this.numGood( _n ) ) {
return 0;
}
// 多保留一位来保证浮点数精度
let fixedNumber = ( _n * 100 ).toFixed( 1 );
return Number( ( parseInt( fixedNumber ) / 100 ).toFixed( 2 ) );
},
// 布尔
isBool: function( _b ) {
return _b === !!_b;
},
// 字节数格式化
formatBytes: function( bytes, decimals = 2 ) {
if( bytes === 0 ) return '0 Bytes';
const k = 1024;
const dm = decimals & lt; 0 ? 0 : decimals;
const sizes = [ 'Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB' ];
const i = Math.floor( Math.log( bytes ) / Math.log( k ) );
return parseFloat( ( bytes / Math.pow( k, i ) ).toFixed( dm ) ) + ' ' + sizes[ i ];
},
// ------------------------------------------------------------
// 方法集：方法的方法
// ------------------------------------------------------------
// 有效方法
fnGood: function( _f ) {
return _f != null && typeof _f === "function";
},
// 空方法
fnEmpty: function() {
},
// 空方法报错
fnEmptyError: function( _fn ) {
if( this.fnGood( _fn ) ) {
nx.error( "方法已经存在:", _fn.name );
}
},
// 安全回调
fnInvoke: function( _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( _s ) {
return _s === _s + "";
},
// 非空字符串
strNEmpty: function( _s ) {
return this.strGood( _s ) && _s != "";
},
// 空字符串
strEmpty: function( _s ) {
return !this.strNEmpty( _s );
},
// 字符串去空格
strTrim: function( _s ) {
if( this.strNEmpty( _s ) ) {
return _s.replace( /^(\s|\u00A0)+/, "" ).replace( /(\s|\u00A0)+$/, "" );
}
return "";
},
// 获取字节长度
strBytes: function( _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( 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( 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( _sp ) {
let a = _sp.split( '#' );
if( a.length != 2 ) {
nx.error( "pairSplit失败,格式无效!", _sp );
return null;
}
let k = a[ 0 ];
let v = a[ 1 ];
// 如果值是数字,那么转为数字
if( Number( v ) == v ) {
v = Number( v );
}
return { [ k ]: v };
},
/**
* 特定key#value属性串转数组
* 用于统一拆分Array[String]数据
* @param {*} _arr
*/
arrPairSplit: function( _arr ) {
let ret = [];
if( this.arrEmpty( _arr ) ) {
return ret;
}
_arr.forEach( _sp => {
let d = this.pairSplit( _sp );
if( d ) {
ret.push( d );
}
} );
return ret;
},
/**
* 补零
* @param num： 被操作数
* @param n： 固定的总位数
*/
prefixZero: function( num, n ) {
return ( Array( n ).join( 0 ) + num ).slice( -n );
},
/**
* 字符串替换
* replaceAll
*/
replace: function( _str, _old, _new ) {
return _str.replace( new RegExp( _old, "gm" ), _new );
},
// ------------------------------------------------------------
// 方法集：数组的方法
// ------------------------------------------------------------
// 数组
arrGood: function( _a ) {
return Object.prototype.toString.call( _a ) === "[object Array]";
},
// 非空数组
arrNEmpty: function( _a ) {
return this.arrGood( _a ) && ( _a.length > 0 );
},
// 空数组
arrEmpty: function( _a ) {
return !this.arrNEmpty( _a );
},
// 是不是数组成员
arrMember: function( _a, _m, _fn ) {
if( !this.arrNEmpty( _a ) ) {
return false;
}
_fn = _fn || function( _v ) {
return _v == _m;
};
for( let i = 0; i < _a.length; ++i ) {
if( _fn( _a[ i ] ) ) {
return true;
}
}
return false;
},
// 合并数据[带关键字且不能重复]
arrConcat: function( _a1, _a2 ) {
if( !this.arrGood( _a1 ) || !this.arrGood( _a2 ) ) {
nx.error( "合并失败,参数不能为空!" );
return null;
}
// 合并Table绑定列表
if( CC_DEBUG ) {
var _exist = function( _key ) {
for( let k in _a1 ) {
var m = _a1[ k ];
if( m[ 0 ] == _key ) {
return true;
}
}
return false;
};
for( let i in _a2 ) {
var binder = _a2[ i ];
if( _exist( binder[ 0 ] ) ) {
nx.error( "合并失败: %s,有重复关键字项!", binder[ 0 ] );
return null;
}
}
}
return _a1.concat( _a2 );
},
// 从数组中删除
arrDelete: function( _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( _map ) {
if( !this.objGood( _map ) ) {
nx.warn( "对象为空,转换失败!" );
return [];
}
var pairs = [];
for( let i in _map ) {
pairs.push( [ i, _map[ i ] ] );
}
return pairs;
},
// 数组比较(成员相同)
arrCompare: function( _a, _b ) {
if( !this.arrGood( _a ) ||
!this.arrGood( _b ) ||
_a.length != _b.length ) {
return false;
}
for( let i in _a ) {
if( !this.arrMember( _b, _a[ i ] ) ) {
return false;
}
}
return true;
},
// ------------------------------------------------------------
// 方法集：对象的方法
// ------------------------------------------------------------
// 创建一个UUID(运行时唯一)
newUUID: function( _key ) {
if( !this.strNEmpty( _key ) ) {
_key = "OBJ";
}
return _key + ( ++this.uuTracker );
},
// 创建永不重复的Tag
newTag: function( _key ) {
let tag = this.md5( cc.sys.now().toString() );
if( this.strEmpty( _key ) ) {
return tag;
}
return _key + "." + tag;
},
// 空对象
objGood: function( _o ) {
return _o != null && typeof _o === "object" && Array.isArray( _o ) === false;
},
// 非空对象
objNEmpty: function( _o ) {
if( !this.objGood( _o ) ) {
return false;
}
return Object.keys( _o ).length > 0;
},
// 空对象
objEmpty: function( _o ) {
return !this.objNEmpty( _o );
},
// 对象合并
objConcat: function( _dic1, _dic2 ) {
if( !this.objGood( _dic1 ) ) {
return this.objClone( _dic2 );
}
if( !this.objGood( _dic1 ) ) {
return this.objClone( _dic1 );
}
var dic = this.objClone( _dic1 );
for( let k in _dic2 ) {
dic[ k ] = this.objClone( _dic2[ k ] );
}
return dic;
},
// 获取对象成员数量
objLen: function( _dic ) {
if( !this.objGood( _dic ) ) {
return 0;
}
return Object.keys( _dic ).length;
},
// 深复制
objClone: function( _obj ) {
// 非对象直接使用返回
if( !_obj || typeof ( _obj ) !== "object" ) {
return _obj;
}
var out = ( _obj.constructor === Array ) ? [] : {};
var _clone = function( 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( _object, _dic, _log = false ) {
if( !this.objGood( _object ) ||
!this.objGood( _dic ) ) {
return false;
}
if( _log ) {
nx.debug( "[DT]属性更新:" );
}
for( let k in _dic ) {
_object[ k ] = this.objClone( _dic[ k ] );
if( _log ) {
nx.debug( "\t\t键值: %s", k );
}
}
},
// ------------------------------------------------------------
// 方法集：随机数的方法
// ------------------------------------------------------------
// 范围随机数
randomRange( _min, _max ) {
var Range = _max - _min;
var Rand = Math.random();
var num = _min + Math.round( Rand * Range ); //四舍五入
return num;
},
// ------------------------------------------------------------
// 方法集：加密的方法
// ------------------------------------------------------------
// 获取md5
md5: function( key ) {
return md.hex_md5( key );
},
// 加密
encode64: function( 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( 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( _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( _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( _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() {
return Math.floor( cc.sys.now() / 1000 );
},
// 格式化日期
fmtDate: function( _date, _year = true ) {
_date = _date ? _date : new Date();
if( this.numGood( _date ) ) {
_date = new Date( _date );
}
var _format = function( 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( _date, _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( _date ) {
_date = _date ? _date : new Date();
var _format = function( 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( _secs, _full = false ) {
if( !this.numPositive( _secs, false ) ) {
return _full ? "00:00:00" : "00:00";
}
var f = function( 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( _ts ) {
let secs = Math.max( 0, _ts - ( cc.sys.now() / 1000 ) );
let days = Math.ceil( secs / ( 24 * 3600 ) );
return days;
},
// ------------------------------------------------------------
// 方法集：URL的方法
// ------------------------------------------------------------
// 格式化URL
formatURL: function( _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( _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( let 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( _count, _sdd = false, _pn = 2, _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;
}
let value = "";
let 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() {
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( _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( _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( _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( str ) {
if( typeof str !== 'string' ) {
return false;
}
//去除字符串的左右两边空格
//+表示匹配一次或多次，|表示或者，\s和\u00A0匹配空白字符，/^以……开头，$以……结尾，/g全局匹配,/i忽略大小写
str = ( str || "" ).replace( /^(\s|\u00A0)+|(\s|\u00A0)+$/g, "" );
//匹配中文，match返回包含中文的数组
const chinese = str.match( /[\u4e00-\u9fa5]/g );
//计算字符个数
return !!chinese;
},
// 检测姓名是否是中文
formatChineseName: function( str ) {
if( str.length <= 1 ) {
return false;
}
const re = /[^\u4e00-\u9fa5]/;
return !re.test( str );
},
// 随机字符串生成
randomStr: function( min, max, strRange ) {
const rd = function( _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;
Reference in New Issue Copy Permalink