工具函数

导入

通过如下方式导入工具函数api

import util from "svr-api/utils";

方法

/**
 * 工具函数
 */

/**
 * 解析xml内容，并返回xml文档对象。
 *
 * @param content xml内容，字符串或输入流
 */
export function parseXML(content: string | InputStream | File | Reader): XMLDocument;

/**
 * 从字符串或输入流中读取json对象，当内容是xml时也会将xml转换为json返回。
 * 
 * @param content 字符串或输入流，支持xml内容
 */
export function parseJSON(content: string | InputStream): any;

/**
 * 对字符串、文件、blob、输入流等进行 md5 方式的编码加密
 * @returns 返回16进制的字符串
 */
export function md5(str: any): string;

/**
 * 对字符串、文件、blob、输入流等进行 sha1 方式的编码加密
 * @returns 返回16进制的字符串
 */
export function sha1(str: any): string;

/**
 * 对字符串、文件、blob、输入流等进行 sha256 方式的编码加密
 * @returns 返回16进制的字符串
 */
export function sha256(str: any): string;

/**
 * 计算两个地点（经纬度）间的距离。 
 * 
 * @param lng1 地点1经度。
 * @param lat1 地点1纬度。
 * @param lng2 地点2经度。
 * @param lat2 地点2纬度。
 * @return
 */
export function geoDistance(lng1: number, lat1: number, lng2: number, lat2: number): number;

/**
 * 判断指定的地点，是否在指定的区域内。
 *
 * @param lng 地点经度
 * @param lat 地点纬度
 * @param geometrys 表示一个地理几何结构区域，如：
 *                  方圆500米`around(117.195907,39.118327, 500)`
 *                  矩形`rectangle(117.195907,39.118327, 116.925304,38.935671)`
 *                  多边形`polygon(117.195907,39.118327, 116.925304,38.935671, 117.654173,39.032846)`
 *                  也可以用分号分隔多个几何结构，比如要查询2个小学周边100米内的小卖部。
 * @return 返回布尔值。
 */
export function geoWithIn(lng: number, lat: number, geometrys: string): boolean;

/**
 * 生成一段随机字符串，和GUID不同的是,这里生成的串尽量短，如Fol8VS6XB,适合于临时文件名、cacheid等场合。
 * @param len 指定随机字符串长度
 */
export function randomString(len?: number): string;

/**
 * 生成一段纯数字的随机字符串
 * @param len 指定随机字符串长度
 */
export function randomNumberString(len: number): string;

/**
 * 生成一段uuid，生成一段uuid，为base64编码，仅含有数字和字母的字符串
 */
export function uuid(): string;

/**
 * 获取汉字的拼音。
 * 
 * @param str 汉字字符串
 * @param initial 是否只返回首字母,默认为true
 * @returns 返回拼音，首字母大写，其它字母小写
 */
export function pinyin(str: string, initial?: boolean): string;

/**
 * 确保字符串str以字符串suffix结尾或者以params中任意一个字符串结尾，返回处理之后的字符串
 * @example
 *  appendIfMissing(null, null) = null
 *  appendIfMissing("abc", null) = "abc"
 *  appendIfMissing("", "xyz") = "xyz"
 *  appendIfMissing("abcxyz", "xyz") = "abcxyz"
 *  appendIfMissing("abcXYZ", "xyz") = "abcXYZxyz"
 *  appendIfMissing("abc", "xyz" , "") = "abc"
 *  appendIfMissing("abc", "xyz", "mno") = "abcxyz"
 *  appendIfMissing("abcxyz", "xyz", "mno") = "abcxyz"
 *  appendIfMissing("abcmno", "xyz", "mno") = "abcmno"
 *  appendIfMissing("abcXYZ", "xyz", "mno") = "abcXYZxyz"
 * 说明：若字符串str既不以suffix结尾，也不以params中的任一项结尾，优先确保字符串str以字符串suffix结尾
 * @param str 用于验证的字符串
 * @param suffix 匹配结尾的字符串
 * @param params [可选] 匹配结尾的字符串
 */
export function appendIfMissing(str: string, suffix: string, ...params: any): string;

