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