@zwa73/utils 1.0.168 → 1.0.170

package/dist/UtilCom.d.ts

@@ -1,5 +1,5 @@
 import { AnyString, JObject, ReqVerifyFn } from "./UtilInterfaces";
-import { RepeatPromiseOpt } from "./UtilFunctions";
+import { RepeatPromiseOpt, RepeatPromiseResult } from "./UtilFunctions";
 export type ComPostOption = {
     /**请求域名 */
     hostname: string;
@@ -30,7 +30,7 @@ export declare namespace UtilCom {
      * @param timeLimit - 超时时间/秒  最小为10秒
      * @returns 结果 null 为未能成功接收
      */
-    function shttpsPost(json: JObject, options: ComPostOption, timeLimit?: number): Promise<JObject | null>;
+    function httpsPost(json: JObject, options: ComPostOption, timeLimit?: number): Promise<JObject | undefined>;
     /**发送一个 http POST请求并接受数据
      * @async
      * @param json 	    - 数据对象
@@ -38,7 +38,7 @@ export declare namespace UtilCom {
      * @param timeLimit - 超时时间/秒  最小为10秒
      * @returns 结果 null 为未能成功接收
      */
-    function shttpPost(json: JObject, options: ComPostOption, timeLimit?: number): Promise<JObject | null>;
+    function httpPost(json: JObject, options: ComPostOption, timeLimit?: number): Promise<JObject | undefined>;
     /**重复一个 https POST请求并接受数据
      * @async
      * @param json 	   - 数据对象
@@ -51,7 +51,7 @@ export declare namespace UtilCom {
      * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 null 为未能成功接收
      */
-    function shttpsRepeatPost(json: JObject, options: ComPostOption, verifyFn?: ReqVerifyFn<JObject | null>, opt?: RepeatPostOpt): Promise<JObject | null>;
+    function httpsRepeatPost(json: JObject, options: ComPostOption, verifyFn?: ReqVerifyFn<JObject | undefined>, opt?: RepeatPostOpt): Promise<RepeatPromiseResult<JObject | undefined> | undefined>;
     /**重复一个 http POST请求并接受数据
      * Object ()
      * @async
@@ -65,6 +65,6 @@ export declare namespace UtilCom {
      * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 null 为未能成功接收
      */
-    function shttpRepeatPost(json: JObject, options: ComPostOption, verifyFn?: ReqVerifyFn<JObject | null>, opt?: RepeatPostOpt): Promise<JObject | null>;
+    function httpRepeatPost(json: JObject, options: ComPostOption, verifyFn?: ReqVerifyFn<JObject | undefined>, opt?: RepeatPostOpt): Promise<RepeatPromiseResult<JObject | undefined> | undefined>;
 }
 export {};

package/dist/UtilCom.js

@@ -36,9 +36,9 @@ var UtilCom;
      * @param json 	    - 数据对象
      * @param options   - 参数对象
      * @param timeLimit - 超时时间/秒  最小为10秒
-     * @returns 结果 null 为未能成功接收
+     * @returns 结果 undefined 为未能成功接收
      */
-    function sPost(posttype, json, options, timeLimit) {
+    function post(posttype, json, options, timeLimit) {
         //转换为毫秒
         const hasTimeLimit = (timeLimit ? timeLimit >= 10 : false);
         if (hasTimeLimit && timeLimit != undefined)
@@ -54,7 +54,7 @@ var UtilCom;
                         res.setTimeout(fixlimit, () => {
                             //res.abort();
                             UtilLogger_1.SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
-                            resolve(null);
+                            resolve(undefined);
                             return;
                         });
                     }
@@ -63,13 +63,13 @@ var UtilCom;
                     res.on('data', (chunk) => resdata += chunk);
                     res.on('error', (e) => {
                         UtilLogger_1.SLogger.warn(`${funcName} 接收反馈错误:${e}`);
-                        resolve(null);
+                        resolve(undefined);
                         return;
                     });
                     res.on('end', () => {
                         if (resdata == "") {
                             UtilLogger_1.SLogger.warn(funcName + " 接收反馈错误: resdata 为空");
-                            resolve(null);
+                            resolve(undefined);
                             return;
                         }
                         try {
@@ -80,14 +80,14 @@ var UtilCom;
                         }
                         catch (e) {
                             UtilLogger_1.SLogger.warn(`${funcName} 接收反馈错误:${e}\n原始字符串:${resdata}`);
-                            resolve(null);
+                            resolve(undefined);
                             return;
                         }
                     });
                 }
                 catch (err) {
                     UtilLogger_1.SLogger.warn(`${funcName} 未知错误:${err}`);
-                    resolve(null);
+                    resolve(undefined);
                     return;
                 }
             };
