@zwa73/utils 1.0.173 → 1.0.175

package/dist/UtilCom.d.ts

@@ -1,11 +1,22 @@
 import { AnyString, JObject, ReqVerifyFn } from "./UtilInterfaces";
 import http from 'http';
 import { RepeatPromiseOpt, RepeatPromiseResult } from "./UtilFunctions";
-export type ComRequestOption = {
-    /**超时时间/秒  最小为10秒 */
-    timeLimit?: number;
+/**网络请求返回值 */
+export type ComResp<T> = {
+    /**响应头 */
+    headers: http.IncomingHttpHeaders;
+    /**响应状态码 */
+    statusCode?: number;
+    /**响应数据 */
+    data: T;
+};
+/**网络请求选项 */
+export type ComReqOpt = {
     /**请求协议 */
     protocol: 'http' | 'https';
+    /**超时时间/毫秒  最小为10_000 默认无限 */
+    timeLimit?: number;
+} & {
     /**请求域名 */
     hostname: string;
     /**请求路径 */
@@ -21,92 +32,128 @@ export type ComRequestOption = {
         /**内容长度 一般无需填写 应为buffer长度而非字符串长度 */
         'Content-Length'?: number;
     };
-};
-type HttpResp = {
-    /**响应头 */
-    headers: http.IncomingHttpHeaders;
-    /**响应状态码 */
-    statusCode?: number;
-    /**响应数据 */
-    data: JObject;
-};
+} & http.RequestOptions;
+/**get请求所允许的数据 */
+export type GetReqData = NodeJS.Dict<string | number | boolean | readonly string[] | readonly number[] | readonly boolean[] | null>;
 /**网络工具 */
 export declare namespace UtilCom {
+    /**网络请求
+     * @param comReqOpt  - 网络请求选项
+     * @param procReq    - 请求处理函数
+     * @param reduceData - 数据处理函数
+     * @param initData   - 初始数据
+     */
+    function comReq<T>(comReqOpt: ComReqOpt, procReq: ((req: http.ClientRequest) => void | Promise<void>), reduceData: (acc: T, data: string) => T, initData: T): Promise<ComResp<T> | undefined>;
     /**发送一个 https POST 请求并接受数据
      * @async
-     * @param json 	      - 数据对象
      * @param comReqOpt   - 请求参数
+     * @param reqData     - 数据对象
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpsPost(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>): Promise<HttpResp | undefined>;
+    function httpsPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData: JObject | undefined): Promise<{
+        data: JObject;
+        /**响应头 */
+        headers: http.IncomingHttpHeaders;
+        /**响应状态码 */
+        statusCode?: number;
+    } | undefined>;
     /**发送一个 http POST 请求并接受数据
      * @async
-     * @param json 	      - 数据对象
      * @param comReqOpt   - 请求参数
+     * @param reqData 	  - 数据对象
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpPost(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>): Promise<HttpResp | undefined>;
+    function httpPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData: JObject | undefined): Promise<{
+        data: JObject;
+        /**响应头 */
+        headers: http.IncomingHttpHeaders;
+        /**响应状态码 */
+        statusCode?: number;
+    } | undefined>;
     /**发送一个 https GET 请求并接受数据
      * @async
-     * @param json 	      - 数据对象
      * @param comReqOpt   - 请求参数
+     * @param reqData     - 数据对象
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpsGet(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>): Promise<HttpResp | undefined>;
+    function httpsGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData: Record<string, string | number | boolean>): Promise<{
+        data: JObject;
+        /**响应头 */
+        headers: http.IncomingHttpHeaders;
+        /**响应状态码 */
+        statusCode?: number;
+    } | undefined>;
     /**发送一个 http GET 请求并接受数据
      * @async
-     * @param json 	      - 数据对象
      * @param comReqOpt   - 请求参数
+     * @param reqData 	  - 数据对象
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpGet(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>): Promise<HttpResp | undefined>;
+    function httpGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData: Record<string, string | number | boolean>): Promise<{
+        data: JObject;
+        /**响应头 */
+        headers: http.IncomingHttpHeaders;
+        /**响应状态码 */
+        statusCode?: number;
+    } | undefined>;
     /**重复一个 https POST请求并接受数据
      * @async
-     * @param json 	     - 数据对象
-     * @param comReqOpt  - 请求参数
-     * @param verifyFn   - 判断有效性函数
-     * @param repeatOpt  - 可选参数
-     * @param opt.count        - 重试次数 默认3
-     * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
-     * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+     * @param comReqOpt - 网络请求选项
+     * @param reqData   - 数据对象
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 延迟默认为 1000 ms
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpsRepeatPost(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<HttpResp | undefined> | undefined>;
+    function httpsRepeatPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: JObject, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
+        data: JObject;
+        /**响应头 */
+        headers: http.IncomingHttpHeaders;
+        /**响应状态码 */
+        statusCode?: number;
+    } | undefined> | undefined>;
     /**重复一个 http POST请求并接受数据
      * @async
-     * @param json 	      - 数据对象
-     * @param comReqOpt   - 请求参数
-     * @param verifyFn    - 判断有效性函数
-     * @param repeatOpt   - 可选参数
-     * @param opt.count        - 重试次数 默认3
-     * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
-     * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+     * @param comReqOpt - 网络请求选项
+     * @param reqData   - 数据对象
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 延迟默认为 1000 ms
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpRepeatPost(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<HttpResp | undefined> | undefined>;
+    function httpRepeatPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: JObject, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
+        data: JObject;
+        /**响应头 */
+        headers: http.IncomingHttpHeaders;
+        /**响应状态码 */
+        statusCode?: number;
+    } | undefined> | undefined>;
     /**重复一个 https GET 请求并接受数据
      * @async
-     * @param json 	     - 数据对象
-     * @param comReqOpt  - 请求参数
-     * @param verifyFn   - 判断有效性函数
-     * @param repeatOpt  - 可选参数
-     * @param opt.count        - 重试次数 默认3
-     * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
-     * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+     * @param comReqOpt - 网络请求选项
+     * @param reqData   - 数据对象
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 延迟默认为 1000 ms
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpsRepeatGet(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<HttpResp | undefined> | undefined>;
+    function httpsRepeatGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: GetReqData, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
+        data: JObject;
+        /**响应头 */
+        headers: http.IncomingHttpHeaders;
+        /**响应状态码 */
+        statusCode?: number;
+    } | undefined> | undefined>;
     /**重复一个 http GET 请求并接受数据
      * @async
-     * @param json 	      - 数据对象
-     * @param comReqOpt   - 请求参数
-     * @param verifyFn    - 判断有效性函数
-     * @param repeatOpt   - 可选参数
-     * @param opt.count        - 重试次数 默认3
-     * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
-     * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+     * @param comReqOpt - 网络请求选项
+     * @param reqData   - 数据对象
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 延迟默认为 1000 ms
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpRepeatGet(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<HttpResp | undefined> | undefined>;
+    function httpRepeatGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: GetReqData, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
+        data: JObject;
+        /**响应头 */
+        headers: http.IncomingHttpHeaders;
+        /**响应状态码 */
+        statusCode?: number;
+    } | undefined> | undefined>;
 }
