@zwa73/utils 1.0.60 → 1.0.62

package/src/UtilFunctions.ts

@@ -1,365 +1,290 @@
-import * as crypto from "crypto";
-import { ComposedClass, ComposedClassMult, ComposedPartClass as ComposedPartClass, FuncPropNames, JToken, PromiseProcFn, PromiseStat, PromiseVerifyFn } from "./UtilInterfaces";
-import * as cp from "child_process";
-import { SLogger } from "./UtilLogger";
-
-/**常用函数 */
-export namespace UtilFunc{
-/**获取当前时间戳  
- * number ()  
- * @returns {number} 时间戳
- */
-export function getTime(): number {
-    return new Date().getTime();
-}
-
-/**初始化对象的字段  
- * void (Object,string,any)  
- * @param {Record<string,T>} obj   - 所要初始化的对象
- * @param {string} field 		   - 所要初始化的字段
- * @param {T} defaultVal 		   - 默认值
- * @returns {T} - 最终值
- */
-export function initField<T>(
-    obj: Record<string, T>,
-    field: string,
-    defaultVal: T
-): T {
-    if (!(field in obj)) obj[field] = defaultVal;
-    return obj[field];
-}
-
-/**生成一串uuid  
- * string ()  
- * @returns {string} uuid
- */
-export function genUUID() {
-    return crypto.randomBytes(16).toString("hex");
-}
-/**计算Hash  
- * string ()  
- * @param {string} str - 待计算的字符串
- * @returns {string} hash
- */
-export function calcHash(str:string) {
-    return crypto.createHash('md5').update(str).digest('hex');
-}
-
-/**深克隆 序列化并反序列化  
- * @template {T} T - JToken类型的泛型
- * @param {T} obj - 克隆目标
- * @returns {T}   克隆结果
- */
-export function deepClone<T extends JToken>(obj: T): T {
-    return JSON.parse(JSON.stringify(obj));
-}
-
-/**是否为安全的数字
- * @param {number} num - 所要检测的数字
- * @returns {boolean} 是否安全
- */
-export function isSafeNumber(num: number): boolean {
-    if (num === undefined || num == null || isNaN(num)) return false;
-    if(typeof num === 'number') return true;
-    return false;
-}
-
-/**等待 timeMs 毫秒  
- * @async
- * @param {number} timeMs - 等待的毫秒数
- * @returns {Promise<boolean>}
- */
-export async function sleep(timeMs: number): Promise<boolean> {
-    return new Promise(function (resolve, rejecte) {
-        let timer = setTimeout(function () {
-            resolve(true);
-        }, timeMs);
-    });
-}
-
-/**封装的 cp.exec 执行一段指令 指令完成后返回 Promise  
- * @param {string} command 指令文本
- */
-export function exec(command: string) {
-	return new Promise<{ stdout:string, stderr:string }>
-        ((resolve, reject) => {
-		cp.exec(command, (error, stdout, stderr) => {
-			if (error)
-				reject(error);
-			else
-				resolve({ stdout, stderr });
-		});
-	});
-}
-
-/**永不完成的Promise单例 */
-const NeverResolvedPromise = new Promise(()=>{});
-/**获得一个永不完成的Promise单例 */
-export function getNeverResolvedPromise<T>():Promise<T>{
-    return NeverResolvedPromise as Promise<T>;
-}
-
-/**进行中的请求 */
-type ProcessingPromise<T> = {
-    /**主体请求 */
-    result:T;
-    /**请求状态 */
-    stat:PromiseStat|Promise<PromiseStat>;
-    /**请求下标/序号 */
-    index:number;
-};
-
-/**重复尝试promise  
- * @async
- * @param {PromiseProcFn<T>} [procFn]       - 发起函数
- * @param {PromiseVerifyFn<T>} [verifyFn]   - 验证函数
- * @param {number} [repeatCount]            - 重试次数
- * @param {number} [repeatTime]             - 超时时间/秒  最小为10秒
- * @returns {Promise<T|null>}               - 结果 null 为全部失败/超时
- */
-export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:PromiseVerifyFn<T>,
-    repeatCount:number=3,repeatTime:number=180):Promise<T|null>{
-
-    //计时
-    const timeflag = "repeatPromise "+UtilFunc.genUUID();
-    SLogger.time(timeflag);
-
-    //转换为毫秒
-    const hasRepeatTime = (repeatTime>=10);
-    if(hasRepeatTime) repeatTime*=1000;
-
-    //验证处理函数
-    if(verifyFn===undefined)
-        verifyFn = ()=>"Completed";
-
-    //计时器
-    let timer:NodeJS.Timer|null = null;
-    let timerP:Promise<"Timeout">|null=null;
-    let resolveFn:((value: "Timeout" | PromiseLike<"Timeout">)=>void)|null = null;
-    /**清理计时器 */
-    const clearTimer = ()=>{
-        if(timer!=null)
-            clearInterval(timer);
-        if(resolveFn!=null)
-            resolveFn("Timeout");
-        timerP=null;
-        timer=null;
-        resolveFn=null;
-    }
-
-    //进行中的请求
-	const plist:Promise<ProcessingPromise<T>>[] = [];
-
-    //开始处理
-    try{
-        for(let i=0;i<repeatCount;){
-            SLogger.info(`开始第 ${i+1} 次 repeatPromise`);
-            //创建当前任务
-            if(plist.length<i+1){
-                plist.push(procFn().then(result =>
-                    ({result, stat:verifyFn!(result), index:i})));
-            }
-
-            //创建定时器
-            if(timerP==null){
-                timerP = new Promise<"Timeout">(function(resolve, rejecte){
-                    resolveFn = resolve;
-                    timer = setTimeout(()=>resolve("Timeout"),
-                        hasRepeatTime? repeatTime:Infinity);//无限制则无限时间
-                })
-            }
-
-            //等待完成
-            const currObj = await Promise.race([...plist, timerP]);
-
-            //超时处理
-            if(currObj=="Timeout"){
-                SLogger.warn(`第 ${i+1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
-                clearTimer(); i++;
-                continue;
-            }
-            const poststat = await currObj.stat;
-            switch(poststat){
-                case "Completed"://完成
-                    SLogger.info(`第 ${currObj.index+1} 次 repeatPromise 成功`);
-                    //非当前
-                    if(currObj.index!=i)
-                        SLogger.info(`成功的 promise 非当前 promise 考虑增大重试间隔\n当前index: ${i}\n当前间隔: ${repeatTime}`);
-                    return currObj.result;
-                case "Terminated"://终止
-                    SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 终止 停止重试`);
-                    return currObj.result;
-                case "Failed"://验证失败
-                    //抛弃失败
-                    plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
-                    //是当前
-                    if(currObj.index==i){
-                        SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败 开始重试`);
-                        clearTimer(); i++;
-                        continue;
-                    }
-                    //非当前
-                    SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败`);
-                    continue;
-            }
-        }
-        //全部失败或超时则返回null
-        SLogger.warn(`${repeatCount} 次 repeatPromise 尝试均失败`);
-        return null;
-    }catch(err){
-        SLogger.warn(`repeatPromise 发生错误`,err);
-        return null;
-    }finally{
-        //清理
-        clearTimer();
-        SLogger.timeEnd(timeflag);
-    }
-}
-
-
-/**柯里化函数类型 */
-type CurryFunc<T, PrevArgs extends any[] = []> = T extends (...args: infer Args) => infer Result
-    ? Args extends [infer Arg, ...infer RestArgs]
-        ? RestArgs extends []
-            ? ((...args: [...PrevArgs, Arg]) => Result )
-            : ((...args: [...PrevArgs, Arg]) => CurryFunc<(...rest:RestArgs) => Result> )
-            & (CurryFunc<(...args: RestArgs) => Result, [...PrevArgs, Arg]>)
-        : Args extends []
-            ? () => Result
-            : never
-    : never;
-
-/**柯里化转换  
- * @param {T} fn - 将要转换的函数
- * @returns {CurryFunc<T>} 柯里化的函数
- */
-export function curry<T extends (...args: any[]) => any>(fn: T): CurryFunc<T> {
-    return (function curried(...args: any[]) {
-        if (args.length >= fn.length)
-            return fn(...args);
-        return (...restArgs: any[]) => curried(...args, ...restArgs);
-    }) as CurryFunc<T>;
-}
-/**
-let sumvoid = ()=>10;
-let a = curry(sumvoid);//?
-console.log(a());
-let sum = (a:number,b:string,c:number,d:boolean)=>a+b+c+d;
-let sumCu = curry(sum);//?
-let suma = sumCu(1)("ss");//?
-let sumb = sumCu(1,"1")(2);//?
-let sumc = sumCu(4);//?
-let sumz = sumCu(1,"b",3)(false);//?
-console.log(suma(2,true));
-console.log(sumb(true));
-console.log(sumc("s",3,false));
-*/
-/**可组合的函数 */
-type CompFunc<T = any, R = any> = (arg: T) => R;
-/**函数组合 从右到左执行 */
-export function compose<T>(...fs: CompFunc<T, T>[]): CompFunc<T, T>;
-export function compose<T, R>(f1: CompFunc<T, R>): CompFunc<T, R>;
-export function compose<T, R, R1>(f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R1>;
-export function compose<T, R, R1, R2>(f3: CompFunc<R1, R2>, f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R2>;
-export function compose<T, R, R1, R2, R3>(f4: CompFunc<R2, R3>, f3: CompFunc<R1, R2>, f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R3>;
-export function compose<T, R, R1, R2, R3, R4>(f5: CompFunc<R3, R4>,f4: CompFunc<R2, R3>, f3: CompFunc<R1, R2>, f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R4>;
-/**函数组合  
- * 从右到左执行  
- * @param {Function[]} funcs - 待组合的函数
- * @returns {(arg: any)=>any} 组合完成的函数
- */
-export function compose(...funcs: Function[]) {
-    return (arg: any) => funcs.reduceRight((value, func) => func(value), arg);
-}
-/**函数管道 从左到右执行  */
-export function pipeline<T>(...fs: CompFunc<T, T>[]): CompFunc<T, T>;
-export function pipeline<T, R>(f1: CompFunc<T, R>): CompFunc<T, R>;
-export function pipeline<T, R, R1>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>): CompFunc<T, R1>;
-export function pipeline<T, R, R1, R2>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>, f3: CompFunc<R1, R2>): CompFunc<T, R2>;
-export function pipeline<T, R, R1, R2, R3>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>, f3: CompFunc<R1, R2>, f4: CompFunc<R2, R3>): CompFunc<T, R3>;
-export function pipeline<T, R, R1, R2, R3, R4>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>, f3: CompFunc<R1, R2>, f4: CompFunc<R2, R3>, f5: CompFunc<R3, R4>): CompFunc<T, R4>;
-/**函数管道  
- * 从左到右执行  
- * @param {((arg: T) => T)} funcs - 待组合的函数
- * @returns {((arg: T) => T)} 组合完成的函数
- */
-export function pipeline<T>(...funcs: ((arg: T) => T)[]): (arg: T) => T {
-    return (arg: T): T => {
-        return funcs.reduce((value, func) => func(value), arg);
-    };
-}
-
-/**部分类组合  
- * 将mixin的部分字段混入base  
- * @param base   - 基础类
- * @param mixin  - 目标类
- * @param fields - 需要混入的字段
- * @returns - 混合完成的类
- */
-export function composePartClass<Base extends object,Mixin extends object>
-    (base:Base,mixin:Mixin,...fields:(keyof Mixin)[]):ComposedPartClass<Base,Mixin,keyof Mixin>{
-    const compObj = base as any;
-    for(const fd of fields){
-        Object.defineProperty(compObj, fd, {
-            get: ()=>mixin[fd],
-            set: (value)=>{mixin[fd] = value},
-            enumerable:true ,
-            //writable: true  ,
-            configurable: true
-        });
-        //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
-    }
-    return compObj;
-}
-/**类组合  
- * 将mixinList每个成员的字段混入base  
- * @param base      - 基础类
- * @param mixinList - 目标类
- * @returns - 混合完成的类
- */
-export function composeClass<Base extends object,MixinList extends object[]>
-    (base:Base,...mixinList:MixinList):ComposedClassMult<Base,MixinList>{
-    let obj = base as any;
-    for(let mixin of mixinList as any){
-        let propks = Object.getOwnPropertyNames(mixin.constructor.prototype)
-        for(const key of propks){
-            if(key != "constructor"){
-                Object.defineProperty(obj, key, {
-                    get: ()=>mixin[key],
-                    set: (value)=>{mixin[key] = value},
-                    enumerable:true,
-                    //writable: true,
-                    configurable: true
-                });
-                //obj[key] = (mixin as any)[key];
-            }
-        }
-        for(const key in mixin){
-            Object.defineProperty(obj, key, {
-                get: ()=>mixin[key],
-                set: (value)=>{mixin[key] = value},
-                enumerable:true ,
-                //writable: true  ,
-                configurable: true
-            });
-            //obj[key] = (mixin as any)[key];
-        }
-    }
-    return obj;
-}
-
-/**对对象的每个属性应用映射函数，并返回一个新的对象。
- * @template T      - 对象的类型
- * @param obj       - 要处理的对象
- * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
- * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
- */
-export function mapObject<T extends Object>
-    (obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T {
-    return Object.entries(obj).reduce((result, [key, value]) => {
-        result[key as keyof T] = mapper(key as keyof T, value);
-        return result;
-    }, {} as T);
-}
-
+import * as crypto from "crypto";
+import { ComposedClass, ComposedClassMult, ComposedClassPart, FuncPropNames, JToken, PromiseProcFn, PromiseStat, PromiseVerifyFn } from "@src/UtilInterfaces";
+import * as cp from "child_process";
+import { SLogger } from "@src/UtilLogger";
+
+/**常用函数 */
+export namespace UtilFunc{
+/**获取当前时间戳  
+ * @returns 时间戳
+ */
+export function getTime(): number {
+    return new Date().getTime();
+}
+
+/**初始化对象的字段  
+ * 会改变obj
+ * @param obj        - 所要初始化的对象
+ * @param field 	 - 所要初始化的字段
+ * @param defaultVal - 默认值
+ * @returns 最终值
+ */
+export function initField<T>(
+    obj: Record<string, T>,
+    field: string,
+    defaultVal: T
+): T {
+    if (!(field in obj)) obj[field] = defaultVal;
+    return obj[field];
+}
+
+/**生成一串uuid  
+ * @returns uuid
+ */
+export function genUUID() {
+    return crypto.randomBytes(16).toString("hex");
+}
+/**计算Hash  
+ * @param str - 待计算的字符串
+ * @returns hash
+ */
+export function calcHash(str:string) {
+    return crypto.createHash('md5').update(str).digest('hex');
+}
+
+/**深克隆 序列化并反序列化  
+ * @template T - JToken类型的泛型
+ * @param obj  - 克隆目标
+ * @returns 克隆结果
+ */
+export function deepClone<T extends JToken>(obj: T): T {
+    return JSON.parse(JSON.stringify(obj));
+}
+
+/**是否为安全的数字
+ * @param num - 所要检测的数字
+ * @returns 是否安全
+ */
+export function isSafeNumber(num: number): boolean {
+    if (num === undefined || num == null || isNaN(num)) return false;
+    if(typeof num === 'number') return true;
+    return false;
+}
+
+/**等待 timeMs 毫秒  
+ * @async
+ * @param timeMs - 等待的毫秒数
+ * @returns
+ */
+export async function sleep(timeMs: number): Promise<boolean> {
+    return new Promise(function (resolve, rejecte) {
+        let timer = setTimeout(function () {
+            resolve(true);
+        }, timeMs);
+    });
+}
+
+/**封装的 cp.exec 执行一段指令 指令完成后返回 Promise  
+ * @param command 指令文本
+ */
+export function exec(command: string) {
+	return new Promise<{ stdout:string, stderr:string }>
+        ((resolve, reject) => {
+		cp.exec(command, (error, stdout, stderr) => {
+			if (error)
+				reject(error);
+			else
+				resolve({ stdout, stderr });
+		});
+	});
+}
+
+/**永不完成的Promise单例 */
+const NeverResolvedPromise = new Promise(()=>{});
+/**获得一个永不完成的Promise单例 */
+export function getNeverResolvedPromise<T>():Promise<T>{
+    return NeverResolvedPromise as Promise<T>;
+}
+
+/**进行中的请求 */
+type ProcessingPromise<T> = {
+    /**主体请求 */
+    result:T;
+    /**请求状态 */
+    stat:PromiseStat|Promise<PromiseStat>;
+    /**请求下标/序号 */
+    index:number;
+};
+
+/**重复尝试promise  
+ * @async
+ * @param procFn      - 发起函数
+ * @param verifyFn    - 验证函数
+ * @param repeatCount - 重试次数
+ * @param repeatTime  - 超时时间/秒  最小为10秒
+ * @returns           - 结果 null 为全部失败/超时
+ */
+export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:PromiseVerifyFn<T>,
+    repeatCount:number=3,repeatTime:number=180):Promise<T|null>{
+
+    //计时
+    const timeflag = "repeatPromise "+UtilFunc.genUUID();
+    SLogger.time(timeflag);
+
+    //转换为毫秒
+    const hasRepeatTime = (repeatTime>=10);
+    if(hasRepeatTime) repeatTime*=1000;
+
+    //验证处理函数
+    if(verifyFn===undefined)
+        verifyFn = ()=>"Completed";
+
+    //计时器
+    let timer:NodeJS.Timer|null = null;
+    let timerP:Promise<"Timeout">|null=null;
+    let resolveFn:((value: "Timeout" | PromiseLike<"Timeout">)=>void)|null = null;
+    /**清理计时器 */
+    const clearTimer = ()=>{
+        if(timer!=null)
+            clearInterval(timer);
+        if(resolveFn!=null)
+            resolveFn("Timeout");
+        timerP=null;
+        timer=null;
+        resolveFn=null;
+    }
+
+    //进行中的请求
+	const plist:Promise<ProcessingPromise<T>>[] = [];
+
+    //开始处理
+    try{
+        for(let i=0;i<repeatCount;){
+            SLogger.info(`开始第 ${i+1} 次 repeatPromise`);
+            //创建当前任务
+            if(plist.length<i+1){
+                plist.push(procFn().then(result =>
+                    ({result, stat:verifyFn!(result), index:i})));
+            }
+
+            //创建定时器
+            if(timerP==null){
+                timerP = new Promise<"Timeout">(function(resolve, rejecte){
+                    resolveFn = resolve;
+                    timer = setTimeout(()=>resolve("Timeout"),
+                        hasRepeatTime? repeatTime:Infinity);//无限制则无限时间
+                })
+            }
+
+            //等待完成
+            const currObj = await Promise.race([...plist, timerP]);
+
+            //超时处理
+            if(currObj=="Timeout"){
+                SLogger.warn(`第 ${i+1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
+                clearTimer(); i++;
+                continue;
+            }
+            const poststat = await currObj.stat;
+            switch(poststat){
+                case "Completed"://完成
+                    SLogger.info(`第 ${currObj.index+1} 次 repeatPromise 成功`);
+                    //非当前
+                    if(currObj.index!=i)
+                        SLogger.info(`成功的 promise 非当前 promise 考虑增大重试间隔\n当前index: ${i}\n当前间隔: ${repeatTime}`);
+                    return currObj.result;
+                case "Terminated"://终止
+                    SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 终止 停止重试`);
+                    return currObj.result;
+                case "Failed"://验证失败
+                    //抛弃失败
+                    plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
+                    //是当前
+                    if(currObj.index==i){
+                        SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败 开始重试`);
+                        clearTimer(); i++;
+                        continue;
+                    }
+                    //非当前
+                    SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败`);
+                    continue;
+            }
+        }
+        //全部失败或超时则返回null
+        SLogger.warn(`${repeatCount} 次 repeatPromise 尝试均失败`);
+        return null;
+    }catch(err){
+        SLogger.warn(`repeatPromise 发生错误`,err);
+        return null;
+    }finally{
+        //清理
+        clearTimer();
+        SLogger.timeEnd(timeflag);
+    }
+}
+
+/**部分类组合  
+ * 将mixin的部分字段混入base  
+ * @param base   - 基础类
+ * @param mixin  - 目标类
+ * @param fields - 需要混入的字段
+ * @returns 混合完成的类
+ */
+export function composeClassPart
+    <Base extends object,Mixin extends object,Field extends keyof Mixin>
+    (base:Base,mixin:Mixin,...fields:Field[]):ComposedClassPart<Base,Mixin,Field>{
+    const compObj = base as any;
+    for(const fd of fields){
+        Object.defineProperty(compObj, fd, {
+            get: ()=>mixin[fd],
+            set: (value)=>{mixin[fd] = value},
+            enumerable:true ,
+            //writable: true  ,
+            configurable: true
+        });
+        //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
+    }
+    return compObj;
+}
+/**类组合  
+ * 将mixinList每个成员的字段混入base  
+ * @param base      - 基础类
+ * @param mixinList - 目标类
+ * @returns - 混合完成的类
+ */
+export function composeClass<Base extends object,MixinList extends object[]>
+    (base:Base,...mixinList:MixinList):ComposedClassMult<Base,MixinList>{
+    let obj = base as any;
+    for(let mixin of mixinList as any){
+        let propks = Object.getOwnPropertyNames(mixin.constructor.prototype)
+        for(const key of propks){
+            if(key != "constructor"){
+                Object.defineProperty(obj, key, {
+                    get: ()=>mixin[key],
+                    set: (value)=>{mixin[key] = value},
+                    enumerable:true,
+                    //writable: true,
+                    configurable: true
+                });
+                //obj[key] = (mixin as any)[key];
+            }
+        }
+        for(const key in mixin){
+            Object.defineProperty(obj, key, {
+                get: ()=>mixin[key],
+                set: (value)=>{mixin[key] = value},
+                enumerable:true ,
+                //writable: true  ,
+                configurable: true
+            });
+            //obj[key] = (mixin as any)[key];
+        }
+    }
+    return obj;
+}
+
+/**对对象的每个属性应用映射函数，并返回一个新的对象。
+ * @template T      - 对象的类型
+ * @param obj       - 要处理的对象
+ * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
+ * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
+ */
+export function mapEntries<T extends Object>
+    (obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T {
+    return Object.entries(obj).reduce((result, [key, value]) => {
+        result[key as keyof T] = mapper(key as keyof T, value);
+        return result;
+    }, {} as T);
+}
+
 }