@@ -106,7 +106,7 @@ var UtilCom;
             }
             req.on('error', (e) => {
                 UtilLogger_1.SLogger.warn(`${funcName} 发送请求错误:${e}`);
-                resolve(null);
+                resolve(undefined);
             });
             req.write(jsonStr);
             req.end();
@@ -119,10 +119,10 @@ var UtilCom;
      * @param timeLimit - 超时时间/秒  最小为10秒
      * @returns 结果 null 为未能成功接收
      */
-    function shttpsPost(json, options, timeLimit) {
-        return sPost("https", json, options, timeLimit);
+    function httpsPost(json, options, timeLimit) {
+        return post("https", json, options, timeLimit);
     }
-    UtilCom.shttpsPost = shttpsPost;
+    UtilCom.httpsPost = httpsPost;
     /**发送一个 http POST请求并接受数据
      * @async
      * @param json 	    - 数据对象
@@ -130,10 +130,10 @@ var UtilCom;
      * @param timeLimit - 超时时间/秒  最小为10秒
      * @returns 结果 null 为未能成功接收
      */
-    function shttpPost(json, options, timeLimit) {
-        return sPost("http", json, options, timeLimit);
+    function httpPost(json, options, timeLimit) {
+        return post("http", json, options, timeLimit);
     }
-    UtilCom.shttpPost = shttpPost;
+    UtilCom.httpPost = httpPost;
     /**通用重复post处理
      * @async
      * @param posttype - post类型
@@ -147,11 +147,11 @@ var UtilCom;
      * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 null 为未能成功接收
      */
-    async function sRepeatPost(posttype, json, options, verifyFn, opt = {}) {
+    async function repeatPost(posttype, json, options, verifyFn, opt = {}) {
         opt.count = opt.count ?? 3;
         opt.tryInterval = opt.tryInterval ?? 180;
         opt.tryDelay = opt.tryDelay ?? 1;
-        const procFn = () => sPost(posttype, json, options, opt.postTimeLimit);
+        const procFn = () => post(posttype, json, options, opt.postTimeLimit);
         return UtilFunctions_1.UtilFunc.repeatPromise(procFn, verifyFn, opt);
     }
     /**重复一个 https POST请求并接受数据
@@ -166,10 +166,10 @@ var UtilCom;
      * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 null 为未能成功接收
      */
-    function shttpsRepeatPost(json, options, verifyFn, opt) {
-        return sRepeatPost("https", json, options, verifyFn, opt);
+    function httpsRepeatPost(json, options, verifyFn, opt) {
+        return repeatPost("https", json, options, verifyFn, opt);
     }
-    UtilCom.shttpsRepeatPost = shttpsRepeatPost;
+    UtilCom.httpsRepeatPost = httpsRepeatPost;
     /**重复一个 http POST请求并接受数据
      * Object ()
      * @async
@@ -183,8 +183,8 @@ var UtilCom;
      * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 null 为未能成功接收
      */
-    function shttpRepeatPost(json, options, verifyFn, opt) {
-        return sRepeatPost("http", json, options, verifyFn, opt);
+    function httpRepeatPost(json, options, verifyFn, opt) {
+        return repeatPost("http", json, options, verifyFn, opt);
     }
-    UtilCom.shttpRepeatPost = shttpRepeatPost;
+    UtilCom.httpRepeatPost = httpRepeatPost;
 })(UtilCom || (exports.UtilCom = UtilCom = {}));

package/dist/UtilFunctions.d.ts

@@ -32,6 +32,12 @@ export type RepeatPromiseOpt = Partial<{
 }>;
 type SuccessOut<T> = Outcome<Success, T>;
 type TimeoutOut<T> = Outcome<Timeout, Promise<T>>;
+/**完成的重试请求 */
+export type RepeatPromiseResult<T> = {
+    completed: T;
+    /**还未完成的其他Promise 若是验证失败则会返回undefined */
+    pending: Promise<T | undefined>[];
+};
 /**遍历对象的回调函数
  * @param key       - 字段名
  * @param value     - 字段值
@@ -105,12 +111,12 @@ export declare class UtilFunc {
      * @param procFn      - 发起函数
      * @param verifyFn    - 验证函数
      * @param opt         - 可选参数
-     * @param opt.count    - 重试次数 默认3
-     * @param opt.timeout  - 超时时间/秒  默认180 最小为5秒
-     * @param opt.interval - 重试间隔时间 默认0
-     * @returns 结果 null 为全部失败/超时
+     * @param opt.count        - 重试次数 默认3
+     * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
+     * @param opt.tryDelay     - 重试间隔时间 默认0
+     * @returns 结果 undefined 为全部失败/超时
      */
-    static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: ReqVerifyFn<T>, opt?: RepeatPromiseOpt): Promise<T | null>;
+    static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: ReqVerifyFn<T>, opt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<T> | undefined>;
     /**创建一个限时的Promise
      * @param func      - 处理函数
      * @param timeLimit - 毫秒限时

package/dist/UtilFunctions.js

@@ -170,10 +170,10 @@ class UtilFunc {
      * @param procFn      - 发起函数
      * @param verifyFn    - 验证函数
      * @param opt         - 可选参数
-     * @param opt.count    - 重试次数 默认3
-     * @param opt.timeout  - 超时时间/秒  默认180 最小为5秒
-     * @param opt.interval - 重试间隔时间 默认0
-     * @returns 结果 null 为全部失败/超时
+     * @param opt.count        - 重试次数 默认3
+     * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
+     * @param opt.tryDelay     - 重试间隔时间 默认0
+     * @returns 结果 undefined 为全部失败/超时
      */
     static async repeatPromise(procFn, verifyFn, opt = {}) {
         opt.count = opt.count ?? 3;
@@ -247,15 +247,34 @@ class UtilFunc {
                     },
                 });
                 if (result !== UtilSymbol_1.None)
-                    return result;
+                    return {
+                        completed: result,
+                        pending: plist
+                            .filter((p, i) => i != postresult.index)
+                            .filter(p => p != UtilFunc.getNeverResolvedPromise())
+                            .map(async (p) => {
+                            const curObj = await p;
+                            if (curObj.status == UtilSymbol_1.Success) {
+                                const outres = curObj.result;
+                                if (outres.stat == UtilSymbol_1.Success)
+                                    return outres.result;
+                            }
+                            if (curObj.status == UtilSymbol_1.Timeout) {
+                                const outres = await curObj.result;
+                                if (outres.stat == UtilSymbol_1.Success)
+                                    return outres.result;
+                            }
+                            return undefined;
+                        }),
+                    };
             }
