761 lines
22 KiB
TypeScript
761 lines
22 KiB
TypeScript
/**
|
||
* 數據工具類
|
||
* @author BrightLi
|
||
* @since 2020/5/3
|
||
*/
|
||
|
||
import Report from "../net/Report";
|
||
import SKLogger from "./SKLogger";
|
||
|
||
export default class SKDataUtil {
|
||
// 生成UUID
|
||
static uuid(): string {
|
||
if (typeof (window) !== "undefined" && typeof (window.crypto) !== "undefined" && typeof (window.crypto.getRandomValues) !== "undefined") {
|
||
let buf: Uint16Array = new Uint16Array(8);
|
||
window.crypto.getRandomValues(buf);
|
||
return (this.pad4(buf[0]) + this.pad4(buf[1]) + "-" + this.pad4(buf[2]) + "-" + this.pad4(buf[3]) + "-" + this.pad4(buf[4]) + "-" + this.pad4(buf[5]) + this.pad4(buf[6]) + this.pad4(buf[7]));
|
||
} else {
|
||
return this.random4() + this.random4() + "-" + this.random4() + "-" + this.random4() + "-" +
|
||
this.random4() + "-" + this.random4() + this.random4() + this.random4();
|
||
}
|
||
}
|
||
private static pad4(num: number): string {
|
||
let ret: string = num.toString(16);
|
||
while (ret.length < 4) {
|
||
ret = "0" + ret;
|
||
}
|
||
return ret;
|
||
}
|
||
private static random4(): string {
|
||
return Math.floor((1 + Math.random()) * 0x10000)
|
||
.toString(16)
|
||
.substring(1);
|
||
}
|
||
// 隨機數
|
||
static random(min: number, max: number): number {
|
||
return Math.floor(Math.random() * (max - min + 1)) + min;
|
||
}
|
||
// 從數組中隨機抽取一項
|
||
static randomList(value: any[]): any {
|
||
if (value == null || value.length < 1) {
|
||
return null;
|
||
}
|
||
let index = this.random(0, value.length - 1);
|
||
return value[index];
|
||
}
|
||
// 替換指定位置的字符
|
||
static replaceChar(value: string, index: number, char: string): string {
|
||
return value.substr(0, index) + char + value.substr(index + char.length);
|
||
}
|
||
// 從前查找相同字符出現的最後一個位置
|
||
static sameIndex(value: string, char: string): number {
|
||
var result: number = -1;
|
||
for (var i = 0; i < value.length; i++) {
|
||
if (value[i] == char) {
|
||
if (result == -1) {
|
||
result = i;
|
||
} else {
|
||
result++;
|
||
}
|
||
} else if (result != -1) {
|
||
break;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
// 從後查找相同字符出現的最後一個位置
|
||
static sameLastIndex(value: string, char: string): number {
|
||
var result: number = -1;
|
||
for (var i = value.length - 1; i > 0; i--) {
|
||
if (value[i] == char) {
|
||
if (result == -1) {
|
||
result = i;
|
||
} else {
|
||
result--;
|
||
}
|
||
} else if (result != -1) {
|
||
break;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
// 格式化數字，不足位補0
|
||
static prefixInteger(num: number, length: number): string {
|
||
let result = (Array(length).join('0') + num).slice(-length);
|
||
return result;
|
||
}
|
||
// "YYYY-mm-dd HH:MM"
|
||
static formatDate(format: string, value: string | number): string {
|
||
let now = new Date(value);
|
||
let opt: any = {
|
||
"Y+": now.getFullYear().toString(),
|
||
"m+": (now.getMonth() + 1).toString(),
|
||
"d+": now.getDate().toString(),
|
||
"H+": now.getHours().toString(),
|
||
"M+": now.getMinutes().toString(),
|
||
"S+": now.getSeconds().toString(),
|
||
}
|
||
let result: RegExpExecArray;
|
||
for (let key in opt) {
|
||
result = new RegExp(`(${key})`).exec(format);
|
||
if (result) {
|
||
format = format.replace(result[1], (result[1].length == 1) ? (opt[key]) : (opt[key].padStart(result[1].length, "0")));
|
||
}
|
||
}
|
||
return format;
|
||
}
|
||
// 根據ID生成5位邀請碼
|
||
static encodeInvite(value: number) {
|
||
let key = 'E50CDG3HQA4B1NOPIJ2RSTUV67MWX89KLYZ';
|
||
let result = "";
|
||
while (value > 0) {
|
||
let mod = value % 35;
|
||
value = (value - mod) / 35;
|
||
result = key[mod] + result;
|
||
}
|
||
if (result.length < 5) {
|
||
result = "F" + result;
|
||
let len = result.length;
|
||
let min = 0;
|
||
let max = key.length - 1;
|
||
for (let i = len; i < 5; i++) {
|
||
let index = Math.floor(Math.random() * (max - min + 1)) + min;
|
||
result = key[index] + result;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
// 解碼邀請碼
|
||
static decodeInvite(value: string): number {
|
||
let key = 'E50CDG3HQA4B1NOPIJ2RSTUV67MWX89KLYZ';
|
||
let index = value.indexOf("F");
|
||
if (index != -1) {
|
||
value = value.slice(index + 1, value.length);
|
||
}
|
||
let result = 0;
|
||
let p = 0;
|
||
for (let i = value.length - 1; i >= 0; i--) {
|
||
let char = value[i];
|
||
index = key.indexOf(char);
|
||
if (index != -1) {
|
||
result += index * Math.pow(35, p);
|
||
p++;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
static numberOfList(list: number[], index: number, valid: number): number {
|
||
if (list == null || !SKDataUtil.isArray(list) || list.length < index) {
|
||
return valid;
|
||
}
|
||
return list[index];
|
||
}
|
||
// 從數組中獲得匹配
|
||
static numberByList(list: any[], key: string, value: number, targetKey: string): any {
|
||
for (let item of list) {
|
||
let temp = item[key];
|
||
if (!temp) {
|
||
continue;
|
||
}
|
||
if (temp == value) {
|
||
let result = item[targetKey];
|
||
return result;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
// 是否存在KV
|
||
static hasKVByList(list: any[], key: string, value: any): boolean {
|
||
for (let item of list) {
|
||
if (item[key] == value) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
// 是否有互斥
|
||
static hasMutex(target: any[], mutex: any[], mutexKey: string, key: string): boolean {
|
||
for (let item of target) {
|
||
let temp = item[key];
|
||
if (!temp) {
|
||
continue;
|
||
}
|
||
// 如果是互斥數組
|
||
if (Array.isArray(temp)) {
|
||
for (let b of mutex) {
|
||
for (let a of temp) {
|
||
if (item[key] == b) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
for (let b of mutex) {
|
||
if (temp == b) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
// 獲得二維數組中的數值
|
||
static intOf2Array(list: number[][], one: number, two: number, valid: number): number {
|
||
if (!list) {
|
||
return valid;
|
||
}
|
||
if (one < 0 || one >= list.length) {
|
||
return valid;
|
||
}
|
||
let temp = list[one] as number[];
|
||
if (!temp) {
|
||
return valid;
|
||
}
|
||
if (two < 0 || two >= temp.length) {
|
||
return valid;
|
||
}
|
||
return temp[two];
|
||
}
|
||
// 根據概率返回真假
|
||
static probability(min: number, max: number): boolean {
|
||
let result = SKDataUtil.random(min, max);
|
||
if (result <= min) {
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
static textAssetByList(value: any[], index: number): cc.TextAsset {
|
||
if (value == null || index >= value.length) {
|
||
return null;
|
||
}
|
||
let result: cc.TextAsset = <cc.TextAsset>value[index];
|
||
return result;
|
||
}
|
||
|
||
static prefabByList(value: any[], index: number): cc.Prefab {
|
||
if (value == null || index >= value.length) {
|
||
return null;
|
||
}
|
||
let result: cc.Prefab = <cc.Prefab>value[index];
|
||
return result;
|
||
}
|
||
|
||
static atlasByList(value: any[], index: number): cc.SpriteAtlas {
|
||
if (value == null || index >= value.length) {
|
||
return null;
|
||
}
|
||
let result: cc.SpriteAtlas = <cc.SpriteAtlas>value[index];
|
||
return result;
|
||
}
|
||
|
||
|
||
static jsonAssetBy(value: any): cc.JsonAsset {
|
||
let result: cc.JsonAsset = <cc.JsonAsset>value;
|
||
return result;
|
||
}
|
||
|
||
static jsonAssetByList(value: any[], index: number): cc.JsonAsset {
|
||
if (value == null || index >= value.length) {
|
||
return null;
|
||
}
|
||
let result: cc.JsonAsset = <cc.JsonAsset>value[index];
|
||
return result;
|
||
}
|
||
|
||
static dictByDict(target: any, sheet: any, key: any): any {
|
||
if (!target) {
|
||
return null;
|
||
}
|
||
let dict = target[sheet];
|
||
if (!dict) {
|
||
return null;
|
||
}
|
||
let result = dict[key];
|
||
return result;
|
||
}
|
||
|
||
static findByDict(target: any, targetKey: any, value: any, resultKey: any, valid: any): any {
|
||
if (!target) {
|
||
return valid;
|
||
}
|
||
for (let key in target) {
|
||
let item = target[key];
|
||
if (item[targetKey] == value) {
|
||
return item[resultKey];
|
||
}
|
||
}
|
||
return valid;
|
||
}
|
||
|
||
static numberByString(target: string, splitter: string, index: number, valid: number = 0): number {
|
||
if (!target) {
|
||
return valid;
|
||
}
|
||
let temp = target.split(splitter);
|
||
if (temp.length < index) {
|
||
return valid;
|
||
}
|
||
let result = parseInt(temp[index]);
|
||
return result;
|
||
}
|
||
// JSON解析
|
||
static jsonBy(value: any): any {
|
||
if (value == null) {
|
||
return null;
|
||
}
|
||
if (!this.isString(value)) {
|
||
return value;
|
||
}
|
||
if (this.isEmptyString(value)) {
|
||
return null;
|
||
}
|
||
let result: any = null;
|
||
try {
|
||
result = JSON.parse(value);
|
||
} catch (error) {
|
||
SKLogger.warn(`JSON解析:${value},失敗:${error}`);
|
||
} finally {
|
||
return result;
|
||
}
|
||
}
|
||
// 轉換成JSON字符串
|
||
static toJson(value: any): string {
|
||
if (value == null) {
|
||
return "";
|
||
}
|
||
if (this.isString(value)) {
|
||
return value;
|
||
}
|
||
let result: string = "";
|
||
try {
|
||
result = JSON.stringify(value);
|
||
} catch (error) {
|
||
SKLogger.warn(`JSON轉換:${value},失敗:${error}`);
|
||
} finally {
|
||
return result;
|
||
}
|
||
}
|
||
// 是否為數字
|
||
static isNumber(value: any): boolean {
|
||
if (value == null) {
|
||
return false;
|
||
}
|
||
let type = typeof value;
|
||
if (type !== 'number') {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
// 轉換成數字
|
||
static toNumber(value: any): number {
|
||
if (this.isNumber(value)) {
|
||
return value;
|
||
}
|
||
if (value == "undefined") {
|
||
return NaN;
|
||
}
|
||
if (this.isString(value)) {
|
||
let result = parseFloat(value);
|
||
return result;
|
||
}
|
||
return NaN;
|
||
}
|
||
// 版本號比較
|
||
static checkVersion(versionA: string, versionB: string): number {
|
||
let vA = versionA.split('.');
|
||
let vB = versionB.split('.');
|
||
for (let i = 0; i < vA.length; ++i) {
|
||
let a = parseInt(vA[i]);
|
||
let b = parseInt(vB[i] || '0');
|
||
if (a === b) {
|
||
continue;
|
||
} else {
|
||
return a - b;
|
||
}
|
||
}
|
||
if (vB.length > vA.length) {
|
||
return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
// 是否為數組
|
||
static isArray(value: any): boolean {
|
||
if (value == null) {
|
||
return false;
|
||
}
|
||
let result = Array.isArray(value);
|
||
return result;
|
||
}
|
||
// 是否為對象
|
||
static isObject(value: any): boolean {
|
||
if (value == null) {
|
||
return false;
|
||
}
|
||
let type = typeof value;
|
||
if (type === "object") {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
// 是否為字符串
|
||
static isString(value: any): boolean {
|
||
if (value == null) {
|
||
return false;
|
||
}
|
||
let result = typeof (value);
|
||
if (result == "string") {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
// 是否為空字符串
|
||
static isEmptyString(value: any): boolean {
|
||
if (value == null) {
|
||
return true;
|
||
}
|
||
if (!this.isString(value)) {
|
||
return true;
|
||
}
|
||
let result = <string>value;
|
||
if (result.length < 1) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
// 正則測試
|
||
static testRegExp(value: string, regexp: RegExp, min: number, max: number, tip: string) {
|
||
if (value.length < min) {
|
||
return `長度不能少於${min}個`;
|
||
}
|
||
if (value.length > max) {
|
||
return `最多只能${max}個`;
|
||
}
|
||
let temp = regexp.test(value);
|
||
if (!temp) {
|
||
return tip;
|
||
}
|
||
return "";
|
||
}
|
||
// 檢查合法性
|
||
static checkSymbol(value: string, min: number, max: number, tip: string): string {
|
||
if (value.length < min) {
|
||
return `長度不能少於${min}個`;
|
||
}
|
||
if (value.length > max) {
|
||
return `最多只能${max}個`;
|
||
}
|
||
let regexp = new RegExp("[\r\n\t]");
|
||
let check = regexp.test(value);
|
||
if (check) {
|
||
return `不能有回車或製表符!`;
|
||
}
|
||
regexp = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\].<>/?~！@#￥……&*（）——|{}【】‘；：”“'。，、？]");
|
||
check = regexp.test(value);
|
||
if (check) {
|
||
return tip;
|
||
}
|
||
return "";
|
||
}
|
||
// 正則測試
|
||
static testNotRegExp(value: string, regexp: RegExp, min: number, max: number, tip: string) {
|
||
if (value.length < min) {
|
||
return `長度不能少於${min}個`;
|
||
}
|
||
if (value.length > max) {
|
||
return `最多只能${max}個`;
|
||
}
|
||
let temp = regexp.test(value);
|
||
if (temp) {
|
||
return tip;
|
||
}
|
||
return "";
|
||
}
|
||
// 獲得鍵值
|
||
static valueForKey(target: any, key: any): any {
|
||
if (target == null) {
|
||
cc.warn(`$警告:獲得鍵值,對像不存在`);
|
||
return null;
|
||
}
|
||
if (key == null) {
|
||
cc.warn(`$警告:獲得鍵值,對象${target}KEY值不存在`);
|
||
return null;
|
||
}
|
||
if (this.isArray(target)) {
|
||
let result = this.getItemByList(target, key);
|
||
return result;
|
||
}
|
||
if (!this.isObject(target)) {
|
||
cc.warn(`$警告:獲得鍵值,${target}[${key}]不是一個對象`);
|
||
return null;
|
||
}
|
||
let temp: Object = <Object>target;
|
||
if (!temp.hasOwnProperty(key)) {
|
||
cc.warn(`$警告:獲得鍵值,${target.toString()}[${key}]不存在`);
|
||
return null;
|
||
}
|
||
return temp[key];
|
||
}
|
||
// 檢查是否合法
|
||
static checkValid(value: string): string {
|
||
if (value == null || value.length < 1) {
|
||
return "不能為空!";
|
||
}
|
||
let temp = value.trim();
|
||
if (value.length != temp.length) {
|
||
return "兩側不能有空格";
|
||
}
|
||
let list = [{ char: "\"", text: "雙引號" },
|
||
{ char: "\'", text: "單引號" }];
|
||
for (let item of list) {
|
||
if (value.indexOf(item.char) != -1) {
|
||
return `不能包含${item.text}`;
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
|
||
static trim(value: string): string {
|
||
if (value == null || value.length < 1) {
|
||
return "";
|
||
}
|
||
value = value.trim();
|
||
return value;
|
||
}
|
||
// 獲得最大值經驗值
|
||
static maxExp(config: any, exp: number): any {
|
||
let result = exp;
|
||
for (let item of config) {
|
||
if (exp < item.exp) {
|
||
result = item.exp;
|
||
break;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
// 獲得當前階段的經驗值與最大值
|
||
static currentExp(config: any, exp: number): any {
|
||
let result: any = { value: 0, max: 0 };
|
||
for (let item of config) {
|
||
let level = item.level;
|
||
let max_exp = item.exp;
|
||
if (exp < max_exp) {
|
||
if (level > 1) {
|
||
let prev = config[`${level - 1}`];
|
||
result.value = exp - prev.exp;
|
||
result.max = max_exp - prev.exp;
|
||
} else {
|
||
result.value = exp;
|
||
result.max = max_exp;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
// 是否有屬性
|
||
static hasProperty(target: any, key: string | number | symbol): boolean {
|
||
if (target == null) {
|
||
return false;
|
||
}
|
||
if (!this.isObject(target)) {
|
||
return false;
|
||
}
|
||
let result = <Object>target;
|
||
if (result.hasOwnProperty(key)) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
// 獲得字典長度
|
||
static getLength(value: any): number {
|
||
if (value == null) {
|
||
return 0;
|
||
}
|
||
if (Array.isArray(value)) {
|
||
return value.length;
|
||
}
|
||
let length = 0;
|
||
for (let _key in value) {
|
||
length++;
|
||
}
|
||
return length;
|
||
}
|
||
// 對鍵求和
|
||
static getKeyTotal(value: any): number {
|
||
let total: number = 0;
|
||
for (let key in value) {
|
||
let count = parseInt(key);
|
||
total += count;
|
||
}
|
||
return total;
|
||
}
|
||
/**
|
||
* 深度拷貝
|
||
* @param value
|
||
* @returns
|
||
*/
|
||
static clone(value: any): any {
|
||
if (value == null) {
|
||
return null;
|
||
}
|
||
let result: any = Array.isArray(value) ? [] : {};
|
||
try {
|
||
result = JSON.parse(JSON.stringify(value));
|
||
} catch (error) {
|
||
let info = `警告:深拷貝對象:${value},失敗:${error}`
|
||
Report.report(info);
|
||
} finally {
|
||
return result;
|
||
}
|
||
}
|
||
// 克隆類實例
|
||
static cloneClass(value: any): any {
|
||
if (value == null) {
|
||
return null;
|
||
}
|
||
let result = Object.create(
|
||
Object.getPrototypeOf(value),
|
||
Object.getOwnPropertyDescriptors(value)
|
||
);
|
||
return result;
|
||
}
|
||
// 是否在範圍內
|
||
static atRange(target: number, range: number[]): boolean {
|
||
for (let item of range) {
|
||
if (target == item) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
static clamp(value: number, min: number, max: number): number {
|
||
if (value < min) {
|
||
return min;
|
||
}
|
||
if (value > max) {
|
||
return max;
|
||
}
|
||
return value;
|
||
}
|
||
// 將大數字單位轉化成 千、萬、千萬、億
|
||
static transform(value: number): string {
|
||
if (value == null) {
|
||
return "";
|
||
}
|
||
value = SKDataUtil.toNumber(value);
|
||
if (isNaN(value)) {
|
||
return "";
|
||
}
|
||
let newValue = ['', '', ''];
|
||
let fr = 1000;
|
||
const ad = 1;
|
||
let num = 3;
|
||
const fm = 1;
|
||
while (value / fr >= 1) {
|
||
fr *= 10;
|
||
num += 1;
|
||
}
|
||
if (num <= 4) { // 千
|
||
newValue[1] = '千';
|
||
newValue[0] = `${this.toDecimal1(value / 1000)}`;
|
||
} else if (num <= 8) { // 萬
|
||
const text1 = `${(num - 4) / 3 > 1 ? '千萬' : '萬'}`;
|
||
// tslint:disable-next-line:no-shadowed-variable
|
||
const fm = '萬' === text1 ? 10000 : 10000000;
|
||
newValue[1] = text1;
|
||
newValue[0] = `${this.toDecimal1(value / fm)}`;
|
||
} else if (num <= 16) {// 億
|
||
let text1 = (num - 8) / 3 > 1 ? '千億' : '億';
|
||
text1 = (num - 8) / 4 > 1 ? '萬億' : text1;
|
||
text1 = (num - 8) / 7 > 1 ? '千萬億' : text1;
|
||
// tslint:disable-next-line:no-shadowed-variable
|
||
let fm = 1;
|
||
if ('億' === text1) {
|
||
fm = 100000000;
|
||
} else if ('千億' === text1) {
|
||
fm = 100000000000;
|
||
} else if ('萬億' === text1) {
|
||
fm = 1000000000000;
|
||
} else if ('千萬億' === text1) {
|
||
fm = 1000000000000000;
|
||
}
|
||
newValue[1] = text1;
|
||
newValue[0] = `${this.toDecimal1(value / fm)}`;
|
||
}
|
||
if (value < 1000) {
|
||
newValue[1] = '';
|
||
newValue[0] = `${value}`;
|
||
}
|
||
let result = newValue.join('');
|
||
return result;
|
||
}
|
||
// 獲得數組元素
|
||
static getItemByList(list: any, index: number): any {
|
||
if (!this.isArray(list)) {
|
||
return null;
|
||
}
|
||
if (index < 0 || index >= list.length) {
|
||
return null;
|
||
}
|
||
let result = list[index];
|
||
return result;
|
||
}
|
||
// 獲得對像元素
|
||
static getItemByMap(obj: any, index: number): any {
|
||
if (index < 0) {
|
||
return null;
|
||
}
|
||
if (!this.isObject(obj)) {
|
||
return null;
|
||
}
|
||
let i = 0;
|
||
for (let key in obj) {
|
||
if (i == index) {
|
||
return obj[key];
|
||
}
|
||
i++;
|
||
}
|
||
}
|
||
// 保留1位小數
|
||
static toDecimal1(value: number): number {
|
||
let temp = this.toNumber(value);
|
||
if (isNaN(temp)) {
|
||
return 0;
|
||
}
|
||
temp = Math.floor(value * 10) / 10;
|
||
return temp;
|
||
}
|
||
// 保留2位小數
|
||
static toDecimal2(value: number): number {
|
||
let temp = this.toNumber(value);
|
||
if (isNaN(temp)) {
|
||
return 0;
|
||
}
|
||
temp = Math.floor(value * 100) / 100;
|
||
return temp;
|
||
}
|
||
// 是否為數字字符串
|
||
static isNumberString(value: string): boolean {
|
||
var regPos = /^\d+$/; //非負浮點數
|
||
if (regPos.test(value)) {
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
// 獲得距離
|
||
static distance(source: any, target: any): number {
|
||
if (source == null || target == null) {
|
||
return 0;
|
||
}
|
||
let sx = (source.x != null ? source.x : 0);
|
||
let sy = (source.y != null ? source.y : 0);
|
||
let tx = (target.x != null ? target.x : 0);
|
||
let ty = (target.y != null ? target.y : 0);
|
||
let xd = Math.abs(sx - tx);
|
||
let yd = Math.abs(sy - ty);
|
||
let result = Math.pow(xd * xd + yd * yd, 0.5);
|
||
return result;
|
||
}
|
||
} |