/**
 * 确保字符串str以字符串suffix结尾或者以params中任意一个字符串结尾，返回处理之后的字符串
 * @example
 *  appendIfMissingIgnoreCase(null, null) = null
 *  appendIfMissingIgnoreCase("abc", null) = "abc"
 *  appendIfMissingIgnoreCase("", "xyz") = "xyz"
 *  appendIfMissingIgnoreCase("abcxyz", "xyz") = "abcxyz"
 *  appendIfMissingIgnoreCase("abcxyz", "XYZ") = "abcxyz"
 *  appendIfMissingIgnoreCase("abc", "xyz" , "") = "abc"
 *  appendIfMissingIgnoreCase("abc", "ABC", "mno") = "abc"
 *  appendIfMissingIgnoreCase("mnoxyz", "abc", "XYZ") = "mnoxyz"
 * 说明：若字符串str既不以suffix结尾，也不以params中的任一项结尾，优先确保字符串str以字符串suffix结尾
 * @param str 用于验证的字符串
 * @param suffix 匹配结尾的字符串
 * @param params [可选] 匹配结尾的字符串
 */
export function appendIfMissingIgnoreCase(str: string, suffix: string, ...params: any): string;

/**
 * 确保字符串str以字符串prefix开头或者以params中任意一个字符串开头，返回处理之后的字符串
 * @example
 *  prependIfMissing(null, null) = null
 *  prependIfMissing("abc", null) = "abc"
 *  prependIfMissing("", "xyz") = "xyz"
 *  prependIfMissing("abc", "xyz") = "xyzabc"
 *  prependIfMissing("abcxyz", "xyz") = "xyzabcxyz"
 *  prependIfMissing("ABCxyz", "abc") = "abcABCxyz"
 *  prependIfMissing("abc", "xyz", "") = "abc"
 *  prependIfMissing("xyzmno", "xyz", "mno") = "xyzmno"
 *  prependIfMissing("XYZmno", "xyz", "mno") = "xyzXYZmno"
 * 说明：若字符串str既不以prefix开头，也不以params中的任一项开头，优先确保字符串str以字符串prefix开头
 * @param str 用于验证的字符串
 * @param prefix 匹配开头的字符串
 * @param params [可选] 匹配开头的字符串
 */
export function prependIfMissing(str: string, prefix: string, ...params: any): string;

/**
 * 确保字符串str以字符串prefix开头或者以params中任意一个字符串开头，返回处理之后的字符串
 * @example
 *  prependIfMissingIgnoreCase(null, null) = null
 *  prependIfMissingIgnoreCase("abc", null) = "abc"
 *  prependIfMissingIgnoreCase("", "xyz") = "xyz"
 *  prependIfMissingIgnoreCase("abcxyz", "abc") = "abcxyz"
 *  prependIfMissingIgnoreCase("abcxyz", "ABC") = "abcxyz"
 *  prependIfMissingIgnoreCase("abc", "xyz" , "") = "abc"
 *  prependIfMissingIgnoreCase("abc", "ABC", "mno") = "abc"
 *  prependIfMissingIgnoreCase("mnoxyz", "abc", "MNO") = "mnoxyz"
 * 说明：若字符串str既不以prefix开头，也不以params中的任一项开头，优先确保字符串str以字符串prefix开头
 * @param str 用于验证的字符串
 * @param prefix 匹配开头的字符串
 * @param params [可选] 匹配开头的字符串
 */
export function prependIfMissingIgnoreCase(str: string, prefix: string, ...params: any): string;

/**
 * 确保字符串str不以字符串prefix开头，返回处理之后的字符串
 * @example
 *  removeStart(null, null) = null
 *  removeStart("abc", null) = "abc"
 *  removeStart("", "xyz") = ""
 *  removeStart("xyz", "") = "xyz"
 *  removeStart("abcxyz", "abc") = "xyz"
 *  removeStart("ABCxyz", "abc") = "ABCxyz"
 * @param str 用于验证的字符串
 * @param prefix 匹配开头的字符串
 */
export function removeStart(str: string, prefix: string, ignoreCase?: boolean): string;