-            //全部失败或超时则返回null
+            //全部失败或超时则返回 undefined
             UtilLogger_1.SLogger.warn(`${count} 次 repeatPromise 尝试均失败`);
-            return null;
+            return undefined;
         }
         catch (err) {
             UtilLogger_1.SLogger.warn(`repeatPromise 发生错误`, err);
-            return null;
+            return undefined;
         }
     }
     /**创建一个限时的Promise
@@ -273,17 +292,19 @@ class UtilFunc {
                 if (clearTimer)
                     clearTimer();
             });
-            const timerP = timeLimit
-                ? new Promise((resolve) => {
-                    const timer = setTimeout(() => resolve(UtilFunc.outcome(UtilSymbol_1.Timeout, procer)), timeLimit); //无限制则无限时间
+            if (timeLimit) {
+                const timerP = new Promise((timeResolve) => {
+                    const timer = setTimeout(() => timeResolve(UtilFunc.outcome(UtilSymbol_1.Timeout, procer)), timeLimit);
                     clearTimer = () => {
-                        resolve(UtilFunc.outcome(UtilSymbol_1.Timeout, procer));
+                        timeResolve(UtilFunc.outcome(UtilSymbol_1.Timeout, procer));
                         clearInterval(timer);
                     };
-                }) //未定义时间限制则无限
-                : UtilFunc.getNeverResolvedPromise();
-            const result = Promise.race([procerP, timerP]);
-            reslove(result);
+                });
+                reslove(Promise.race([procerP, timerP]));
+            }
+            else {
+                reslove(procerP);
+            }
         });
     }
     /**对对象的每个属性应用映射函数，并返回一个新的对象。

package/dist/UtilLogger.d.ts

@@ -83,7 +83,7 @@ export declare class SLogger {
      * @param level - log等级 === null时不产生log
      * @returns 格式化的时间字符串
      */
