@zwa73/utils 1.0.15 → 1.0.17

package/dist/UtilFunctions.d.ts

@@ -6,11 +6,47 @@ import { JObject } from "./UtilInterfaces";
 export declare function getTime(): number;
 /**初始化对象的字段
  * void (Object,string,any)
- * @param {Record<string,any>} obj - 所要初始化的对象
+ * @param {Record<string,T>} obj   - 所要初始化的对象
  * @param {string} field 		   - 所要初始化的字段
- * @param {any} defaultVal 		   - 默认值
+ * @param {T} defaultVal 		   - 默认值
+ * @returns {T} - 最终值
  */
-export declare function initField(obj: Record<string, any>, field: string, defaultVal: any): void;
+export declare function initField<T>(obj: Record<string, T>, field: string, defaultVal: T): T;
+/**验证路径 文件或文件夹 是否存在 异步
+ * @async
+ * @param {string} filePath - 待验证的路径
+ * @returns {Promise<boolean>} - 是否存在
+ */
+export declare function pathExists(filePath: string): Promise<boolean>;
+/**验证路径 文件或文件夹 是否存在 同步
+ * @param {string} filePath - 待验证的路径
+ * @returns {boolean} - 是否存在
+ */
+export declare function pathExistsSync(filePath: string): boolean;
+/**路径不存在时创建路径 以path.sep结尾时创建文件夹 异步
+ * @async
+ * @param {string} filePath - 待创建的路径
+ * @param {boolean} isDir   - 强制创建一个文件夹
+ * @returns {Promise<boolean>} - 是否成功创建
+ */
+export declare function createPath(filePath: string, isDir?: boolean): Promise<boolean>;
+/**路径不存在时创建路径 以path.sep结尾时创建文件夹 同步
+ * @param {string} filePath - 待创建的路径
+ * @param {boolean} isDir   - 强制创建一个文件夹
+ * @returns {boolean} - 是否成功创建
+ */
+export declare function createPathSync(filePath: string, isDir?: boolean): boolean;
+/**确保路径存在 不存在时创建 异步
+ * @async
+ * @param {string} filePath - 待验证的路径
+ * @returns {Promise<boolean>} - 是否成功执行 创建或已存在
+ */
+export declare function ensurePathExists(filePath: string): Promise<boolean>;
+/**确保路径存在 不存在时创建 同步
+ * @param {string} filePath - 待验证的路径
+ * @returns {boolean} - 是否成功执行 创建或已存在
+ */
+export declare function ensurePathExistsSync(filePath: string): boolean;
 /**加载json文件 同步
  * Object (string)
  * @param {string} filePath - 文件路径

package/dist/UtilFunctions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileSearch = exports.sleep = exports.isSafeNumber = exports.deepClone = exports.genUUID = exports.writeJSONFile = exports.loadJSONFile = exports.loadJSONFileSync = exports.initField = exports.getTime = void 0;
+exports.fileSearch = exports.sleep = exports.isSafeNumber = exports.deepClone = exports.genUUID = exports.writeJSONFile = exports.loadJSONFile = exports.loadJSONFileSync = exports.ensurePathExistsSync = exports.ensurePathExists = exports.createPathSync = exports.createPath = exports.pathExistsSync = exports.pathExists = exports.initField = exports.getTime = void 0;
 const fs = require("fs");
 const crypto = require("crypto");
 const path = require("path");
@@ -14,15 +14,117 @@ function getTime() {
 exports.getTime = getTime;
 /**初始化对象的字段
  * void (Object,string,any)
- * @param {Record<string,any>} obj - 所要初始化的对象
+ * @param {Record<string,T>} obj   - 所要初始化的对象
  * @param {string} field 		   - 所要初始化的字段
- * @param {any} defaultVal 		   - 默认值
+ * @param {T} defaultVal 		   - 默认值
+ * @returns {T} - 最终值
  */
 function initField(obj, field, defaultVal) {
     if (!(field in obj))
         obj[field] = defaultVal;
+    return obj[field];
 }
 exports.initField = initField;