-export {};

package/dist/UtilCom.js

@@ -12,240 +12,237 @@ const querystring_1 = __importDefault(require("querystring"));
 /**网络工具 */
 var UtilCom;
 (function (UtilCom) {
-    /**通用post处理
-     * @param json 	    - 数据对象
-     * @param comReqOpt - 请求参数
-     * @param timeLimit - 超时时间/秒  最小为10秒
-     * @returns 结果 undefined 为未能成功接收
+    /**网络请求
+     * @param comReqOpt  - 网络请求选项
+     * @param procReq    - 请求处理函数
+     * @param reduceData - 数据处理函数
+     * @param initData   - 初始数据
      */
-    function comReq(json, comReqOpt) {
-        let { protocol, timeLimit, ...baseOpt } = comReqOpt;
-        //转换为毫秒
-        const hasTimeLimit = (timeLimit ? timeLimit >= 10 : false);
-        if (hasTimeLimit && timeLimit != undefined)
-            timeLimit *= 1000;
-        const fixlimit = timeLimit;
-        const isPost = baseOpt.method == "POST";
-        const isHttps = protocol == "https";
-        const jsonStr = isPost ? UtilFunctions_1.UtilFunc.stringifyJToken(json) : '';
-        const funcName = `${protocol}${baseOpt.method}`;
-        if (!isPost)
-            baseOpt.path += `?${querystring_1.default.stringify(json)}`;
-        return new Promise((resolve, rejecte) => {
+    async function comReq(comReqOpt, procReq, reduceData, initData) {
+        const { protocol, timeLimit, ...baseReqOpt } = comReqOpt;
+        const hasTimeLimit = (timeLimit ? timeLimit >= 10_000 : false);
+        const flagName = `${comReq.name}.${protocol}${baseReqOpt.method}`;
+        return new Promise(async (resolve, rejecte) => {
             const resFunc = (res) => {
                 try {
                     //请求超时
                     if (hasTimeLimit) {
-                        res.setTimeout(fixlimit, () => {
-                            //res.abort();
-                            UtilLogger_1.SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
+                        res.setTimeout(timeLimit, () => {
+                            UtilLogger_1.SLogger.warn(`${flagName} 接收反馈超时(timeLimit): ${timeLimit} ms`);
                             resolve(undefined);
                             return;
                         });
                     }
-                    let resdata = "";
+                    let mergedata = initData;
                     res.setEncoding('utf8');
-                    res.on('data', (chunk) => resdata += chunk);
+                    res.on('data', chunk => mergedata = reduceData(mergedata, chunk));
                     res.on('error', (e) => {
-                        UtilLogger_1.SLogger.warn(`${funcName} 接收反馈错误:${e}`);
+                        UtilLogger_1.SLogger.warn(`${flagName} 接收反馈错误:${e}`);
                         resolve(undefined);
                         return;
                     });
                     res.on('end', () => {
-                        if (resdata == "") {
-                            UtilLogger_1.SLogger.warn(`${funcName} 接收反馈错误: resdata 为空`);
-                            resolve(undefined);
-                            return;
-                        }
-                        try {
-                            const obj = JSON.parse(resdata);
-                            UtilLogger_1.SLogger.http(`${funcName} 接受信息:`, UtilFunctions_1.UtilFunc.stringifyJToken(obj, { compress: true, space: 2 }));
-                            resolve({
-                                headers: res.headers,
-                                statusCode: res.statusCode,
-                                data: obj,
-                            });
-                            return;
-                        }
-                        catch (e) {
-                            UtilLogger_1.SLogger.warn(`${funcName} 接收反馈错误:${e}\n原始字符串:${resdata}`);
-                            resolve(undefined);
-                            return;
-                        }
+                        resolve({
+                            headers: res.headers,
+                            statusCode: res.statusCode,
+                            data: mergedata,
+                        });
                     });
                 }
                 catch (err) {
-                    UtilLogger_1.SLogger.warn(`${funcName} 未知错误:${err}`);
+                    UtilLogger_1.SLogger.warn(`${flagName} 未知错误:${err}`);
                     resolve(undefined);
                     return;
                 }
             };
             //路由 http/https
-            const req = isHttps
-                ? https_1.default.request(baseOpt, resFunc)
-                : http_1.default.request(baseOpt, resFunc);
+            const req = protocol == "https"
+                ? https_1.default.request(baseReqOpt, resFunc)
+                : http_1.default.request(baseReqOpt, resFunc);
             //请求超时
             if (hasTimeLimit) {
-                req.setTimeout(fixlimit, () => {
-                    UtilLogger_1.SLogger.warn(`${funcName} 发送请求超时: ${timeLimit} ms`);
+                req.setTimeout(timeLimit, () => {
+                    UtilLogger_1.SLogger.warn(`${flagName} 发送请求超时(timeLimit): ${timeLimit} ms`);
+                    req.destroy();
+                });
+                req.on('timeout', () => {
+                    UtilLogger_1.SLogger.warn(`${flagName} 发送请求超时(timeout): ${timeLimit} ms`);
                     req.destroy();
                 });
             }
             req.on('error', (e) => {
-                UtilLogger_1.SLogger.warn(`${funcName} 发送请求错误:${e}`);
+                UtilLogger_1.SLogger.warn(`${flagName} 发送请求错误:${e}`);
                 resolve(undefined);
             });
-            if (isHttps)
-                req.write(jsonStr);
+            await procReq(req);
             req.end();
         });
     }
-    /**通用重复post处理
+    UtilCom.comReq = comReq;
+    /**发送json的网络请求
+     * @param comReqOpt - 网络请求选项
+     * @param reqData   - 数据对象
+     * @returns 结果 undefined 为未能成功接收
+     */
+    async function jsonReq(comReqOpt, reqData) {
+        const { method } = comReqOpt;
+        const isPost = (method == "POST");
+        if (!isPost && reqData != undefined)
+            comReqOpt.path += querystring_1.default.stringify(reqData);
+        const procReq = (req) => {
+            if (isPost)
+                req.write(JSON.stringify(reqData));
+        };
+        const reduceData = (acc, data) => acc + data;
+        const result = await comReq(comReqOpt, procReq, reduceData, "");
+        if (result == undefined)
+            return undefined;
+        const { data, ...rest } = result;
+        if (data == "") {
+            UtilLogger_1.SLogger.warn(`${jsonReq.name} 接收反馈错误: 原始字符串为空`);
+            return undefined;
+        }
+        try {
+            const obj = JSON.parse(data);
+            UtilLogger_1.SLogger.http(`${jsonReq.name} 接受信息:`, UtilFunctions_1.UtilFunc.stringifyJToken(obj, { compress: true, space: 2 }));
+            return { ...rest, data: obj };
+        }
+        catch (e) {
+            UtilLogger_1.SLogger.warn(`${jsonReq.name} 接收反馈错误:${e}\n原始字符串:${data}`);
+            return undefined;
+        }
+    }
+    /**重复发送json的网络请求
      * @async
-     * @param json 	    - 数据对象
-     * @param comReqOpt - 请求参数
-     * @param verifyFn  - 判断有效性函数
-     * @param repeatOpt - 可选参数
-     * @param opt.count        - 重试次数 默认3
-     * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
-     * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+     * @param comReqOpt - 网络请求选项
+     * @param reqData   - 数据对象
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 延迟默认为 1000 ms
      * @returns 结果 undefined 为未能成功接收
      */
-    async function repeatComReq(json, comReqOpt, verifyFn, repeatOpt = {}) {
-        repeatOpt.tryDelay = repeatOpt.tryDelay ?? 1;
-        const procFn = () => comReq(json, comReqOpt);
+    async function repeatJsonComReq(comReqOpt, reqData, verifyFn, repeatOpt = {}) {
+        repeatOpt.tryDelay = repeatOpt.tryDelay ?? 1000;
+        const procFn = () => jsonReq(comReqOpt, reqData);
         return UtilFunctions_1.UtilFunc.repeatPromise(procFn, verifyFn, repeatOpt);
     }
     /**发送一个 https POST 请求并接受数据
      * @async
-     * @param json 	      - 数据对象
      * @param comReqOpt   - 请求参数
+     * @param reqData     - 数据对象
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpsPost(json, comReqOpt) {
-        return comReq(json, {
+    function httpsPost(comReqOpt, reqData) {
+        return jsonReq({
             ...comReqOpt,
             method: "POST",
             protocol: "https",
-        });
+        }, reqData);
     }
     UtilCom.httpsPost = httpsPost;
     /**发送一个 http POST 请求并接受数据
      * @async
-     * @param json 	      - 数据对象
      * @param comReqOpt   - 请求参数
+     * @param reqData 	  - 数据对象
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpPost(json, comReqOpt) {
-        return comReq(json, {
+    function httpPost(comReqOpt, reqData) {
+        return jsonReq({
             ...comReqOpt,
             method: "POST",
             protocol: "http",
-        });
+        }, reqData);
     }
     UtilCom.httpPost = httpPost;
     /**发送一个 https GET 请求并接受数据
      * @async
-     * @param json 	      - 数据对象
      * @param comReqOpt   - 请求参数
+     * @param reqData     - 数据对象
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpsGet(json, comReqOpt) {
-        return comReq(json, {
+    function httpsGet(comReqOpt, reqData) {
+        return jsonReq({
             ...comReqOpt,
             method: "GET",
             protocol: "https",
-        });
+        }, reqData);
     }
     UtilCom.httpsGet = httpsGet;
     /**发送一个 http GET 请求并接受数据
      * @async
-     * @param json 	      - 数据对象
      * @param comReqOpt   - 请求参数
+     * @param reqData 	  - 数据对象
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpGet(json, comReqOpt) {
-        return comReq(json, {
+    function httpGet(comReqOpt, reqData) {
+        return jsonReq({
             ...comReqOpt,
             method: "GET",
             protocol: "http",
-        });
+        }, reqData);
     }
     UtilCom.httpGet = httpGet;
     /**重复一个 https POST请求并接受数据
      * @async
-     * @param json 	     - 数据对象
-     * @param comReqOpt  - 请求参数
-     * @param verifyFn   - 判断有效性函数
-     * @param repeatOpt  - 可选参数
-     * @param opt.count        - 重试次数 默认3
-     * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
-     * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+     * @param comReqOpt - 网络请求选项
+     * @param reqData   - 数据对象
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 延迟默认为 1000 ms
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpsRepeatPost(json, comReqOpt, verifyFn, repeatOpt) {
-        return repeatComReq(json, {
+    function httpsRepeatPost(comReqOpt, reqData, verifyFn, repeatOpt) {
+        return repeatJsonComReq({
             ...comReqOpt,
             method: "POST",
             protocol: "https",
-        }, verifyFn, repeatOpt);
+        }, reqData, verifyFn, repeatOpt);
     }
     UtilCom.httpsRepeatPost = httpsRepeatPost;
     /**重复一个 http POST请求并接受数据
      * @async
-     * @param json 	      - 数据对象
-     * @param comReqOpt   - 请求参数
-     * @param verifyFn    - 判断有效性函数
-     * @param repeatOpt   - 可选参数
-     * @param opt.count        - 重试次数 默认3
-     * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
-     * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+     * @param comReqOpt - 网络请求选项
+     * @param reqData   - 数据对象
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 延迟默认为 1000 ms
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpRepeatPost(json, comReqOpt, verifyFn, repeatOpt) {
-        return repeatComReq(json, {
+    function httpRepeatPost(comReqOpt, reqData, verifyFn, repeatOpt) {
+        return repeatJsonComReq({
             ...comReqOpt,
             method: "POST",
             protocol: "http",
-        }, verifyFn, repeatOpt);
+        }, reqData, verifyFn, repeatOpt);
     }
     UtilCom.httpRepeatPost = httpRepeatPost;
     /**重复一个 https GET 请求并接受数据
      * @async
-     * @param json 	     - 数据对象
-     * @param comReqOpt  - 请求参数
-     * @param verifyFn   - 判断有效性函数
-     * @param repeatOpt  - 可选参数
-     * @param opt.count        - 重试次数 默认3
-     * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
-     * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+     * @param comReqOpt - 网络请求选项
+     * @param reqData   - 数据对象
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 延迟默认为 1000 ms
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpsRepeatGet(json, comReqOpt, verifyFn, repeatOpt) {
-        return repeatComReq(json, {
+    function httpsRepeatGet(comReqOpt, reqData, verifyFn, repeatOpt) {
+        return repeatJsonComReq({
             ...comReqOpt,
             method: "GET",
             protocol: "https",
-        }, verifyFn, repeatOpt);
+        }, reqData, verifyFn, repeatOpt);
     }
     UtilCom.httpsRepeatGet = httpsRepeatGet;
     /**重复一个 http GET 请求并接受数据
      * @async
-     * @param json 	      - 数据对象
-     * @param comReqOpt   - 请求参数
-     * @param verifyFn    - 判断有效性函数
-     * @param repeatOpt   - 可选参数
-     * @param opt.count        - 重试次数 默认3
-     * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
-     * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+     * @param comReqOpt - 网络请求选项
+     * @param reqData   - 数据对象
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 延迟默认为 1000 ms
      * @returns 结果 undefined 为未能成功接收
      */
-    function httpRepeatGet(json, comReqOpt, verifyFn, repeatOpt) {
-        return repeatComReq(json, {
+    function httpRepeatGet(comReqOpt, reqData, verifyFn, repeatOpt) {
+        return repeatJsonComReq({
             ...comReqOpt,
             method: "GET",
             protocol: "http",
-        }, verifyFn, repeatOpt);
+        }, reqData, verifyFn, repeatOpt);
     }
     UtilCom.httpRepeatGet = httpRepeatGet;
 })(UtilCom || (exports.UtilCom = UtilCom = {}));

package/dist/UtilFunctions.d.ts

@@ -24,10 +24,10 @@ export type RepeatPromiseOpt = Partial<{
     /**重试次数 默认3*/
     count?: number;
     /**尝试间隔时间 超过此事件会重新创建新的Promise
-     * 同时等待新的与旧的Promise 秒 默认180
+     * 同时等待新的与旧的Promise 毫秒 默认180_000
      */
     tryInterval?: number;
-    /**尝试延迟 重新尝试时会先等待此秒数 秒 默认0*/
+    /**尝试延迟 重新尝试时会先等待此毫秒数 毫秒 默认0*/
     tryDelay?: number;
 }>;
 type SuccessOut<T> = Outcome<Success, T>;
@@ -111,9 +111,6 @@ export declare class UtilFunc {
      * @param procFn      - 发起函数
      * @param verifyFn    - 验证函数
      * @param opt         - 可选参数
-     * @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<RepeatPromiseResult<T> | undefined>;

package/dist/UtilFunctions.js

@@ -170,20 +170,14 @@ class UtilFunc {
      * @param procFn      - 发起函数
      * @param verifyFn    - 验证函数
      * @param opt         - 可选参数
-     * @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;
-        opt.tryInterval = opt.tryInterval ?? 180;
-        let { count, tryInterval } = opt;
+        opt.tryInterval = opt.tryInterval ?? 180_000;
+        const { count, tryInterval } = opt;
         /**是否含有超时时间 */
-        const hasRepeatTime = (tryInterval >= 5);
-        //转换为毫秒
-        if (hasRepeatTime)
-            tryInterval *= 1000;
+        const hasRepeatTime = (tryInterval >= 5000);
         //验证处理函数
         if (verifyFn === undefined)
             verifyFn = () => UtilSymbol_1.Success;
@@ -194,7 +188,7 @@ class UtilFunc {
             //根据最大重试次数限制进行循环
             for (let i = 0; i < count;) {
                 if (i > 0 && opt.tryDelay)
-                    await this.sleep(opt.tryDelay * 1000);
+                    await this.sleep(opt.tryDelay);
                 UtilLogger_1.SLogger.info(`开始第 ${i + 1} 次 repeatPromise`);
                 //如果 plist 中当前下标的任务还未创建 则 创建当前任务
                 if (plist.length < i + 1) {

package/package.json

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

package/src/UtilCom.ts

@@ -1,15 +1,27 @@
-import { AnyString, JObject, ReqVerifyFn } from "@src/UtilInterfaces";
+import { AnyString, JObject, PRecord, ReqVerifyFn } from "@src/UtilInterfaces";
 import https from 'https';
 import http from 'http';
 import { SLogger } from "@src/UtilLogger";
 import { RepeatPromiseOpt, RepeatPromiseResult, UtilFunc } from "@src/UtilFunctions";
 import qs from "querystring";
 
-export type ComRequestOption = {
-    /**超时时间/秒  最小为10秒 */
-    timeLimit?:number
+/**网络请求返回值 */
+export type ComResp<T> = {
+    /**响应头 */
+    headers: http.IncomingHttpHeaders;
+    /**响应状态码 */
+    statusCode?: number;
+    /**响应数据 */
+    data: T;
+}
+
+/**网络请求选项 */
+export type ComReqOpt = {
     /**请求协议 */
     protocol: 'http'|'https';
+    /**超时时间/毫秒  最小为10_000 默认无限 */
+    timeLimit?:number;
+}&{
     /**请求域名 */
     hostname: string;
     /**请求路径 */
@@ -24,269 +36,302 @@ export type ComRequestOption = {
         'Content-Type'?: 'application/json'|AnyString;
         /**内容长度 一般无需填写 应为buffer长度而非字符串长度 */
         'Content-Length'?: number;
-    }
-}
+    };
+}&http.RequestOptions;
 
-type HttpResp = {
-    /**响应头 */
-    headers: http.IncomingHttpHeaders;
-    /**响应状态码 */
-    statusCode?: number;
-    /**响应数据 */
-    data: JObject;
-}
+/**get请求所允许的数据 */
+export type GetReqData = NodeJS.Dict<
+| string
+| number
+| boolean
+| readonly string[]
+| readonly number[]
+| readonly boolean[]
+| null
+>;
 
 /**网络工具 */
 export namespace UtilCom{
 
-/**通用post处理  
- * @param json 	    - 数据对象
- * @param comReqOpt - 请求参数
- * @param timeLimit - 超时时间/秒  最小为10秒
- * @returns 结果 undefined 为未能成功接收
- */
-function comReq(json:JObject,comReqOpt:ComRequestOption):Promise<HttpResp|undefined>{
-    let {protocol,timeLimit,...baseOpt} = comReqOpt;
-
-    //转换为毫秒
-    const hasTimeLimit = (timeLimit ? timeLimit>=10 : false );
-    if(hasTimeLimit && timeLimit!=undefined) timeLimit*=1000;
-    const fixlimit = timeLimit as number;
 
-    const isPost = baseOpt.method=="POST";
-    const isHttps = protocol=="https";
+/**网络请求
+ * @param comReqOpt  - 网络请求选项
+ * @param procReq    - 请求处理函数
+ * @param reduceData - 数据处理函数
+ * @param initData   - 初始数据
+ */
+export async function comReq<T>(
+    comReqOpt:ComReqOpt,
+    procReq:((req:http.ClientRequest)=>void|Promise<void>),
+    reduceData:(acc:T,data:string)=>T,
+    initData:T,
+){
+    const {protocol,timeLimit,...baseReqOpt} = comReqOpt;
 
-    const jsonStr = isPost ? UtilFunc.stringifyJToken(json) : '';
-    const funcName = `${protocol}${baseOpt.method}`;
+    const hasTimeLimit = (timeLimit ? timeLimit>=10_000 : false );
 
-    if(!isPost) baseOpt.path += `?${qs.stringify(json as any)}`;
+    const flagName = `${comReq.name}.${protocol}${baseReqOpt.method}`;
 
-    return new Promise((resolve, rejecte)=>{
+    return new Promise<ComResp<T>|undefined>(async (resolve, rejecte)=>{
         const resFunc = (res:http.IncomingMessage)=>{
             try{
                 //请求超时
                 if(hasTimeLimit){
-                    res.setTimeout(fixlimit, ()=>{
-                        //res.abort();
-                        SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
+                    res.setTimeout(timeLimit!, ()=>{
+                        SLogger.warn(`${flagName} 接收反馈超时(timeLimit): ${timeLimit} ms`);
                         resolve(undefined);
                         return;
                     });
                 }
 
-                let resdata = "";
+                let mergedata:T = initData;
                 res.setEncoding('utf8');
-                res.on('data',(chunk)=>resdata+=chunk);
+                res.on('data',chunk => mergedata=reduceData(mergedata,chunk));
 
                 res.on('error',(e)=>{
-                    SLogger.warn(`${funcName} 接收反馈错误:${e}`);
+                    SLogger.warn(`${flagName} 接收反馈错误:${e}`);
                     resolve(undefined);
                     return;
                 });
 
                 res.on('end',()=>{
-                    if(resdata==""){
-                        SLogger.warn(`${funcName} 接收反馈错误: resdata 为空`);
-                        resolve(undefined);
-                        return;
-                    }
-                    try{
-                        const obj = JSON.parse(resdata) as JObject;
-                        SLogger.http(`${funcName} 接受信息:`,UtilFunc.stringifyJToken(obj,{compress:true,space:2}));
-                        resolve({
-                            headers: res.headers,
-                            statusCode: res.statusCode,
-                            data: obj,
-                        });
-                        return;
-                    }
-                    catch(e){
-                        SLogger.warn(`${funcName} 接收反馈错误:${e}\n原始字符串:${resdata}`);
-                        resolve(undefined);
-                        return;
-                    }
+                    resolve({
+                        headers: res.headers,
+                        statusCode: res.statusCode,
+                        data: mergedata,
+                    });
                 });
             }catch(err){
-                SLogger.warn(`${funcName} 未知错误:${err}`);
+                SLogger.warn(`${flagName} 未知错误:${err}`);
                 resolve(undefined);
                 return;
             }
         };
         //路由 http/https
-        const req:http.ClientRequest= isHttps
-            ? https.request(baseOpt, resFunc)
-            : http.request(baseOpt, resFunc);
+        const req:http.ClientRequest= protocol=="https"
+            ? https.request(baseReqOpt as http.RequestOptions, resFunc)
+            : http.request(baseReqOpt  as http.RequestOptions, resFunc);
 
         //请求超时
         if(hasTimeLimit){
-            req.setTimeout(fixlimit, ()=>{
-                SLogger.warn(`${funcName} 发送请求超时: ${timeLimit} ms`);
+            req.setTimeout(timeLimit!, ()=>{
+                SLogger.warn(`${flagName} 发送请求超时(timeLimit): ${timeLimit} ms`);
+                req.destroy();
+            });
+            req.on('timeout', ()=>{
+                SLogger.warn(`${flagName} 发送请求超时(timeout): ${timeLimit} ms`);
                 req.destroy();
             });
         }
 
         req.on('error', (e)=>{
-            SLogger.warn(`${funcName} 发送请求错误:${e}`);
+            SLogger.warn(`${flagName} 发送请求错误:${e}`);
             resolve(undefined);
         });
-        if(isHttps) req.write(jsonStr);
+
+        await procReq(req);
+
         req.end();
     });
 }
 
-/**通用重复post处理  
- * @async
- * @param json 	    - 数据对象
- * @param comReqOpt - 请求参数
- * @param verifyFn  - 判断有效性函数
- * @param repeatOpt - 可选参数
- * @param opt.count        - 重试次数 默认3
- * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
- * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+/**发送json的网络请求  
+ * @param comReqOpt - 网络请求选项
+ * @param reqData   - 数据对象
  * @returns 结果 undefined 为未能成功接收
  */
-async function repeatComReq(json:JObject,comReqOpt:ComRequestOption,verifyFn?:ReqVerifyFn<JObject|undefined>,repeatOpt:RepeatPromiseOpt={}):
-Promise<RepeatPromiseResult<HttpResp|undefined>|undefined>{
-    repeatOpt.tryDelay    = repeatOpt.tryDelay??1;
+async function jsonReq<T extends ComReqOpt>(
+    comReqOpt:T,
+    reqData?:T['method'] extends "POST" ? JObject :GetReqData
+){
+    const {method} = comReqOpt;
+    const isPost = (method=="POST");
+
+    if(!isPost && reqData!=undefined) comReqOpt.path+=qs.stringify(reqData as GetReqData);
 
-    const procFn = ()=>comReq(json,comReqOpt);
+    const procReq = (req:http.ClientRequest)=>{
+        if(isPost) req.write(JSON.stringify(reqData));
+    }
+
+    const reduceData = (acc:string,data:string)=>acc+data;
+    const result = await comReq(comReqOpt,procReq,reduceData,"");
+    if(result==undefined) return undefined;
+    const {data,...rest} = result;
+
+    if(data==""){
+        SLogger.warn(`${jsonReq.name} 接收反馈错误: 原始字符串为空`);
+        return undefined;
+    }
+
+    try{
+        const obj = JSON.parse(data) as JObject;
+        SLogger.http(`${jsonReq.name} 接受信息:`,UtilFunc.stringifyJToken(obj,{compress:true,space:2}));
+        return{...rest,data:obj};
+    }
+    catch(e){
+        SLogger.warn(`${jsonReq.name} 接收反馈错误:${e}\n原始字符串:${data}`);
+        return undefined;
+    }
+}
+
+/**重复发送json的网络请求  
+ * @async
+ * @param comReqOpt - 网络请求选项
+ * @param reqData   - 数据对象
+ * @param verifyFn  - 有效性验证函数
+ * @param repeatOpt - 重试选项 延迟默认为 1000 ms
+ * @returns 结果 undefined 为未能成功接收
+ */
+async function repeatJsonComReq<T extends ComReqOpt>(
+    comReqOpt:T,
+    reqData?:T['method'] extends "POST" ? JObject :GetReqData,
+    verifyFn?:ReqVerifyFn<ComResp<JObject>|undefined>,
+    repeatOpt:RepeatPromiseOpt={},
+){
+    repeatOpt.tryDelay    = repeatOpt.tryDelay??1000;
+    const procFn = ()=>jsonReq(comReqOpt,reqData);
     return UtilFunc.repeatPromise(procFn,verifyFn,repeatOpt);
 }
 
 /**发送一个 https POST 请求并接受数据  
  * @async
- * @param json 	      - 数据对象
  * @param comReqOpt   - 请求参数
+ * @param reqData     - 数据对象
  * @returns 结果 undefined 为未能成功接收
  */
-export function httpsPost(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>):Promise<HttpResp|undefined>{
-    return comReq(json,{
+export function httpsPost(comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,reqData:JObject|undefined){
+    return jsonReq({
         ...comReqOpt,
         method:"POST",
         protocol:"https",
-    });
+    },reqData);
 }
 
 /**发送一个 http POST 请求并接受数据  
  * @async
- * @param json 	      - 数据对象
  * @param comReqOpt   - 请求参数
+ * @param reqData 	  - 数据对象
  * @returns 结果 undefined 为未能成功接收
  */
-export function httpPost(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>):Promise<HttpResp|undefined>{
-    return comReq(json,{
+export function httpPost(comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,reqData:JObject|undefined){
+    return jsonReq({
         ...comReqOpt,
         method:"POST",
         protocol:"http",
-    });
+    },reqData);
 }
+
 /**发送一个 https GET 请求并接受数据  
  * @async
- * @param json 	      - 数据对象
  * @param comReqOpt   - 请求参数
+ * @param reqData     - 数据对象
  * @returns 结果 undefined 为未能成功接收
  */
-export function httpsGet(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>):Promise<HttpResp|undefined>{
-    return comReq(json,{
+export function httpsGet(comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,reqData:Record<string,string|number|boolean>){
+    return jsonReq({
         ...comReqOpt,
         method:"GET",
         protocol:"https",
-    });
+    },reqData);
 }
 
 /**发送一个 http GET 请求并接受数据  
  * @async
- * @param json 	      - 数据对象
  * @param comReqOpt   - 请求参数
+ * @param reqData 	  - 数据对象
  * @returns 结果 undefined 为未能成功接收
  */
-export function httpGet(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>):Promise<HttpResp|undefined>{
-    return comReq(json,{
+export function httpGet(comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,reqData:Record<string,string|number|boolean>){
+    return jsonReq({
         ...comReqOpt,
         method:"GET",
         protocol:"http",
-    });
+    },reqData);
 }
 
 
 /**重复一个 https POST请求并接受数据  
  * @async
- * @param json 	     - 数据对象
- * @param comReqOpt  - 请求参数
- * @param verifyFn   - 判断有效性函数
- * @param repeatOpt  - 可选参数
- * @param opt.count        - 重试次数 默认3
- * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
- * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+ * @param comReqOpt - 网络请求选项
+ * @param reqData   - 数据对象
+ * @param verifyFn  - 有效性验证函数
+ * @param repeatOpt - 重试选项 延迟默认为 1000 ms
  * @returns 结果 undefined 为未能成功接收
  */
-export function httpsRepeatPost(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,verifyFn?:ReqVerifyFn<JObject|undefined>,repeatOpt?:RepeatPromiseOpt):
-Promise<RepeatPromiseResult<HttpResp|undefined>|undefined>{
-    return repeatComReq(json,{
+export function httpsRepeatPost(
+    comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,
+    reqData?:JObject,
+    verifyFn?:ReqVerifyFn<JObject|undefined>,
+    repeatOpt?:RepeatPromiseOpt
+){
+    return repeatJsonComReq({
         ...comReqOpt,
         method:"POST",
         protocol:"https",
-    },verifyFn,repeatOpt);
+    },reqData,verifyFn,repeatOpt);
 }
 
 /**重复一个 http POST请求并接受数据  
  * @async
- * @param json 	      - 数据对象
- * @param comReqOpt   - 请求参数
- * @param verifyFn    - 判断有效性函数
- * @param repeatOpt   - 可选参数
- * @param opt.count        - 重试次数 默认3
- * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
- * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+ * @param comReqOpt - 网络请求选项
+ * @param reqData   - 数据对象
+ * @param verifyFn  - 有效性验证函数
+ * @param repeatOpt - 重试选项 延迟默认为 1000 ms
  * @returns 结果 undefined 为未能成功接收
  */
-export function httpRepeatPost(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,verifyFn?:ReqVerifyFn<JObject|undefined>,repeatOpt?:RepeatPromiseOpt):
-Promise<RepeatPromiseResult<HttpResp|undefined>|undefined>{
-    return repeatComReq(json,{
+export function httpRepeatPost(
+    comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,
+    reqData?:JObject,
+    verifyFn?:ReqVerifyFn<JObject|undefined>,
+    repeatOpt?:RepeatPromiseOpt
+){
+    return repeatJsonComReq({
         ...comReqOpt,
         method:"POST",
         protocol:"http",
-    },verifyFn,repeatOpt);
+    },reqData,verifyFn,repeatOpt);
 }
 
 /**重复一个 https GET 请求并接受数据  
  * @async
- * @param json 	     - 数据对象
- * @param comReqOpt  - 请求参数
- * @param verifyFn   - 判断有效性函数
- * @param repeatOpt  - 可选参数
- * @param opt.count        - 重试次数 默认3
- * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
- * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+ * @param comReqOpt - 网络请求选项
+ * @param reqData   - 数据对象
+ * @param verifyFn  - 有效性验证函数
+ * @param repeatOpt - 重试选项 延迟默认为 1000 ms
  * @returns 结果 undefined 为未能成功接收
  */
-export function httpsRepeatGet(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,verifyFn?:ReqVerifyFn<JObject|undefined>,repeatOpt?:RepeatPromiseOpt):
-Promise<RepeatPromiseResult<HttpResp|undefined>|undefined>{
-    return repeatComReq(json,{
+export function httpsRepeatGet(
+    comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,
+    reqData?:GetReqData,
+    verifyFn?:ReqVerifyFn<JObject|undefined>,
+    repeatOpt?:RepeatPromiseOpt
+){
+    return repeatJsonComReq({
         ...comReqOpt,
         method:"GET",
         protocol:"https",
-    },verifyFn,repeatOpt);
+    },reqData,verifyFn,repeatOpt);
 }
 
 /**重复一个 http GET 请求并接受数据  
  * @async
- * @param json 	      - 数据对象
- * @param comReqOpt   - 请求参数
- * @param verifyFn    - 判断有效性函数
- * @param repeatOpt   - 可选参数
- * @param opt.count        - 重试次数 默认3
- * @param opt.tryInterval  - 超时时间/秒  默认180 最小为5秒
- * @param opt.tryDelay     - 重试间隔时间/秒 默认 1
+ * @param comReqOpt - 网络请求选项
+ * @param reqData   - 数据对象
+ * @param verifyFn  - 有效性验证函数
+ * @param repeatOpt - 重试选项 延迟默认为 1000 ms
  * @returns 结果 undefined 为未能成功接收
  */
-export function httpRepeatGet(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,verifyFn?:ReqVerifyFn<JObject|undefined>,repeatOpt?:RepeatPromiseOpt):
-Promise<RepeatPromiseResult<HttpResp|undefined>|undefined>{
-    return repeatComReq(json,{
+export function httpRepeatGet(
+    comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,
+    reqData?:GetReqData,
+    verifyFn?:ReqVerifyFn<JObject|undefined>,
+    repeatOpt?:RepeatPromiseOpt
+){
+    return repeatJsonComReq({
         ...comReqOpt,
         method:"GET",
         protocol:"http",
-    },verifyFn,repeatOpt);
+    },reqData,verifyFn,repeatOpt);
 }
 
 }

package/src/UtilFunctions.ts

@@ -35,10 +35,10 @@ export type RepeatPromiseOpt = Partial<{
     /**重试次数 默认3*/
     count?        :number;
     /**尝试间隔时间 超过此事件会重新创建新的Promise
-     * 同时等待新的与旧的Promise 秒 默认180
+     * 同时等待新的与旧的Promise 毫秒 默认180_000
      */
     tryInterval? :number;
-    /**尝试延迟 重新尝试时会先等待此秒数 秒 默认0*/
+    /**尝试延迟 重新尝试时会先等待此毫秒数 毫秒 默认0*/
     tryDelay?    :number;
 }>
 
@@ -224,21 +224,16 @@ static getNeverResolvedPromise<T>():Promise<T>{
  * @param procFn      - 发起函数
  * @param verifyFn    - 验证函数
  * @param opt         - 可选参数
- * @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<RepeatPromiseResult<T>|undefined>{
     opt.count = opt.count??3;
-    opt.tryInterval = opt.tryInterval??180;
-    let {count,tryInterval} = opt;
+    opt.tryInterval = opt.tryInterval??180_000;
+    const {count,tryInterval} = opt;
     /**是否含有超时时间 */
-    const hasRepeatTime = (tryInterval>=5);
-    //转换为毫秒
-    if(hasRepeatTime) tryInterval*=1000;
+    const hasRepeatTime = (tryInterval>=5000);
 
     //验证处理函数
     if(verifyFn===undefined)
@@ -254,7 +249,7 @@ Promise<RepeatPromiseResult<T>|undefined>{
     try{
         //根据最大重试次数限制进行循环
         for(let i=0;i<count;){
-            if(i>0 && opt.tryDelay) await this.sleep(opt.tryDelay*1000);
+            if(i>0 && opt.tryDelay) await this.sleep(opt.tryDelay);
             SLogger.info(`开始第 ${i+1} 次 repeatPromise`);
             //如果 plist 中当前下标的任务还未创建 则 创建当前任务
             if(plist.length<i+1){