/**
 * 确保字符串str不以字符串prefix开头，返回处理之后的字符串
 * @example
 *  removeStartIgnoreCase(null, null) = null
 *  removeStartIgnoreCase("abc", null) = "abc"
 *  removeStartIgnoreCase("", "xyz") = ""
 *  removeStartIgnoreCase("xyz", "") = "xyz"
 *  removeStartIgnoreCase("abcxyz", "abc") = "xyz"
 *  removeStartIgnoreCase("ABCxyz", "abc") = "xyz"
 * @param str 用于验证的字符串
 * @param prefix 匹配开头的字符串
 */
export function removeStartIgnoreCase(str: string, prefix: string, ignoreCase?: boolean): string;

/**
 * 确保字符串str不以字符串suffix结尾，返回处理之后的字符串
 * @example
 *  removeEnd(null, null) = null
 *  removeEnd("abc", null) = "abc"
 *  removeEnd("", "xyz") = ""
 *  removeEnd("xyz", "") = "xyz"
 *  removeEnd("abcxyz", "xyz") = "abc"
 *  removeEnd("abcXYZ", "xyz") = "abcXYZ"
 * @param str 用于验证的字符串
 * @param suffix 匹配结尾的字符串
 */
export function removeEnd(str: string, suffix: string, ignoreCase?: boolean): string;

/**
 * 确保字符串str不以字符串suffix结尾，返回处理之后的字符串
 * @example
 *  removeEndIgnoreCase(null, null) = null
 *  removeEndIgnoreCase("abc", null) = "abc"
 *  removeEndIgnoreCase("", "xyz") = ""
 *  removeEndIgnoreCase("xyz", "") = "xyz"
 *  removeEndIgnoreCase("abcxyz", "xyz") = "abc"
 *  removeEndIgnoreCase("abcXYZ", "xyz") = "abc"
 * @param str 用于验证的字符串
 * @param suffix 匹配结尾的字符串
 */
export function removeEndIgnoreCase(str: string, suffix: string, ignoreCase?: boolean): string;

/**
 * 将传入的对象解析为boolean类型,若解析不成功，有def则返回def，没有则返回false
 * @example
 *  parseBoolean(null, true) = true
 *  parseBoolean("0", true) = false
 *  parseBoolean("1", true) = true
 *  parseBoolean("Y", true) = true
 *  parseBoolean("T", true) = true
 *  parseBoolean("yes", true) = true
 *  parseBoolean("N", true) = false
 *  parseBoolean("f", true) = false
 *  parseBoolean("no", true) = false
 *  parseBoolean("true", false) = true
 *  parseBoolean("false", true) = false
 *  parseBoolean("faLse", true) = false
 *  parseBoolean("on", false) = true
 *  parseBoolean("ON", false) = true
 *  parseBoolean("off", true) = false
 *  parseBoolean("oFf", true) = false
 *  parseBoolean("test", true) = true
 *  parseBoolean("test") = false
 * @param obj 需解析成boolean类型的对象,传入的对象不区分大小写
 * @param def 解析失败时的默认值
 */
export function parseBoolean(obj: any, def?: boolean): boolean;

/**
 * 将一个xml文档写入到指定的流中，输出的格式没有换行和缩进，若想格式化，请用formatXML
 * @param doc 待写入的xml文档
 * @param target 写入的对象
 */
export function writeXML(doc: Document, target: File | Writer): void;

/**
 * 把一个字符串首尾和内部的非可见字符都去掉
 * @param str 
 */
export function trimAll(str: string): string;

/**
 * 格式化XML内容
 * @param xml 待格式化的xml，可以为string或Document
 * @return 返回格式化之后的xml字符串
 */
export function formatXML(xml: string | Document | File): string;

/**
 * 对一串字符进行base64加密,返回加密后的字符串,加密后的字符串是url-safe的
 * @param str 待加密的字符串
 */
export function encodeBase64(str: string): string;

/**
 * 对一串字符进行base64解密,返回解密后的字符串
 * @param str 待解密的字符串
 */
export function decodeBase64(str: string): string;

/**
 * 对一串html的字符串内容进行转义
 * @example
 *  escapeHTML("<br/>&") = "&lt;br/&gt;&amp;"
 * @param str 要被转义或编码的字符串。
 * @return 转义之后的字符串
 */
export function escapeHTML(str: string): string;

/**
 * 对一串js的内容进行转义,将字符串转义内容再次转义
 * @example
 *  escapeJS("let test = \"test\"") = "let test = \\\"test\\\""
 * @param str 要被转义或编码的字符串。
 * @return 转义之后的字符串
 */