-    timeEnd(flag: string, level?: LogLevel | null): string | null;
+    timeEnd(flag: string, level?: LogLevel | null): string | undefined;
     /**名称为default的slogger实例 */
     private static get defaultInstance();
     /**让名称为default的logger 产生一条对应等级的log 返回自身

package/dist/UtilLogger.js

@@ -242,7 +242,7 @@ class SLogger {
         const start = SLogger.timeTable[flag];
         if (start == null) {
             this.warn("SLogger.timeEnd 错误 flag:" + flag + " 不存在");
-            return null;
+            return;
         }
         const timelen = process.hrtime(start);
         const totalMicroseconds = (timelen[0] * 1e9 + timelen[1]) / 1000;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/utils",
-	"version": "1.0.168",
+	"version": "1.0.170",
 	"description": "my utils",
 	"main": "index.js",
 	"scripts": {

package/src/UtilCom.ts

@@ -2,7 +2,7 @@ import { AnyString, JObject, ReqVerifyFn } from "@src/UtilInterfaces";
 import * as https from 'https';
 import * as http from 'http';
 import { SLogger } from "@src/UtilLogger";
-import { RepeatPromiseOpt, UtilFunc } from "@src/UtilFunctions";
+import { RepeatPromiseOpt, RepeatPromiseResult, UtilFunc } from "@src/UtilFunctions";
 
 export type ComPostOption = {
     /**请求域名 */
