@ivujs/i-utils 2.0.0 → 2.1.1

package/dist/cjs/validate/index.cjs

@@ -1,9 +1,12 @@
 'use strict';
 
+/**
+ * @module 校验
+ */
 /**
  * 判断是整数
  * @param {*} value 参数
- * @returns {Boolean} result 返回结果
+ * @returns {boolean} result 返回结果
  */
 function isInteger(value) {
     return Number.isInteger(value);
@@ -11,15 +14,15 @@ function isInteger(value) {
 /**
  * 判断是小数
  * @param {*} value 参数
- * @returns {Boolean} result 返回结果
+ * @returns {boolean} result 返回结果
  */
 function isDecimal(value) {
     return /^\d+\.\d+$/.test(value);
 }
 /**
  * 判断类型是数字 Number
- * @param {Number} value 参数
- * @returns {Boolean} 返回结果
+ * @param {*} value 参数
+ * @returns {boolean} 返回结果
  */
 function isNumber(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "Number";
@@ -27,7 +30,7 @@ function isNumber(value) {
 /**
  * 判断类型是字符串 String
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isString(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "String";
@@ -35,7 +38,7 @@ function isString(value) {
 /**
  * 判断类型是数组 Array
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isArray(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "Array";
@@ -43,23 +46,23 @@ function isArray(value) {
 /**
  * 判断类型是对象 Object
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isObject(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "Object";
 }
 /**
- * 判断类型是布尔 Boolean
+ * 判断类型是布尔 boolean
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isBoolean(value) {
-    return Object.prototype.toString.call(value).slice(8, -1) === "Boolean";
+    return Object.prototype.toString.call(value).slice(8, -1) === "boolean";
 }
 /**
  * 判断类型是日期 Date
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isDate(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "Date";
@@ -67,7 +70,7 @@ function isDate(value) {
 /**
  * 判断类型是函数 Function
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isFunction(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "Function";
@@ -76,12 +79,12 @@ function isFunction(value) {
  * 判断类型是函数字符串 FunctionString
  * @description 支持普通函数，异步函数，箭头函数
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isFunctionString(value) {
     if (value) {
         try {
-            let fn = new Function(`return ${value}`)();
+            const fn = new Function(`return ${value}`)();
             return typeof fn === "function";
         }
         catch (e) {
@@ -96,7 +99,7 @@ function isFunctionString(value) {
 /**
  * 判断类型是异步函数 AsyncFunction
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isAsyncFunction(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "AsyncFunction";
@@ -104,7 +107,7 @@ function isAsyncFunction(value) {
 /**
  * 判断类型是 Symbol
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isSymbol(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "Symbol";
@@ -112,7 +115,7 @@ function isSymbol(value) {
 /**
  * 判断类型是正则 RegExp
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isRegExp(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "RegExp";
@@ -120,7 +123,7 @@ function isRegExp(value) {
 /**
  * 判断类型是错误 Error
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isError(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "Error";
@@ -128,7 +131,7 @@ function isError(value) {
 /**
  * 判断类型是 Promise
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isPromise(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "Promise";
@@ -136,7 +139,7 @@ function isPromise(value) {
 /**
  *判断类型是 Map
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isMap(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "Map";
@@ -144,7 +147,7 @@ function isMap(value) {
 /**
  * 判断类型是 WeakMap
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isWeakMap(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "WeakMap";
@@ -152,7 +155,7 @@ function isWeakMap(value) {
 /**
  * 判断类型是 Set
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isSet(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "Set";
@@ -160,7 +163,7 @@ function isSet(value) {
 /**
  * 判断类型是 WeakSet
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isWeakSet(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "WeakSet";
@@ -168,7 +171,7 @@ function isWeakSet(value) {
 /**
  * 判断类型是 BigInt
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isBigInt(value) {
     return Object.prototype.toString.call(value).slice(8, -1) === "BigInt";
@@ -176,7 +179,7 @@ function isBigInt(value) {
 /**
  * 判断类型是 Json
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isJson(value) {
     try {
@@ -191,7 +194,7 @@ function isJson(value) {
 /**
  * 判断值为真
  * @param {*} value 校验的参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isTrue(value) {
     return !isFalse(value);
@@ -199,7 +202,7 @@ function isTrue(value) {
 /**
  * 判断值为假
  * @param {*} value 校验的参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isFalse(value) {
     return (value === undefined ||
@@ -213,7 +216,7 @@ function isFalse(value) {
 /**
  * 判断非数字
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isNaN(value) {
     // window的isNaN函数是有缺陷的，空数组/数组有一个元素，null，空字符串 都会被认为是数字
@@ -223,7 +226,7 @@ function isNaN(value) {
  * 判断是数字
  * @description 等同于isNumber()
  * @param {*} value 参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isNotNaN(value) {
     return !isNaN(value);
@@ -232,7 +235,7 @@ function isNotNaN(value) {
  * 判断对象为空
  * @description 判断值是否为空，如果对象初始化了值则不为空
  * @param {*} value 校验的参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isNull(value) {
     return value === undefined || value === null || value === "";
@@ -241,7 +244,7 @@ function isNull(value) {
  * 判断对象不为空
  * @description 判断值是否为空，如果对象初始化了值则不为空
  * @param {*} value 校验的参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isNotNull(value) {
     return !isNull(value);
@@ -250,7 +253,7 @@ function isNotNull(value) {
  * 判断值为空
  * @description 判断是否是有意义不为空的值，如果值是{},[]空的数据则为空
  * @param {*} value 校验的参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isEmpty(value) {
     if (isNull(value))
@@ -273,7 +276,7 @@ function isEmpty(value) {
  * 判断值不为空
  * @description 判断是否是有意义不为空的值，如果值是{},[]空的数据则为空
  * @param {*} value 校验的参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isNotEmpty(value) {
     return !isEmpty(value);
@@ -282,7 +285,7 @@ function isNotEmpty(value) {
  * 判断值是空白的
  * @description 同时会校验空值，空对象，以及空白符号
  * @param {*} value 校验的参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isBlank(value) {
     return isEmpty(value) || /^\s*$/.test(value);
@@ -291,7 +294,7 @@ function isBlank(value) {
  * 判断值不是空白的
  * @description 同时会校验空值，空对象，以及空白符号
  * @param {*} value 校验的参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isNotBlank(value) {
     return !isBlank(value);
@@ -299,7 +302,7 @@ function isNotBlank(value) {
 /**
  * 判断值是undefined
  * @param {*} value 校验的参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isUndefined(value) {
     return value === undefined;
@@ -307,7 +310,7 @@ function isUndefined(value) {
 /**
  * 判断值不是undefined
  * @param {*} value 校验的参数
- * @returns {Boolean} 返回结果
+ * @returns {boolean} 返回结果
  */
 function isNotUndefined(value) {
     return !isUndefined(value);
@@ -315,115 +318,128 @@ function isNotUndefined(value) {
 /* 数据比较 */
 /**
  * 判断两个值是否相等
- * @param {String|Number} value1 参数1
- * @param {String|Number} value2 参数2
- * @returns {Boolean} 返回结果
+ * @param {*} value1 参数1
+ * @param {*} value2 参数2
+ * @returns {boolean} 返回结果
  */
 function equals(value1, value2) {
     return Object.is(value1, value2);
 }
 /**
  * 判断两个值是否相等（忽略大小写）
- * @param {String|Number} value1 参数1
- * @param {String|Number} value2 参数2
- * @returns {Boolean} 返回结果
+ * @param {*} value1 参数1
+ * @param {*} value2 参数2
+ * @returns {boolean} 返回结果
  */
 function equalsIgnoreCase(value1, value2) {
     return Object.is(value1.toLowerCase(), value2.toLowerCase());
 }
 /**
  * 深度对比数据
- * @description 可以对比任意数据，对象，数组，日期等也可深度对比，对象不区分先后顺序
+ * @description 可以对比任意数据，对象、数组、日期等也可深度对比，对象不区分先后顺序
  * @param {*} x 数据1
- * @param {*} y 数据2
- * @returns {Boolean} 返回结果
- */
-function deepCompare(x, y) {
-    let i, l, leftChain, rightChain;
-    function compare2Objects(x, y) {
-        let p;
-        // remember that NaN === NaN returns false
-        // and isNaN(undefined) returns true
-        if (isNaN(x) && isNaN(y) && typeof x === "number" && typeof y === "number") {
+ * @param {*} args 数据2
+ * @returns {boolean} 返回对比结果
+ */
+function deepCompare(x, ...args) {
+    let leftChain = [];
+    let rightChain = [];
+    // 核心对比函数（添加严格类型标注）
+    const compare2Objects = (xObj, yObj) => {
+        // 1. 处理 NaN 特殊场景（NaN === NaN 返回 false，需单独判断）
+        if (Number.isNaN(xObj) && Number.isNaN(yObj)) {
             return true;
         }
-        // Compare primitives and functions.
-        // Check if both arguments link to the same object.
-        // Especially useful on the step where we compare prototypes
-        if (x === y) {
+        // 2. 原始类型/引用同一对象 直接对比
+        if (xObj === yObj) {
             return true;
         }
-        // Works in case when functions are created in constructor.
-        // Comparing dates is a common scenario. Another built-ins?
-        // We can even handle functions passed across iframes
-        if ((typeof x === "function" && typeof y === "function") ||
-            (x instanceof Date && y instanceof Date) ||
-            (x instanceof RegExp && y instanceof RegExp) ||
-            (x instanceof String && y instanceof String) ||
-            (x instanceof Number && y instanceof Number)) {
-            return x.toString() === y.toString();
+        // 3. 特殊内置对象对比（函数/日期/正则/包装对象）
+        const typeOfX = typeof xObj;
+        const typeOfY = typeof yObj;
+        // 函数对比：通过 toString 比较内容
+        if (typeOfX === "function" && typeOfY === "function") {
+            return xObj.toString() === yObj.toString();
+        }
+        // 日期对象对比：时间戳一致则相等
+        if (xObj instanceof Date && yObj instanceof Date) {
+            return xObj.getTime() === yObj.getTime();
         }
-        // At last checking prototypes as good as we can
-        if (!(x instanceof Object && y instanceof Object)) {
+        // 正则对象对比：源文本+标志位一致则相等
+        if (xObj instanceof RegExp && yObj instanceof RegExp) {
+            return xObj.source === yObj.source && xObj.flags === yObj.flags;
+        }
+        // 字符串/数字包装对象对比
+        if ((xObj instanceof String && yObj instanceof String) || (xObj instanceof Number && yObj instanceof Number)) {
+            return xObj.toString() === yObj.toString();
+        }
+        // 4. 非对象类型（排除上述特殊类型后）直接返回 false
+        if (!(xObj instanceof Object && yObj instanceof Object)) {
             return false;
         }
-        if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
+        // 5. 原型链/构造函数校验
+        if (xObj.isPrototypeOf(yObj) || yObj.isPrototypeOf(xObj)) {
             return false;
         }
-        if (x.constructor !== y.constructor) {
+        if (xObj.constructor !== yObj.constructor) {
             return false;
         }
-        if (x.prototype !== y.prototype) {
+        if (xObj.prototype !== yObj.prototype) {
             return false;
         }
-        // Check for infinitive linking loops
-        if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
+        // 6. 循环引用检测（避免无限递归）
+        if (leftChain.includes(xObj) || rightChain.includes(yObj)) {
             return false;
         }
-        // Quick checking of one object being a subset of another.
-        for (p in y) {
-            if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
+        // 7. 遍历对象属性，对比键存在性和类型
+        const xObjKeys = Object.keys(xObj);
+        const yObjKeys = Object.keys(yObj);
+        // 先对比属性数量（数量不同直接不相等）
+        if (xObjKeys.length !== yObjKeys.length) {
+            return false;
+        }
+        // 遍历所有属性，校验存在性、类型、值
+        for (const p of yObjKeys) {
+            if (Object.prototype.hasOwnProperty.call(xObj, p) !== Object.prototype.hasOwnProperty.call(yObj, p)) {
                 return false;
             }
-            else if (typeof y[p] !== typeof x[p]) {
+            const xProp = xObj[p];
+            const yProp = yObj[p];
+            if (typeof xProp !== typeof yProp) {
                 return false;
             }
         }
-        for (p in x) {
-            if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
-                return false;
-            }
-            else if (typeof y[p] !== typeof x[p]) {
-                return false;
+        // 深度对比属性值
+        for (const p of xObjKeys) {
+            const xProp = xObj[p];
+            const yProp = yObj[p];
+            if (typeof xProp === "object" || typeof xProp === "function") {
+                leftChain.push(xObj);
+                rightChain.push(yObj);
+                if (!compare2Objects(xProp, yProp)) {
+                    return false;
+                }
+                leftChain.pop();
+                rightChain.pop();
             }
-            switch (typeof x[p]) {
-                case "object":
-                case "function":
-                    leftChain.push(x);
-                    rightChain.push(y);
-                    if (!compare2Objects(x[p], y[p])) {
-                        return false;
-                    }
-                    leftChain.pop();
-                    rightChain.pop();
-                    break;
-                default:
-                    if (x[p] !== y[p]) {
-                        return false;
-                    }
-                    break;
+            else {
+                if (xProp !== yProp) {
+                    return false;
+                }
             }
         }
         return true;
+    };
+    // 边界处理：参数数量不足时的兜底
+    if (arguments.length < 2) {
+        console.warn("deepCompare 需要至少两个对比参数");
+        return true;
     }
-    if (arguments.length < 1) {
-        return true; // Die silently? Don't know how to handle such case, please help...
-        // throw "Need two or more arguments to compare";
-    }
-    for (i = 1, l = arguments.length; i < l; i++) {
+    // 遍历所有传入的参数（支持对比多个值）
+    for (const y of args) {
         leftChain = [];
         rightChain = [];
-        if (!compare2Objects(arguments[0], arguments[i])) {
+        if (!compare2Objects(x, y)) {
             return false;
         }
     }

package/dist/es/ID-card/index.d.ts

@@ -1,31 +1,36 @@
 /**
  * 根据身份证号码获取信息
  * @description 能获取到 籍贯，出生日期，年龄，性别
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
+ * @param {string} idCard 身份证号码，支持一代15位和二代18位
  * @returns {Object} 返回身份证信息对象
  */
-export function getInfoByIDCard(idCard: string): Object;
+export declare function getInfoByIDCard(idCard: string): {
+    province: string | undefined;
+    birthday: string | undefined;
+    age: number | undefined;
+    sex: string | undefined;
+} | undefined;
 /**
  * 根据身份证号码获得生日
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {String} 返回生日
+ * @param {string} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {string} 返回生日
  */
-export function getBirthdayByIDCard(idCard: string): string;
+export declare function getBirthdayByIDCard(idCard: string): string | undefined;
 /**
  * 根据身份证号码获得年龄
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {Number} 返回年龄
+ * @param {string} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {number} 返回年龄
  */
-export function getAgeByIDCard(idCard: string): number;
+export declare function getAgeByIDCard(idCard: string): number | undefined;
 /**
  * 根据身份证号码获得性别
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {String} 返回性别
+ * @param {string} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {string} 返回性别
  */
-export function getSexByIDCard(idCard: string): string;
+export declare function getSexByIDCard(idCard: string): string | undefined;
 /**
  * 根据身份证号码获得省份
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {String} 返回省份
+ * @param {string} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {string} 返回省份
  */
-export function getProvinceByIDCard(idCard: string): string;
+export declare function getProvinceByIDCard(idCard: string): string | undefined;

package/dist/es/ID-card/index.mjs

@@ -1,11 +1,14 @@
 import { isNull } from '../validate/index.mjs';
-import { getAge, parseDate } from '../date/index.mjs';
+import { getAge, toDate } from '../date/index.mjs';
 import { ID_CARD } from '../constants/id-card.mjs';
 
+/**
+ * @module 身份证号码
+ */
 /**
  * 根据身份证号码获取信息
  * @description 能获取到 籍贯，出生日期，年龄，性别
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
+ * @param {string} idCard 身份证号码，支持一代15位和二代18位
  * @returns {Object} 返回身份证信息对象
  */
 function getInfoByIDCard(idCard) {
@@ -24,8 +27,8 @@ function getInfoByIDCard(idCard) {
 }
 /**
  * 根据身份证号码获得生日
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {String} 返回生日
+ * @param {string} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {string} 返回生日
  */
 function getBirthdayByIDCard(idCard) {
     if (isNull(idCard))
@@ -41,23 +44,25 @@ function getBirthdayByIDCard(idCard) {
 }
 /**
  * 根据身份证号码获得年龄
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {Number} 返回年龄
+ * @param {string} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {number} 返回年龄
  */
 function getAgeByIDCard(idCard) {
     if (isNull(idCard))
         return;
-    let birthday = getBirthdayByIDCard(idCard);
-    return getAge(parseDate(birthday));
+    const birthday = getBirthdayByIDCard(idCard);
+    if (birthday) {
+        return getAge(toDate(String(birthday)));
+    }
 }
 /**
  * 根据身份证号码获得性别
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {String} 返回性别
+ * @param {string} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {string} 返回性别
  */
 function getSexByIDCard(idCard) {
     if (isNull(idCard))
-        return;
+        return undefined;
     // 15位身份证
     if (idCard.length === 15) {
         return Number(idCard.substring(14)) % 2 === 0 ? ID_CARD.SEX.WOMAN : ID_CARD.SEX.MAN;
@@ -69,13 +74,16 @@ function getSexByIDCard(idCard) {
 }
 /**
  * 根据身份证号码获得省份
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {String} 返回省份
+ * @param {string} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {string} 返回省份
  */
 function getProvinceByIDCard(idCard) {
     if (isNull(idCard))
         return;
-    return ID_CARD.PROVINCE[idCard.substring(0, 2)];
+    const prefix = idCard.substring(0, 2);
+    if (prefix) {
+        return ID_CARD.PROVINCE[prefix];
+    }
 }
 
 export { getAgeByIDCard, getBirthdayByIDCard, getInfoByIDCard, getProvinceByIDCard, getSexByIDCard };