export function escapeJS(str: string): string;

/**
 * 执行前端指定的js模块中的指定的函数
 * 注意：
 * 1.若指定的函数中抛出了异常，则此方法也抛出异常
 * 2.支持异步函数
 * @param args 
 * @return 返回执行方法的返回值
 */
export function runNodeJs(args: {
	/**前端js模块名称，如`metadata/metadata`、`ana/dashboard/dashboard` */
	jsModule: string,
	/**要执行的函数的名称 */
	funcName: string,
	/**传递给函数的参数，参数是通过命令行传递给nodejs的，有字符限制 */
	args?: Array<string>,
	/**默认为true，支持前端代码中发起ajax请求 */
	supportAjax?: boolean,
	/**执行js模块的用户身份，可以为空，即用登录用户，在报表，仪表板，表单获取编译信息时，需要用一个有编辑权限的用户，不然在获取资源时可能会有权限异常 */
	userid?: string,
}): string;

/**
 * 加密一个密码，此函数的加密结果长度和输入的密码的长度是相关的
 * 传入的密文如果是null此函数自动将其转换为""
 * @param password 需要加密的密码字符串
 */
export function encryptPassword(password: string): string;

/**
 * 解密由utils.encryptPassword加密的密码，若该密码不是由encryptPassword加密的，直接返回
 * 传入的密文如果是null此函数自动将其转换为""
 * @param password 需要解密的密码字符串
 */
export function decryptPassword(password: string): string;

/**
 * SM3加密算法
 * @param str SM3加密的参数，可以为字符串、文件、blob、输入流
 * @returns 返回SM3加密的16进制字符串 
 */
export function encryptSM3(data: any): string;

/**
 * SM4算法加密数据
 * @param args 传递string类型的参数的时候，调用产品默认的加密参数
 * @return 返回加密之后的数据,Base64类型的字符串
 * @example
 * 1.推荐的调用方式：
 * 		// 不用指定秘钥，使用系统默认的
 * 		let strEncrypt = utils.encryptSM4(str); 
 * 2.在系统设置修改密钥之后
 * 		let strEncrypt = utils.encryptSM4({str:"TEST",mode:utils.SM4Mode.CBC,algorithmId:"**********"});
 * 3.CBC模式,key和iv不为16进制字符串的时候
 * utils.encryptSM4({
 *      str: "TEST",
 *      iv: "**************",
 *      key: "*************",
 *      mode: utils.SM4Mode.CBC,
 *      hexString: false,
 *      encoding: "utf-8"
 *	}
 * 4.ECB模式,key为16进制字符串的时候
 * utils.encryptSM4({
 *      str: "TEST",
 *      key: "***************",
 *      mode: utils.SM4Mode.ECB,
 *      hexString: true,
 *      encoding: "utf-8"
 *	}
 */
export function encryptSM4(args: {
	/**待加密数据 */
	str: any,

	/**加密模式 */
	mode: SM4Mode,

	/**算法id，在安全设置——数据加密中添加的算法的id。可以为空，默认为产品自带的秘钥id
		 说明，指定algorithmId和key二者只用指定1个
		 说明2，暂时只有mode=CBC才支持algorithmId参数。EBC模式得指定key
	*/
	algorithmId?: string,

	/**密钥 */
	key?: string,

	/**key和iv向量是否为16进制字符串，默认为false */
	hexString?: boolean,

	/**初始化向量,ECB模式可不用传递 */
	iv?: string,

	/**编码方式，默认为utf-8 */
	encoding?: string,
} | string): string;