@@ -35,9 +35,9 @@ export namespace UtilCom{
  * @param json 	    - 数据对象
  * @param options   - 参数对象
  * @param timeLimit - 超时时间/秒  最小为10秒
- * @returns 结果 null 为未能成功接收
+ * @returns 结果 undefined 为未能成功接收
  */
-function sPost(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|null>{
+function post(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|undefined>{
     //转换为毫秒
     const hasTimeLimit = (timeLimit ? timeLimit>=10 : false );
     if(hasTimeLimit && timeLimit!=undefined) timeLimit*=1000;
@@ -54,7 +54,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLi
                     res.setTimeout(fixlimit, ()=>{
                         //res.abort();
                         SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
-                        resolve(null);
+                        resolve(undefined);
                         return;
                     });
                 }
@@ -65,14 +65,14 @@ function sPost(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLi
 
                 res.on('error',(e)=>{
                     SLogger.warn(`${funcName} 接收反馈错误:${e}`);
-                    resolve(null);
+                    resolve(undefined);
                     return;
                 });
 
                 res.on('end',()=>{
                     if(resdata==""){
                         SLogger.warn(funcName+" 接收反馈错误: resdata 为空");
-                        resolve(null);
+                        resolve(undefined);
                         return;
                     }
                     try{
@@ -83,13 +83,13 @@ function sPost(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLi
                     }
                     catch(e){
                         SLogger.warn(`${funcName} 接收反馈错误:${e}\n原始字符串:${resdata}`);
-                        resolve(null);
+                        resolve(undefined);
                         return;
                     }
                 });
             }catch(err){
                 SLogger.warn(`${funcName} 未知错误:${err}`);
-                resolve(null);
+                resolve(undefined);
                 return;
             }
         };
@@ -110,7 +110,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLi
 
         req.on('error', (e)=>{
             SLogger.warn(`${funcName} 发送请求错误:${e}`);
-            resolve(null);
+            resolve(undefined);
         });
 
         req.write(jsonStr);
@@ -125,8 +125,8 @@ function sPost(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLi
  * @param timeLimit - 超时时间/秒  最小为10秒
  * @returns 结果 null 为未能成功接收
  */
-export function shttpsPost(json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|null>{
-    return sPost("https",json,options,timeLimit);
+export function httpsPost(json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|undefined>{
+    return post("https",json,options,timeLimit);
 }
 
 /**发送一个 http POST请求并接受数据  
@@ -136,8 +136,8 @@ export function shttpsPost(json:JObject,options:ComPostOption,timeLimit?:number)
  * @param timeLimit - 超时时间/秒  最小为10秒
  * @returns 结果 null 为未能成功接收
  */
-export function shttpPost(json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|null>{
-    return sPost("http",json,options,timeLimit);
+export function httpPost(json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|undefined>{
+    return post("http",json,options,timeLimit);
 }
 
 
@@ -155,12 +155,13 @@ export function shttpPost(json:JObject,options:ComPostOption,timeLimit?:number):
  * @param opt.try_delay      - 重试间隔 秒 默认0
  * @returns 结果 null 为未能成功接收
  */
-async function sRepeatPost(posttype:"http"|"https",json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|null>,opt:RepeatPostOpt={}):Promise<JObject|null>{
+async function repeatPost(posttype:"http"|"https",json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|undefined>,opt:RepeatPostOpt={}):
+Promise<RepeatPromiseResult<JObject|undefined>|undefined>{
     opt.count        = opt.count??3;
     opt.tryInterval = opt.tryInterval??180;
     opt.tryDelay    = opt.tryDelay??1;
 
-    const procFn = ()=>sPost(posttype,json,options,opt.postTimeLimit);
+    const procFn = ()=>post(posttype,json,options,opt.postTimeLimit);
     return UtilFunc.repeatPromise(procFn,verifyFn,opt);
 }
 
@@ -177,8 +178,9 @@ async function sRepeatPost(posttype:"http"|"https",json:JObject,options:ComPostO
  * @param opt.try_delay      - 重试间隔 秒 默认0
  * @returns 结果 null 为未能成功接收
  */
-export function shttpsRepeatPost(json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|null>,opt?:RepeatPostOpt):Promise<JObject|null>{
-    return sRepeatPost("https",json,options,verifyFn,opt);
+export function httpsRepeatPost(json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|undefined>,opt?:RepeatPostOpt):
+Promise<RepeatPromiseResult<JObject|undefined>|undefined>{
+    return repeatPost("https",json,options,verifyFn,opt);
 }
 
 /**重复一个 http POST请求并接受数据  
@@ -194,8 +196,9 @@ export function shttpsRepeatPost(json:JObject,options:ComPostOption,verifyFn?:Re
  * @param opt.try_delay      - 重试间隔 秒 默认0
  * @returns 结果 null 为未能成功接收
  */
-export function shttpRepeatPost(json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|null>,opt?:RepeatPostOpt):Promise<JObject|null>{
-    return sRepeatPost("http",json,options,verifyFn,opt);
+export function httpRepeatPost(json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|undefined>,opt?:RepeatPostOpt):
+Promise<RepeatPromiseResult<JObject|undefined>|undefined>{
+    return repeatPost("http",json,options,verifyFn,opt);
 }
 
 }

package/src/UtilFunctions.ts

@@ -56,6 +56,14 @@ type PromiseResult<T> = {
     index:number;
 };
 
+/**完成的重试请求 */
+export type RepeatPromiseResult<T> = {
+    completed:T;
+    /**还未完成的其他Promise 若是验证失败则会返回undefined */
+    pending:Promise<T|undefined>[];
+}
+
+
 /**遍历对象的回调函数
  * @param key       - 字段名
  * @param value     - 字段值
@@ -216,13 +224,14 @@ static getNeverResolvedPromise<T>():Promise<T>{
  * @param procFn      - 发起函数
  * @param verifyFn    - 验证函数
  * @param opt         - 可选参数
- * @param opt.count    - 重试次数 默认3
- * @param opt.timeout  - 超时时间/秒  默认180 最小为5秒
- * @param opt.interval - 重试间隔时间 默认0
- * @returns 结果 null 为全部失败/超时
+ * @param opt.count        - 重试次数 默认3
+ * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
+ * @param opt.tryDelay     - 重试间隔时间 默认0
+ * @returns 结果 undefined 为全部失败/超时
  */
 @LogTimeAsync("repeatPromise ",true)
-static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,opt:RepeatPromiseOpt = {}):Promise<T|null>{
+static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,opt:RepeatPromiseOpt = {}):
+Promise<RepeatPromiseResult<T>|undefined>{
     opt.count = opt.count??3;
     opt.tryInterval = opt.tryInterval??180;
     let {count,tryInterval} = opt;
@@ -300,14 +309,31 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,opt
                     return None;
                 },
             });
-            if(result !== None) return result;
+            if(result !== None) return {
+                completed:result,
+                pending:plist
+                    .filter((p,i)=>i!=postresult.index)
+                    .filter(p=>p!=UtilFunc.getNeverResolvedPromise())
+                    .map(async p=>{
+                        const curObj = await p;
+                        if(curObj.status==Success){
+                            const outres = curObj.result;
+                            if(outres.stat==Success) return outres.result;
+                        }
+                        if(curObj.status==Timeout){
+                            const outres = await curObj.result;
+                            if(outres.stat==Success) return outres.result;
+                        }
+                        return undefined;
+                    }),
+            };
         }
-        //全部失败或超时则返回null
+        //全部失败或超时则返回 undefined
         SLogger.warn(`${count} 次 repeatPromise 尝试均失败`);
-        return null;
+        return undefined;
     }catch(err){
         SLogger.warn(`repeatPromise 发生错误`,err);
-        return null;
+        return undefined;
     }
 }
 
@@ -329,21 +355,21 @@ static timelimitPromise<T>
             if(clearTimer) clearTimer();
         });
 
-        const timerP = timeLimit
-            ? new Promise<TimeoutOut<T>>((resolve)=>{
+        if(timeLimit){
+            const timerP = new Promise<TimeoutOut<T>>((timeResolve)=>{
                 const timer = setTimeout(()=>
-                    resolve(UtilFunc.outcome(Timeout,procer))
-                ,timeLimit);//无限制则无限时间
+                    timeResolve(UtilFunc.outcome(Timeout,procer)), timeLimit);
 
                 clearTimer = ()=>{
-                    resolve(UtilFunc.outcome(Timeout,procer))
+                    timeResolve(UtilFunc.outcome(Timeout,procer))
                     clearInterval(timer)
                 }
-            })//未定义时间限制则无限
-            : UtilFunc.getNeverResolvedPromise<TimeoutOut<T>>();
+            });
 
-        const result = Promise.race([procerP,timerP]);
-        reslove(result);
+            reslove(Promise.race([procerP,timerP]));
+        }else{
+            reslove(procerP);
+        }
     })
 }
 

package/src/UtilLogger.ts

@@ -230,11 +230,11 @@ export class SLogger{
      * @param level - log等级 === null时不产生log
      * @returns 格式化的时间字符串
      */
-    timeEnd(flag:string,level:LogLevel|null="info"):string|null{
+    timeEnd(flag:string,level:LogLevel|null="info"):string|undefined{
         const start = SLogger.timeTable[flag];
         if(start==null){
             this.warn("SLogger.timeEnd 错误 flag:"+flag+" 不存在");
-            return null;
+            return;
         }
         const timelen = process.hrtime(start as any as [number,number]);