+/**验证路径 文件或文件夹 是否存在 异步
+ * @async
+ * @param {string} filePath - 待验证的路径
+ * @returns {Promise<boolean>} - 是否存在
+ */
+async function pathExists(filePath) {
+    try {
+        const stats = await fs.promises.stat(filePath);
+        await fs.promises.access(filePath);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.pathExists = pathExists;
+/**验证路径 文件或文件夹 是否存在 同步
+ * @param {string} filePath - 待验证的路径
+ * @returns {boolean} - 是否存在
+ */
+function pathExistsSync(filePath) {
+    try {
+        fs.accessSync(filePath);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.pathExistsSync = pathExistsSync;
+/**路径不存在时创建路径 以path.sep结尾时创建文件夹 异步
+ * @async
+ * @param {string} filePath - 待创建的路径
+ * @param {boolean} isDir   - 强制创建一个文件夹
+ * @returns {Promise<boolean>} - 是否成功创建
+ */
+async function createPath(filePath, isDir) {
+    if (isDir == true)
+        filePath = path.join(filePath, path.sep);
+    try {
+        if (filePath.endsWith(path.sep)) {
+            await fs.promises.mkdir(filePath, { recursive: true });
+            return true;
+        }
+        await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.promises.open(filePath, 'w');
+        return true;
+    }
+    catch (e) {
+        console.log("createPath 错误");
+        console.log(e);
+        return false;
+    }
+}
+exports.createPath = createPath;
+/**路径不存在时创建路径 以path.sep结尾时创建文件夹 同步
+ * @param {string} filePath - 待创建的路径
+ * @param {boolean} isDir   - 强制创建一个文件夹
+ * @returns {boolean} - 是否成功创建
+ */
+function createPathSync(filePath, isDir) {
+    if (isDir == true)
+        filePath = path.join(filePath, path.sep);
+    try {
+        if (filePath.endsWith(path.sep)) {
+            fs.mkdirSync(filePath, { recursive: true });
+            return true;
+        }
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.openSync(filePath, 'w');
+        return true;
+    }
+    catch (e) {
+        console.log("createPath 错误");
+        console.log(e);
+        return false;
+    }
+}
+exports.createPathSync = createPathSync;
+/**确保路径存在 不存在时创建 异步
+ * @async
+ * @param {string} filePath - 待验证的路径
+ * @returns {Promise<boolean>} - 是否成功执行 创建或已存在
+ */
+async function ensurePathExists(filePath) {
+    if (await pathExists(filePath))
+        return true;
+    return await createPath(filePath);
+}
+exports.ensurePathExists = ensurePathExists;
+/**确保路径存在 不存在时创建 同步
+ * @param {string} filePath - 待验证的路径
+ * @returns {boolean} - 是否成功执行 创建或已存在
+ */
+function ensurePathExistsSync(filePath) {
+    if (pathExistsSync(filePath))
+        return true;
+    return createPathSync(filePath);
+}
+exports.ensurePathExistsSync = ensurePathExistsSync;
 /**加载json文件 同步
  * Object (string)
  * @param {string} filePath - 文件路径
@@ -33,12 +135,8 @@ function loadJSONFileSync(filePath) {
         filePath += '.json';
     let str = "";
     // 判断文件路径是否存在
-    try {
-        fs.accessSync(filePath);
-        // 读取文件
+    if (pathExistsSync(filePath))
         str = fs.readFileSync(filePath, "utf-8");
-    }
-    catch (err) { }
     if (str == "" || str == null)
         str = "{}";
     return JSON.parse(str);
@@ -55,12 +153,8 @@ async function loadJSONFile(filePath) {
         filePath += '.json';
     let str = "";
     // 判断文件路径是否存在
-    try {
-        await fs.promises.access(filePath);
-        // 读取文件
+    if (await pathExists(filePath))
         str = await fs.promises.readFile(filePath, "utf-8");
-    }
-    catch (err) { }
     if (str == "" || str == null)
         str = "{}";
     return JSON.parse(str);
@@ -77,21 +171,9 @@ async function writeJSONFile(filePath, obj) {
     let str = JSON.stringify(obj, null, "\t");
     if (path.extname(filePath) !== '.json')
         filePath += '.json';
-    // 判断文件路径是否存在
-    try {
-        await fs.promises.access(filePath);
-    }
-    catch (err) {
-        // 不存在则创建
-        try {
-            await fs.promises.mkdir(path.dirname(filePath), {
-                recursive: true,
-            });
-        }
-        catch (e) {
-            console.log("创建文件错误:" + e);
-        }
-    }
+    // 判断文件路径是否存在 不存在则创建
+    if (!(await pathExists(filePath)))
+        await createPath(filePath);
     // 写入文件
     try {
         await fs.promises.writeFile(filePath, str);
@@ -127,7 +209,9 @@ exports.deepClone = deepClone;
 function isSafeNumber(num) {
     if (num === undefined || num == null || isNaN(num))
         return false;
-    return true;
+    if (typeof num === 'number')
+        return true;
+    return false;
 }
 exports.isSafeNumber = isSafeNumber;
 /**等待 timeMs 毫秒
@@ -157,7 +241,7 @@ function fileSearch(folder, traitRegex) {
         let stat = fs.lstatSync(subFilePath);
         //判断是否是文件夹，递归调用
         if (stat.isDirectory()) {
-            let subMap = fileSearch(path.join(subFilePath, "/"), traitRegex);
+            let subMap = fileSearch(path.join(subFilePath, path.sep), traitRegex);
             for (let key in subMap)
                 outMap[key] = subMap[key];
             continue;

package/package.json

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

package/src/UtilFunctions.ts

@@ -13,16 +13,118 @@ export function getTime(): number {
 
 /**初始化对象的字段
  * void (Object,string,any)
- * @param {Record<string,any>} obj - 所要初始化的对象
+ * @param {Record<string,T>} obj   - 所要初始化的对象
  * @param {string} field 		   - 所要初始化的字段
- * @param {any} defaultVal 		   - 默认值
+ * @param {T} defaultVal 		   - 默认值
+ * @returns {T} - 最终值
  */
-export function initField(
-    obj: Record<string, any>,
+export function initField<T>(
+    obj: Record<string, T>,
     field: string,
-    defaultVal: any
-): void {
+    defaultVal: T
+): T {
     if (!(field in obj)) obj[field] = defaultVal;
+    return obj[field];
+}
+
+/**验证路径 文件或文件夹 是否存在 异步
+ * @async
+ * @param {string} filePath - 待验证的路径
+ * @returns {Promise<boolean>} - 是否存在
+ */
+export async function pathExists(filePath: string):Promise<boolean>{
+    try {
+        const stats = await fs.promises.stat(filePath);
+        await fs.promises.access(filePath);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+/**验证路径 文件或文件夹 是否存在 同步
+ * @param {string} filePath - 待验证的路径
+ * @returns {boolean} - 是否存在
+ */
+export function pathExistsSync(filePath: string):boolean{
+    try {
+        fs.accessSync(filePath);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+/**路径不存在时创建路径 以path.sep结尾时创建文件夹 异步
+ * @async
+ * @param {string} filePath - 待创建的路径
+ * @param {boolean} isDir   - 强制创建一个文件夹
+ * @returns {Promise<boolean>} - 是否成功创建
+ */
+export async function createPath(filePath: string, isDir?:boolean):Promise<boolean>{
+    if(isDir==true)
+        filePath = path.join(filePath,path.sep);
+
+    try{
+        if(filePath.endsWith(path.sep)){
+            await fs.promises.mkdir(filePath, {recursive: true});
+            return true;
+        }
+        await fs.promises.mkdir(path.dirname(filePath), {recursive: true});
+        await fs.promises.open(filePath, 'w');
+        return true;
+    }
+    catch(e){
+        console.log("createPath 错误");
+        console.log(e);
+        return false;
+    }
+}
+
+/**路径不存在时创建路径 以path.sep结尾时创建文件夹 同步
+ * @param {string} filePath - 待创建的路径
+ * @param {boolean} isDir   - 强制创建一个文件夹
+ * @returns {boolean} - 是否成功创建
+ */
+export function createPathSync(filePath: string, isDir?:boolean):boolean{
+    if(isDir==true)
+        filePath = path.join(filePath,path.sep);
+
+    try{
+        if(filePath.endsWith(path.sep)){
+            fs.mkdirSync(filePath, {recursive: true});
+            return true;
+        }
+        fs.mkdirSync(path.dirname(filePath), {recursive: true});
+        fs.openSync(filePath, 'w');
+        return true;
+    }
+    catch(e){
+        console.log("createPath 错误");
+        console.log(e);
+        return false;
+    }
+}
+
+/**确保路径存在 不存在时创建 异步
+ * @async
+ * @param {string} filePath - 待验证的路径
+ * @returns {Promise<boolean>} - 是否成功执行 创建或已存在
+ */
+export async function ensurePathExists(filePath: string):Promise<boolean>{
+    if(await pathExists(filePath))
+        return true;
+    return await createPath(filePath);
+}
+
+/**确保路径存在 不存在时创建 同步
+ * @param {string} filePath - 待验证的路径
+ * @returns {boolean} - 是否成功执行 创建或已存在
+ */
+export function ensurePathExistsSync(filePath: string):boolean{
+    if(pathExistsSync(filePath))
+        return true;
+    return createPathSync(filePath);
 }
 
 /**加载json文件 同步
@@ -36,11 +138,8 @@ export function loadJSONFileSync(filePath: string): JObject {
     let str = "";
 
     // 判断文件路径是否存在
-    try {
-        fs.accessSync(filePath);
-        // 读取文件
+    if(pathExistsSync(filePath))
         str = fs.readFileSync(filePath, "utf-8");
-    }catch(err) {}
 
     if (str == "" || str == null) str = "{}";
     return JSON.parse(str);
@@ -57,11 +156,8 @@ export async function loadJSONFile(filePath: string): Promise<JObject> {
     let str = "";
 
     // 判断文件路径是否存在
-    try {
-        await fs.promises.access(filePath);
-        // 读取文件
+    if(await pathExists(filePath))
         str = await fs.promises.readFile(filePath, "utf-8");
-    } catch (err) {}
 
     if (str == "" || str == null) str = "{}";
     return JSON.parse(str);
@@ -81,19 +177,10 @@ export async function writeJSONFile(
     let str = JSON.stringify(obj, null, "\t");
     if (path.extname(filePath) !== '.json') filePath += '.json';
 
-    // 判断文件路径是否存在
-    try {
-        await fs.promises.access(filePath);
-    } catch (err) {
-        // 不存在则创建
-        try {
-            await fs.promises.mkdir(path.dirname(filePath), {
-                recursive: true,
-            });
-        } catch (e) {
-            console.log("创建文件错误:" + e);
-        }
-    }
+    // 判断文件路径是否存在 不存在则创建
+    if(!(await pathExists(filePath)))
+        await createPath(filePath);
+
 	// 写入文件
     try {
         await fs.promises.writeFile(filePath, str);
@@ -126,7 +213,8 @@ export function deepClone<T>(obj: T): T {
  */
 export function isSafeNumber(num: number): boolean {
     if (num === undefined || num == null || isNaN(num)) return false;
-    return true;
+    if(typeof num === 'number') return true;
+    return false;
 }
 
 /**等待 timeMs 毫秒
@@ -157,7 +245,7 @@ export function fileSearch(folder: string, traitRegex: string) {
 
         //判断是否是文件夹，递归调用
         if (stat.isDirectory()) {
-            let subMap = fileSearch(path.join(subFilePath, "/"), traitRegex);
+            let subMap = fileSearch(path.join(subFilePath, path.sep), traitRegex);
             for (let key in subMap) outMap[key] = subMap[key];
             continue;
         }