/**
 * SM4算法加密数据
 * @param args 传递string类型的参数的时候，调用产品默认的加密参数
 * @return 返回加密之后的数据,Base64类型的字符串
 * @example
 * 1.推荐的调用方式：
 * 		// 不用指定秘钥，使用系统默认的
 * 		let strEncrypt = utils.decryptSM4(str); 
 * 2.在系统设置修改密钥之后
 * 		let strEncrypt = utils.decryptSM4({str:"TEST",mode:utils.SM4Mode.CBC,algorithmId:"**********"});
 * 3.CBC模式,key和iv不为16进制字符串的时候
 * utils.decryptSM4({
 *      str: "TEST",
 *      iv: "**************",
 *      key: "*************",
 *      mode: utils.SM4Mode.CBC,
 *      hexString: false,
 *      encoding: "utf-8"
 *	}
 * 4.ECB模式,key为16进制字符串的时候
 * utils.decryptSM4({
 *      str: "TEST",
 *      key: "***************",
 *      mode: utils.SM4Mode.ECB,
 *      hexString: true,
 *      encoding: "utf-8"
 *	}
 */
 export function decryptSM4(args: {
	/**待解密数据 */
	str: any,

	/**解密模式 */
	mode: SM4Mode,

	/**算法id，在安全设置——数据加密中添加的算法的id。可以为空，默认为产品自带的秘钥id
		 说明，指定algorithmId和key二者只用指定1个
		 说明2，暂时只有mode=CBC才支持algorithmId参数。EBC模式得指定key
	*/
	algorithmId?: string,

	/**密钥 */
	key?: string,

	/**key和iv向量是否为16进制字符串，默认为false */
	hexString?: boolean,

	/**初始化向量,ECB模式可不用传递 */
	iv?: string,

	/**编码方式，默认为utf-8 */
	encoding?: string,
} | string): string;


/**SM4数据加密解密模式 */
declare const enum SM4Mode {
	/**ECB模式 */
	ECB = "ECB",
	/**CBC模式 */
	CBC = "CBC"
}

/**
 * 校验身份证号的合法性
 * @param pid 身份证号码
 * @example 
 * pidCheck("330722196501292110") = true
 * pidCheck("330722196501292112") = false	第18位数字校验失败
 * pidCheck("330722296501292110") = false	身份证生日不合法，校验失败
 * pidCheck("030722196501292110") = false	身份证区域校验失败
 * pidCheck("3307221965012921101") = false	身份证长度校验失败
 * pidCheck("330722650129211") = true
 */
export function pidCheck(pid: string): boolean;

/**
 * 校验身份证合法性，该方法返回详细信息
 * @param pid 身份证号码
 */
export function pidCheckInfo(pid: string): {

	/**身份证是否合法 */
	valid: boolean,

	/**
	 * 身份证错误信息代码
	 * err_checkcode，第十八位校验失败
	 * err_length，身份证长度不对
	 * err_city，身份证区位码不正确
	 * err_birthday，身份证生日不合法
	 */
	errorType?: string,

	/**身份证最后一位的字符 */
	checkCode?: string
}

/**
 * 将十六进制字符串转换成字符数组
 * @param hexString 16进制字符串
 */
export function hex2Bytes(hexString: string): Array<number>;

/**
 * 获取redis客户端。
 * https://github.com/redisson/redisson
 */
export function getRedisClient(): any;

/**
 * 对日期进行格式化，不传递date参数时，默认返回当前时间字符串
 * @param format 
 * @param date  支持js的Date,java的Date,及long类型
 */
export function formatDate(format: string, date?: any): string;

/**
 * 对传入的日期进行天数加len的操作
 * @param date 支持js的Date,java的Date,及String类型
 * @param len 
 * @param pattern 当传入字符串时，可指定字符串的格式，默认为yyyyMMdd 
 * @returns 传入String类型，返回String,传入jsDate或JavaDate,返回java.util.Date类型
 */
export function addDay(date: any, len: number, pattern?: string): any;

/**
 * 对传入的日期进行月份加len的操作
 * @param date 支持js的Date,java的Date,及String类型
 * @param len 
 * @param pattern 当传入字符串时，可指定字符串的格式，默认为yyyyMMdd
 * @returns 传入String类型，返回String,传入jsDate或JavaDate,返回java.util.Date类型
 */
export function addMonth(date: any, len: number, pattern?: string): any;

/**
 * 对传入的日期进行年份加len的操作
 * @param date 支持js的Date,java的Date,及String类型
 * @param len 
 * @param pattern 当传入字符串时，可指定字符串的格式，默认为yyyyMMdd
 * @returns 传入String类型，返回String,传入jsDate或JavaDate,返回java.util.Date类型
 */
export function addYear(date: any, len: number, pattern?: string): any;

/**
 * 将日期字符串转换成java.util.Date类型
 * @param date 
 * @param pattern 
 */
export function parseDate(date: string, pattern: string): any;