CocosPlugin/esengine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

新增StringUtils.isNullOrEmpty方法

Browse Source
This commit is contained in:
yhh
2021-08-26 13:58:09 +08:00
parent 5d1609111c
commit a4b971bba0
4 changed files with 555 additions and 519 deletions
Download Patch File Download Diff File Expand all files Collapse all files

170
source/bin/framework.d.ts vendored
View File

@@ -2093,87 +2093,95 @@ declare module es {
updateLists(): void; updateLists(): void;
} }
} }
declare class StringUtils { declare module es {
/** class StringUtils {
* 特殊符号字符串 /**
*/ * 特殊符号字符串
private static specialSigns; */
/** private static specialSigns;
* 匹配中文字符 /**
* @param str 需要匹配的字符串 * 匹配中文字符
* @return * @param str 需要匹配的字符串
*/ * @return
static matchChineseWord(str: string): string[]; */
/** static matchChineseWord(str: string): string[];
* 去除字符串左端的空白字符 /**
* @param target 目标字符串 * 去除字符串左端的空白字符
* @return * @param target 目标字符串
*/ * @return
static lTrim(target: string): string; */
/** static lTrim(target: string): string;
* 去除字符串右端的空白字符 /**
* @param target 目标字符串 * 去除字符串右端的空白字符
* @return * @param target 目标字符串
*/ * @return
static rTrim(target: string): string; */
/** static rTrim(target: string): string;
* 返回一个去除2段空白字符的字符串 /**
* @param target * 返回一个去除2段空白字符的字符串
* @return 返回一个去除2段空白字符的字符串 * @param target
*/ * @return 返回一个去除2段空白字符的字符串
static trim(target: string): string; */
/** static trim(target: string): string;
* 返回该字符是否为空白字符 /**
* @param str * 返回该字符是否为空白字符
* @return 返回该字符是否为空白字符 * @param str
*/ * @return 返回该字符是否为空白字符
static isWhiteSpace(str: string): boolean; */
/** static isWhiteSpace(str: string): boolean;
* 返回执行替换后的字符串 /**
* @param mainStr 待查找字符串 * 返回该字符是否为空字符或者为null
* @param targetStr 目标字符串 * @param str
* @param replaceStr 替换字符串 * @returns
* @param caseMark 是否忽略大小写 */
* @return 返回执行替换后的字符串 static isNullOrEmpty(str: string): boolean;
*/ /**
static replaceMatch(mainStr: string, targetStr: string, replaceStr: string, caseMark?: boolean): string; * 返回执行替换后的字符串
/** * @param mainStr 待查找字符串
* 用html实体换掉字符窜中的特殊字符 * @param targetStr 目标字符串
* @param str 需要替换的字符串 * @param replaceStr 替换字符串
* @param reversion 是否翻转替换：将转义符号替换为正常的符号 * @param caseMark 是否忽略大小写
* @return 换掉特殊字符后的字符串 * @return 返回执行替换后的字符串
*/ */
static htmlSpecialChars(str: string, reversion?: boolean): string; static replaceMatch(mainStr: string, targetStr: string, replaceStr: string, caseMark?: boolean): string;
/** /**
* 给数字字符前面添 "0" * 用html实体换掉字符窜中的特殊字符
* * @param str 需要替换的字符串
* @param str 要进行处理的字符串 * @param reversion 是否翻转替换：将转义符号替换为正常的符号
* @param width 处理后字符串的长度， * @return 换掉特殊字符后的字符串
* 如果str.length >= width，将不做任何处理直接返回原始的str。 */
* @return static htmlSpecialChars(str: string, reversion?: boolean): string;
* /**
*/ * 给数字字符前面添 "0"
static zfill(str: string, width?: number): string; *
/** * @param str 要进行处理的字符串
* 翻转字符串 * @param width 处理后字符串的长度，
* @param str 字符串 * 如果str.length >= width，将不做任何处理直接返回原始的str。
* @return 翻转后的字符串 * @return
*/ *
static reverse(str: string): string; */
/** static zfill(str: string, width?: number): string;
* 截断某段字符串 /**
* @param str 目标字符串 * 翻转字符串
* @param start 需要截断的起始索引 * @param str 字符串
* @param en 截断长度 * @return 翻转后的字符串
* @param order 顺序，true从字符串头部开始计算，false从字符串尾巴开始结算。 */
* @return 截断后的字符串 static reverse(str: string): string;
*/ /**
static cutOff(str: string, start: number, len: number, order?: boolean): string; * 截断某段字符串
/** * @param str 目标字符串
* {0} 字符替换 * @param start 需要截断的起始索引
*/ * @param en 截断长度
static strReplace(str: string, rStr: string[]): string; * @param order 顺序，true从字符串头部开始计算，false从字符串尾巴开始结算。
static format(str: string, ...args: any[]): string; * @return 截断后的字符串
*/
static cutOff(str: string, start: number, len: number, order?: boolean): string;
/**
* {0} 字符替换
*/
static strReplace(str: string, rStr: string[]): string;
static format(str: string, ...args: any[]): string;
}
} }
declare module es { declare module es {
/** 提供帧定时信息 */ /** 提供帧定时信息 */

454
source/bin/framework.js
View File

@@ -301,19 +301,19 @@ var es;
} }
switch (type) { switch (type) {
case LogType.error: case LogType.error:
console.error(type + ": " + StringUtils.format(format, args)); console.error(type + ": " + es.StringUtils.format(format, args));
break; break;
case LogType.warn: case LogType.warn:
console.warn(type + ": " + StringUtils.format(format, args)); console.warn(type + ": " + es.StringUtils.format(format, args));
break; break;
case LogType.log: case LogType.log:
console.log(type + ": " + StringUtils.format(format, args)); console.log(type + ": " + es.StringUtils.format(format, args));
break; break;
case LogType.info: case LogType.info:
console.info(type + ": " + StringUtils.format(format, args)); console.info(type + ": " + es.StringUtils.format(format, args));
break; break;
case LogType.trace: case LogType.trace:
console.trace(type + ": " + StringUtils.format(format, args)); console.trace(type + ": " + es.StringUtils.format(format, args));
break; break;
default: default:
throw new Error('argument out of range'); throw new Error('argument out of range');
@@ -360,7 +360,7 @@ var es;
console.assert(false); console.assert(false);
} }
else { else {
console.assert(false, StringUtils.format(message, args)); console.assert(false, es.StringUtils.format(message, args));
} }
}; };
Insist.isTrue = function (condition, message) { Insist.isTrue = function (condition, message) {
@@ -5468,229 +5468,243 @@ var es;
}()); }());
es.RenderableComponentList = RenderableComponentList; es.RenderableComponentList = RenderableComponentList;
})(es || (es = {})); })(es || (es = {}));
var StringUtils = /** @class */ (function () { var es;
function StringUtils() { (function (es) {
} var StringUtils = /** @class */ (function () {
/** function StringUtils() {
* 匹配中文字符
* @param str 需要匹配的字符串
* @return
*/
StringUtils.matchChineseWord = function (str) {
//中文字符的unicode值[\u4E00-\u9FA5]
var patternA = /[\u4E00-\u9FA5]+/gim;
return str.match(patternA);
};
/**
* 去除字符串左端的空白字符
* @param target 目标字符串
* @return
*/
StringUtils.lTrim = function (target) {
var startIndex = 0;
while (this.isWhiteSpace(target.charAt(startIndex))) {
startIndex++;
} }
return target.slice(startIndex, target.length); /**
}; * 匹配中文字符
/** * @param str 需要匹配的字符串
* 去除字符串右端的空白字符 * @return
* @param target 目标字符串 */
* @return StringUtils.matchChineseWord = function (str) {
*/ //中文字符的unicode值[\u4E00-\u9FA5]
StringUtils.rTrim = function (target) { var patternA = /[\u4E00-\u9FA5]+/gim;
var endIndex = target.length - 1; return str.match(patternA);
while (this.isWhiteSpace(target.charAt(endIndex))) { };
endIndex--; /**
} * 去除字符串左端的空白字符
return target.slice(0, endIndex + 1); * @param target 目标字符串
}; * @return
/** */
* 返回一个去除2段空白字符的字符串 StringUtils.lTrim = function (target) {
* @param target var startIndex = 0;
* @return 返回一个去除2段空白字符的字符串 while (this.isWhiteSpace(target.charAt(startIndex))) {
*/ startIndex++;
StringUtils.trim = function (target) { }
if (target == null) { return target.slice(startIndex, target.length);
return null; };
} /**
return this.rTrim(this.lTrim(target)); * 去除字符串右端的空白字符
}; * @param target 目标字符串
/** * @return
* 返回该字符是否为空白字符 */
* @param str StringUtils.rTrim = function (target) {
* @return 返回该字符是否为空白字符 var endIndex = target.length - 1;
*/ while (this.isWhiteSpace(target.charAt(endIndex))) {
StringUtils.isWhiteSpace = function (str) { endIndex--;
if (str == " " || str == "\t" || str == "\r" || str == "\n") }
return true; return target.slice(0, endIndex + 1);
return false; };
}; /**
/** * 返回一个去除2段空白字符的字符串
* 返回执行替换后的字符串 * @param target
* @param mainStr 待查找字符串 * @return 返回一个去除2段空白字符的字符串
* @param targetStr 目标字符串 */
* @param replaceStr 替换字符串 StringUtils.trim = function (target) {
* @param caseMark 是否忽略大小写 if (target == null) {
* @return 返回执行替换后的字符串 return null;
*/ }
StringUtils.replaceMatch = function (mainStr, targetStr, replaceStr, caseMark) { return this.rTrim(this.lTrim(target));
if (caseMark === void 0) { caseMark = false; } };
var len = mainStr.length; /**
var tempStr = ""; * 返回该字符是否为空白字符
var isMatch = false; * @param str
var tempTarget = caseMark == true ? targetStr.toLowerCase() : targetStr; * @return 返回该字符是否为空白字符
for (var i = 0; i < len; i++) { */
isMatch = false; StringUtils.isWhiteSpace = function (str) {
if (mainStr.charAt(i) == tempTarget.charAt(0)) { if (str == " " || str == "\t" || str == "\r" || str == "\n")
if (mainStr.substr(i, tempTarget.length) == tempTarget) { return true;
isMatch = true; return false;
};
/**
* 返回该字符是否为空字符或者为null
* @param str
* @returns
*/
StringUtils.isNullOrEmpty = function (str) {
if (str == "" || str == null || str == undefined)
return true;
return false;
};
/**
* 返回执行替换后的字符串
* @param mainStr 待查找字符串
* @param targetStr 目标字符串
* @param replaceStr 替换字符串
* @param caseMark 是否忽略大小写
* @return 返回执行替换后的字符串
*/
StringUtils.replaceMatch = function (mainStr, targetStr, replaceStr, caseMark) {
if (caseMark === void 0) { caseMark = false; }
var len = mainStr.length;
var tempStr = "";
var isMatch = false;
var tempTarget = caseMark == true ? targetStr.toLowerCase() : targetStr;
for (var i = 0; i < len; i++) {
isMatch = false;
if (mainStr.charAt(i) == tempTarget.charAt(0)) {
if (mainStr.substr(i, tempTarget.length) == tempTarget) {
isMatch = true;
}
}
if (isMatch) {
tempStr += replaceStr;
i = i + tempTarget.length - 1;
}
else {
tempStr += mainStr.charAt(i);
} }
} }
if (isMatch) { return tempStr;
tempStr += replaceStr; };
i = i + tempTarget.length - 1; /**
* 用html实体换掉字符窜中的特殊字符
* @param str 需要替换的字符串
* @param reversion 是否翻转替换：将转义符号替换为正常的符号
* @return 换掉特殊字符后的字符串
*/
StringUtils.htmlSpecialChars = function (str, reversion) {
if (reversion === void 0) { reversion = false; }
var len = this.specialSigns.length;
for (var i = 0; i < len; i += 2) {
var from = void 0;
var to = void 0;
from = this.specialSigns[i];
to = this.specialSigns[i + 1];
if (reversion) {
var temp = from;
from = to;
to = temp;
}
str = this.replaceMatch(str, from, to);
}
return str;
};
/**
* 给数字字符前面添 "0"
*
* @param str 要进行处理的字符串
* @param width 处理后字符串的长度，
* 如果str.length >= width，将不做任何处理直接返回原始的str。
* @return
*
*/
StringUtils.zfill = function (str, width) {
if (width === void 0) { width = 2; }
if (!str) {
return str;
}
width = Math.floor(width);
var slen = str.length;
if (slen >= width) {
return str;
}
var negative = false;
if (str.substr(0, 1) == '-') {
negative = true;
str = str.substr(1);
}
var len = width - slen;
for (var i = 0; i < len; i++) {
str = '0' + str;
}
if (negative) {
str = '-' + str;
}
return str;
};
/**
* 翻转字符串
* @param str 字符串
* @return 翻转后的字符串
*/
StringUtils.reverse = function (str) {
if (str.length > 1)
return this.reverse(str.substring(1)) + str.substring(0, 1);
else
return str;
};
/**
* 截断某段字符串
* @param str 目标字符串
* @param start 需要截断的起始索引
* @param en 截断长度
* @param order 顺序，true从字符串头部开始计算，false从字符串尾巴开始结算。
* @return 截断后的字符串
*/
StringUtils.cutOff = function (str, start, len, order) {
if (order === void 0) { order = true; }
start = Math.floor(start);
len = Math.floor(len);
var length = str.length;
if (start > length)
start = length;
var s = start;
var e = start + len;
var newStr;
if (order) {
newStr = str.substring(0, s) + str.substr(e, length);
} }
else { else {
tempStr += mainStr.charAt(i); s = length - 1 - start - len;
e = s + len;
newStr = str.substring(0, s + 1) + str.substr(e + 1, length);
} }
} return newStr;
return tempStr; };
}; /**
/** * {0} 字符替换
* 用html实体换掉字符窜中的特殊字符 */
* @param str 需要替换的字符串 StringUtils.strReplace = function (str, rStr) {
* @param reversion 是否翻转替换：将转义符号替换为正常的符号 var i = 0, len = rStr.length;
* @return 换掉特殊字符后的字符串 for (; i < len; i++) {
*/ if (rStr[i] == null || rStr[i] == "") {
StringUtils.htmlSpecialChars = function (str, reversion) { rStr[i] = "无";
if (reversion === void 0) { reversion = false; } }
var len = this.specialSigns.length; str = str.replace("{" + i + "}", rStr[i]);
for (var i = 0; i < len; i += 2) {
var from = void 0;
var to = void 0;
from = this.specialSigns[i];
to = this.specialSigns[i + 1];
if (reversion) {
var temp = from;
from = to;
to = temp;
} }
str = this.replaceMatch(str, from, to);
}
return str;
};
/**
* 给数字字符前面添 "0"
*
* @param str 要进行处理的字符串
* @param width 处理后字符串的长度，
* 如果str.length >= width，将不做任何处理直接返回原始的str。
* @return
*
*/
StringUtils.zfill = function (str, width) {
if (width === void 0) { width = 2; }
if (!str) {
return str; return str;
} };
width = Math.floor(width); StringUtils.format = function (str) {
var slen = str.length; var args = [];
if (slen >= width) { for (var _i = 1; _i < arguments.length; _i++) {
return str; args[_i - 1] = arguments[_i];
}
var negative = false;
if (str.substr(0, 1) == '-') {
negative = true;
str = str.substr(1);
}
var len = width - slen;
for (var i = 0; i < len; i++) {
str = '0' + str;
}
if (negative) {
str = '-' + str;
}
return str;
};
/**
* 翻转字符串
* @param str 字符串
* @return 翻转后的字符串
*/
StringUtils.reverse = function (str) {
if (str.length > 1)
return this.reverse(str.substring(1)) + str.substring(0, 1);
else
return str;
};
/**
* 截断某段字符串
* @param str 目标字符串
* @param start 需要截断的起始索引
* @param en 截断长度
* @param order 顺序，true从字符串头部开始计算，false从字符串尾巴开始结算。
* @return 截断后的字符串
*/
StringUtils.cutOff = function (str, start, len, order) {
if (order === void 0) { order = true; }
start = Math.floor(start);
len = Math.floor(len);
var length = str.length;
if (start > length)
start = length;
var s = start;
var e = start + len;
var newStr;
if (order) {
newStr = str.substring(0, s) + str.substr(e, length);
}
else {
s = length - 1 - start - len;
e = s + len;
newStr = str.substring(0, s + 1) + str.substr(e + 1, length);
}
return newStr;
};
/**
* {0} 字符替换
*/
StringUtils.strReplace = function (str, rStr) {
var i = 0, len = rStr.length;
for (; i < len; i++) {
if (rStr[i] == null || rStr[i] == "") {
rStr[i] = "无";
} }
str = str.replace("{" + i + "}", rStr[i]); for (var i = 0; i < args.length - 1; i++) {
} var reg = new RegExp("\\{" + i + "\\}", "gm");
return str; str = str.replace(reg, args[i + 1]);
}; }
StringUtils.format = function (str) { return str;
var args = []; };
for (var _i = 1; _i < arguments.length; _i++) { /**
args[_i - 1] = arguments[_i]; * 特殊符号字符串
} */
for (var i = 0; i < args.length - 1; i++) { StringUtils.specialSigns = [
var reg = new RegExp("\\{" + i + "\\}", "gm"); '&', '&amp;',
str = str.replace(reg, args[i + 1]); '<', '&lt;',
} '>', '&gt;',
return str; '"', '&quot;',
}; "'", '&apos;',
/** '®', '&reg;',
* 特殊符号字符串 '©', '&copy;',
*/ '™', '&trade;',
StringUtils.specialSigns = [ ];
'&', '&amp;', return StringUtils;
'<', '&lt;', }());
'>', '&gt;', es.StringUtils = StringUtils;
'"', '&quot;', })(es || (es = {}));
"'", '&apos;',
'®', '&reg;',
'©', '&copy;',
'™', '&trade;',
];
return StringUtils;
}());
var es; var es;
(function (es) { (function (es) {
/** 提供帧定时信息 */ /** 提供帧定时信息 */

2
source/bin/framework.min.js vendored
View File

File diff suppressed because one or more lines are too long

432
source/src/ECS/Utils/StringUtils.ts
View File

@@ -1,231 +1,245 @@
class StringUtils { module es {
/** export class StringUtils {
* 特殊符号字符串 /**
*/ * 特殊符号字符串
private static specialSigns: string[] = [ */
'&', '&amp;', private static specialSigns: string[] = [
'<', '&lt;', '&', '&amp;',
'>', '&gt;', '<', '&lt;',
'"', '&quot;', '>', '&gt;',
"'", '&apos;', '"', '&quot;',
'®', '&reg;', "'", '&apos;',
'©', '&copy;', '®', '&reg;',
'™', '&trade;', '©', '&copy;',
]; '™', '&trade;',
];
/** /**
* 匹配中文字符 * 匹配中文字符
* @param str 需要匹配的字符串 * @param str 需要匹配的字符串
* @return * @return
*/ */
public static matchChineseWord(str: string): string[] { public static matchChineseWord(str: string): string[] {
//中文字符的unicode值[\u4E00-\u9FA5] //中文字符的unicode值[\u4E00-\u9FA5]
let patternA: RegExp = /[\u4E00-\u9FA5]+/gim; let patternA: RegExp = /[\u4E00-\u9FA5]+/gim;
return str.match(patternA); return str.match(patternA);
}
/**
* 去除字符串左端的空白字符
* @param target 目标字符串
* @return
*/
public static lTrim(target: string): string {
let startIndex: number = 0;
while (this.isWhiteSpace(target.charAt(startIndex))) {
startIndex++;
} }
return target.slice(startIndex, target.length);
}
/** /**
* 去除字符串右端的空白字符 * 去除字符串左端的空白字符
* @param target 目标字符串 * @param target 目标字符串
* @return * @return
*/ */
public static rTrim(target: string): string { public static lTrim(target: string): string {
let endIndex: number = target.length - 1; let startIndex: number = 0;
while (this.isWhiteSpace(target.charAt(endIndex))) { while (this.isWhiteSpace(target.charAt(startIndex))) {
endIndex--; startIndex++;
}
return target.slice(startIndex, target.length);
} }
return target.slice(0, endIndex + 1);
}
/** /**
* 返回一个去除2段空白字符的字符串 * 去除字符串右端的空白字符
* @param target * @param target 目标字符串
* @return 返回一个去除2段空白字符的字符串 * @return
*/ */
public static trim(target: string): string { public static rTrim(target: string): string {
if (target == null) { let endIndex: number = target.length - 1;
return null; while (this.isWhiteSpace(target.charAt(endIndex))) {
endIndex--;
}
return target.slice(0, endIndex + 1);
} }
return this.rTrim(this.lTrim(target));
}
/** /**
* 返回该字符是否为空白字符 * 返回一个去除2段空白字符的字符串
* @param str * @param target
* @return 返回该字符是否为空白字符 * @return 返回一个去除2段空白字符的字符串
*/ */
public static isWhiteSpace(str: string): boolean { public static trim(target: string): string {
if (str == " " || str == "\t" || str == "\r" || str == "\n") if (target == null) {
return true; return null;
return false; }
} return this.rTrim(this.lTrim(target));
}
/** /**
* 返回执行替换后的字符串 * 返回该字符是否为空白字符
* @param mainStr 待查找字符串 * @param str
* @param targetStr 目标字符串 * @return 返回该字符是否为空白字符
* @param replaceStr 替换字符串 */
* @param caseMark 是否忽略大小写 public static isWhiteSpace(str: string): boolean {
* @return 返回执行替换后的字符串 if (str == " " || str == "\t" || str == "\r" || str == "\n")
*/ return true;
public static replaceMatch(mainStr: string, targetStr: string, return false;
replaceStr: string, caseMark: boolean = false): string { }
let len: number = mainStr.length;
let tempStr: string = ""; /**
let isMatch: boolean = false; * 返回该字符是否为空字符或者为null
let tempTarget: string = caseMark == true ? targetStr.toLowerCase() : targetStr; * @param str
for (let i: number = 0; i < len; i++) { * @returns
isMatch = false; */
if (mainStr.charAt(i) == tempTarget.charAt(0)) { public static isNullOrEmpty(str: string): boolean {
if (mainStr.substr(i, tempTarget.length) == tempTarget) { if (str == "" || str == null || str == undefined)
isMatch = true; return true;
return false;
}
/**
* 返回执行替换后的字符串
* @param mainStr 待查找字符串
* @param targetStr 目标字符串
* @param replaceStr 替换字符串
* @param caseMark 是否忽略大小写
* @return 返回执行替换后的字符串
*/
public static replaceMatch(mainStr: string, targetStr: string,
replaceStr: string, caseMark: boolean = false): string {
let len: number = mainStr.length;
let tempStr: string = "";
let isMatch: boolean = false;
let tempTarget: string = caseMark == true ? targetStr.toLowerCase() : targetStr;
for (let i: number = 0; i < len; i++) {
isMatch = false;
if (mainStr.charAt(i) == tempTarget.charAt(0)) {
if (mainStr.substr(i, tempTarget.length) == tempTarget) {
isMatch = true;
}
}
if (isMatch) {
tempStr += replaceStr;
i = i + tempTarget.length - 1;
} else {
tempStr += mainStr.charAt(i);
} }
} }
if (isMatch) { return tempStr;
tempStr += replaceStr; }
i = i + tempTarget.length - 1;
/**
* 用html实体换掉字符窜中的特殊字符
* @param str 需要替换的字符串
* @param reversion 是否翻转替换：将转义符号替换为正常的符号
* @return 换掉特殊字符后的字符串
*/
public static htmlSpecialChars(str: string, reversion: boolean = false): string {
let len: number = this.specialSigns.length;
for (let i: number = 0; i < len; i += 2) {
let from: string;
let to: string;
from = this.specialSigns[i];
to = this.specialSigns[i + 1];
if (reversion) {
let temp: string = from;
from = to;
to = temp;
}
str = this.replaceMatch(str, from, to);
}
return str;
}
/**
* 给数字字符前面添 "0"
*
* @param str 要进行处理的字符串
* @param width 处理后字符串的长度，
* 如果str.length >= width，将不做任何处理直接返回原始的str。
* @return
*
*/
public static zfill(str: string, width: number = 2): string {
if (!str) {
return str;
}
width = Math.floor(width);
let slen: number = str.length;
if (slen >= width) {
return str;
}
let negative: boolean = false;
if (str.substr(0, 1) == '-') {
negative = true;
str = str.substr(1);
}
let len: number = width - slen;
for (let i: number = 0; i < len; i++) {
str = '0' + str;
}
if (negative) {
str = '-' + str;
}
return str;
}
/**
* 翻转字符串
* @param str 字符串
* @return 翻转后的字符串
*/
public static reverse(str: string): string {
if (str.length > 1)
return this.reverse(str.substring(1)) + str.substring(0, 1);
else
return str;
}
/**
* 截断某段字符串
* @param str 目标字符串
* @param start 需要截断的起始索引
* @param en 截断长度
* @param order 顺序，true从字符串头部开始计算，false从字符串尾巴开始结算。
* @return 截断后的字符串
*/
public static cutOff(str: string, start: number,
len: number, order: boolean = true): string {
start = Math.floor(start);
len = Math.floor(len);
let length: number = str.length;
if (start > length) start = length;
let s: number = start;
let e: number = start + len;
let newStr: string;
if (order) {
newStr = str.substring(0, s) + str.substr(e, length);
} else { } else {
tempStr += mainStr.charAt(i); s = length - 1 - start - len;
e = s + len;
newStr = str.substring(0, s + 1) + str.substr(e + 1, length);
} }
return newStr;
} }
return tempStr;
}
/** /**
* 用html实体换掉字符窜中的特殊字符 * {0} 字符替换
* @param str 需要替换的字符串 */
* @param reversion 是否翻转替换：将转义符号替换为正常的符号 public static strReplace(str: string, rStr: string[]): string {
* @return 换掉特殊字符后的字符串 let i: number = 0, len: number = rStr.length;
*/ for (; i < len; i++) {
public static htmlSpecialChars(str: string, reversion: boolean = false): string { if (rStr[i] == null || rStr[i] == "") {
let len: number = this.specialSigns.length; rStr[i] = "无";
for (let i: number = 0; i < len; i += 2) { }
let from: string; str = str.replace("{" + i + "}", rStr[i]);
let to: string;
from = this.specialSigns[i];
to = this.specialSigns[i + 1];
if (reversion) {
let temp: string = from;
from = to;
to = temp;
} }
str = this.replaceMatch(str, from, to); return str
} }
return str;
}
public static format(str: string, ...args: any[]) {
for (let i = 0; i < args.length - 1; i++) {
let reg = new RegExp("\\{" + i + "\\}", "gm");
str = str.replace(reg, args[i + 1]);
}
/**
* 给数字字符前面添 "0"
*
* @param str 要进行处理的字符串
* @param width 处理后字符串的长度，
* 如果str.length >= width，将不做任何处理直接返回原始的str。
* @return
*
*/
public static zfill(str: string, width: number = 2): string {
if (!str) {
return str; return str;
} }
width = Math.floor(width);
let slen: number = str.length;
if (slen >= width) {
return str;
}
let negative: boolean = false;
if (str.substr(0, 1) == '-') {
negative = true;
str = str.substr(1);
}
let len: number = width - slen;
for (let i: number = 0; i < len; i++) {
str = '0' + str;
}
if (negative) {
str = '-' + str;
}
return str;
}
/**
* 翻转字符串
* @param str 字符串
* @return 翻转后的字符串
*/
public static reverse(str: string): string {
if (str.length > 1)
return this.reverse(str.substring(1)) + str.substring(0, 1);
else
return str;
}
/**
* 截断某段字符串
* @param str 目标字符串
* @param start 需要截断的起始索引
* @param en 截断长度
* @param order 顺序，true从字符串头部开始计算，false从字符串尾巴开始结算。
* @return 截断后的字符串
*/
public static cutOff(str: string, start: number,
len: number, order: boolean = true): string {
start = Math.floor(start);
len = Math.floor(len);
let length: number = str.length;
if (start > length) start = length;
let s: number = start;
let e: number = start + len;
let newStr: string;
if (order) {
newStr = str.substring(0, s) + str.substr(e, length);
} else {
s = length - 1 - start - len;
e = s + len;
newStr = str.substring(0, s + 1) + str.substr(e + 1, length);
}
return newStr;
}
/**
* {0} 字符替换
*/
public static strReplace(str: string, rStr: string[]): string {
let i: number = 0, len: number = rStr.length;
for (; i < len; i++) {
if (rStr[i] == null || rStr[i] == "") {
rStr[i] = "无";
}
str = str.replace("{" + i + "}", rStr[i]);
}
return str
}
public static format(str: string, ...args: any[]) {
for (let i = 0; i < args.length - 1; i++) {
let reg = new RegExp("\\{" + i + "\\}", "gm");
str = str.replace(reg, args[i + 1]);
}
return str;
} }
} }