@ivujs/i-utils 1.1.18 → 2.1.0

package/dist/es/math/index.mjs

@@ -0,0 +1,300 @@
+import { isNaN } from '../validate/index.mjs';
+import { MATH } from '../constants/math.mjs';
+
+/**
+ * @module 数学
+ */
+/* 数字计算 */
+/**
+ * 两个数字相加
+ * @param {string|number} arg1 第一个数字
+ * @param {string|number} arg2 第二个数字
+ * @returns {number} 返回计算后的数字
+ */
+function add(arg1, arg2) {
+    let r1, r2;
+    try {
+        r1 = arg1.toString().split(".")[1].length;
+    }
+    catch (e) {
+        r1 = 0;
+    }
+    try {
+        r2 = arg2.toString().split(".")[1].length;
+    }
+    catch (e) {
+        r2 = 0;
+    }
+    const m = Math.pow(10, Math.max(r1, r2));
+    return (Number(arg1) * m + Number(arg2) * m) / m;
+}
+/**
+ * 两个数字相减
+ * @param {string|number} arg1 第一个数字
+ * @param {string|number} arg2 第二个数字
+ * @returns {number} 返回计算后的数字
+ */
+function subtract(arg1, arg2) {
+    let r1, r2, m, n;
+    try {
+        r1 = arg1.toString().split(".")[1].length;
+    }
+    catch (e) {
+        r1 = 0;
+    }
+    try {
+        r2 = arg2.toString().split(".")[1].length;
+    }
+    catch (e) {
+        r2 = 0;
+    }
+    m = Math.pow(10, Math.max(r1, r2));
+    n = r1 >= r2 ? r1 : r2;
+    return ((Number(arg1) * m - Number(arg2) * m) / m).toFixed(n);
+}
+/**
+ * 两个数字相乘
+ * @param {string|number} arg1 第一个数字
+ * @param {string|number} arg2 第二个数字
+ * @returns 返回计算后的数字
+ */
+function multiply(arg1, arg2) {
+    let m = 0;
+    const s1 = arg1.toString();
+    const s2 = arg2.toString();
+    try {
+        m += s1.split(".")[1].length;
+    }
+    catch (e) { }
+    try {
+        m += s2.split(".")[1].length;
+    }
+    catch (e) { }
+    return (Number(s1.replace(".", "")) * Number(s2.replace(".", ""))) / Math.pow(10, m);
+}
+/**
+ * 两个数字相除
+ * @param {string|number} arg1 第一个数字
+ * @param {string|number} arg2 第二个数字
+ * @returns {number} 返回计算后的数字
+ */
+function divide(arg1, arg2) {
+    let t1 = 0, t2 = 0;
+    try {
+        t1 = arg1.toString().split(".")[1].length;
+    }
+    catch (e) { }
+    try {
+        t2 = arg2.toString().split(".")[1].length;
+    }
+    catch (e) { }
+    const r1 = Number(arg1.toString().replace(".", ""));
+    const r2 = Number(arg2.toString().replace(".", ""));
+    return (r1 / r2) * Math.pow(10, t2 - t1);
+}
+/**
+ * 两个数字取模
+ * @param {string|number} arg1 第一个数字
+ * @param {string|number} arg2 第二个数字
+ * @returns {number} 返回计算后的数字
+ */
+function modulo(arg1, arg2) {
+    let t1 = 0, t2 = 0, d = 0;
+    try {
+        t1 = arg1.toString().split(".")[1].length;
+    }
+    catch (e) { }
+    try {
+        t2 = arg2.toString().split(".")[1].length;
+    }
+    catch (e) { }
+    d = Math.pow(10, Math.max(t1, t2));
+    return (Math.round(Number(arg1) * d) % Math.round(Number(arg2) * d)) / d;
+}
+/**
+ * 最大公约数
+ * @param {string|number} arg1 第一个数字
+ * @param {string|number} arg2 第二个数字
+ * @returns {number} 返回计算后的数字
+ */
+function gcd(arg1, arg2) {
+    let a = Math.abs(Number(arg1));
+    let b = Math.abs(Number(arg2));
+    while (b !== 0) {
+        const temp = b;
+        b = a % b;
+        a = temp;
+    }
+    return a;
+}
+/**
+ * 最小公倍数
+ * @param {string|number} arg1 第一个数字
+ * @param {string|number} arg2 第二个数字
+ * @returns {number} 返回计算后的数字
+ */
+function scm(arg1, arg2) {
+    const a = Number(arg1);
+    const b = Number(arg2);
+    const absA = Math.abs(a);
+    const absB = Math.abs(b);
+    if (absA === 0 || absB === 0) {
+        return 0;
+    }
+    return (absA * absB) / gcd(absA, absB);
+}
+/* 数字精度 */
+/**
+ * 强制保留小数位数
+ * @description 默认保留两位小数，解决原生的toFixed()会五舍六入的问题
+ * @param {string|number} num 数字
+ * @param {number} decimals 保留小数的位数，默认2位
+ * @param {number} mode 保留小数模式
+ * @returns {string} 返回保留后的数字字符串
+ */
+function toFixed(num, decimals = 2, mode = MATH.ROUND) {
+    // 四舍五入
+    if (mode === MATH.ROUND) {
+        return _toFixedRound(num, decimals);
+    }
+    // 向下舍出
+    if (mode === MATH.ROUND_FLOOR) {
+        return _toFixedFloor(num, decimals);
+    }
+}
+/**
+ * 尽可能保留小数位数
+ * @param {string|number} num 数字
+ * @param {number} decimals 保留小数的位数，默认2位
+ * @param {number} mode 保留小数模式
+ * @returns {number} 返回保留后的数字
+ */
+function toDecimal(num, decimals = 2, mode = MATH.ROUND) {
+    // 四舍五入
+    if (mode === MATH.ROUND) {
+        return _toDecimalRound(num, decimals);
+    }
+    // 向下舍出
+    if (mode === MATH.ROUND_FLOOR) {
+        return _toDecimalFloor(num, decimals);
+    }
+}
+/* 内部函数 */
+/**
+ * 四舍五入，强制保留小数位数
+ * @description 默认保留两位小数，此方法解决原生的toFixed()会五舍六入的问题
+ * @param {string|number} num 数字
+ * @param {number} decimals 保留小数的位数，默认2位
+ * @returns {string} 返回字符串的数字
+ */
+function _toFixedRound(num, decimals = 2) {
+    if (isNaN(Number(num))) {
+        // num可能是字符串，先转数字再判断NaN
+        return "--";
+    }
+    let s = String(num);
+    if (!decimals)
+        decimals = 0;
+    if (s.indexOf(".") === -1)
+        s += ".";
+    s += new Array(decimals + 1).join("0");
+    // 正则模板字符串拼接，避免手动拼接字符串的转义问题
+    const reg = new RegExp(`^(-|\\+)?(\\d+(\\.\\d{0,${decimals + 1}})?)\\d*$`);
+    if (reg.test(s)) {
+        let s1 = "0" + RegExp.$2, b = true;
+        // 1. 把外层的数字变量 a 改名，避免和内层数组冲突
+        const decimalLength = RegExp.$3.length;
+        const pm = RegExp.$1;
+        if (decimalLength === decimals + 2) {
+            // 2. 内层数组用新变量名 digitArr，明确类型为 string[]
+            const digitArr = s1.match(/\d/g);
+            if (parseInt(digitArr[digitArr.length - 1]) > 4) {
+                for (let i = digitArr.length - 2; i >= 0; i--) {
+                    // 3. 确保赋值为字符串类型
+                    digitArr[i] = (parseInt(digitArr[i]) + 1).toString();
+                    if (digitArr[i] === "10") {
+                        digitArr[i] = "0";
+                        b = i !== 1;
+                    }
+                    else
+                        break;
+                }
+            }
+            s1 = digitArr.join("").replace(new RegExp(`(\\d+)(\\d{${decimals}})\\d$`), "$1.$2");
+        }
+        if (b)
+            s1 = s1.substr(1);
+        return (pm + s1).replace(/\.$/, "");
+    }
+    return String(num);
+}
+/**
+ * 向下舍出，强制保留小数位数
+ * @description 默认保留两位小数，此方法相当于强制截取小数位数
+ * @param {string|number} num 数字
+ * @param {number} decimals 保留小数的位数，默认2位
+ * @returns {number} 返回字符串的数字
+ */
+function _toFixedFloor(num, decimals = 2) {
+    // 修复1：num可能是字符串，先转数字再判断NaN
+    const numVal = Number(num);
+    if (isNaN(numVal)) {
+        return "--";
+    }
+    // 默认为保留的小数点后两位
+    const dec = Math.max(0, Math.floor(decimals)); // 确保小数位数为非负整数
+    const tempNumStr = String(numVal); // 提前转字符串，避免重复转换
+    const pointIndex = tempNumStr.indexOf("."); // ：去掉+1，直接获取小数点位置
+    // 获取小数点后的个数(需要保证有小数位)
+    const pointCount = pointIndex > -1 ? tempNumStr.length - pointIndex - 1 : 0;
+    // 源数据为整数或者小数点后面小于decimals位的作补零处理
+    if (pointIndex === -1 || pointCount <= dec) {
+        // pointIndex === -1 表示无小数点
+        let tempNumA = tempNumStr; // 统一为字符串类型，避免类型混淆
+        if (pointIndex === -1) {
+            tempNumA = `${tempNumA}.`;
+            // 补零到指定小数位
+            for (let index = 0; index < dec; index++) {
+                tempNumA = `${tempNumA}0`;
+            }
+        }
+        else {
+            // 补零到指定小数位
+            for (let index = 0; index < dec - pointCount; index++) {
+                tempNumA = `${tempNumA}0`;
+            }
+        }
+        return tempNumA;
+    }
+    // 截取当前数据到小数点后decimals位
+    const [integerPart, decimalPart] = tempNumStr.split(".");
+    return `${integerPart}.${decimalPart.substring(0, dec)}`;
+}
+/**
+ * 四舍五入，尽可能保留小数
+ * @param {string|number} num 数字
+ * @param {number} decimals 保留小数的位数，默认2位
+ * @returns {number} 返回保留后的数字
+ */
+function _toDecimalRound(num, decimals = 2) {
+    if (isNaN(Number(num))) {
+        return "--";
+    }
+    const n = Math.pow(10, decimals);
+    return Math.round(Number(num) * n) / n;
+}
+/**
+ * 向下舍入，尽可能保留小数
+ * @param {string|number} num 数字
+ * @param {number} decimals 保留小数的位数，默认2位
+ * @returns {number} 返回保留后的数字
+ */
+function _toDecimalFloor(num, decimals = 2) {
+    if (isNaN(Number(num))) {
+        return "--";
+    }
+    const n = Math.pow(10, decimals);
+    return Math.floor(Number(num) * n) / n;
+}
+
+export { add, divide, gcd, modulo, multiply, scm, subtract, toDecimal, toFixed };

package/dist/es/number/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 转为数字类型
+ * @description 解决部分浏览器在转换 '08','09'等是0开头时被默认转8进制问题
+ * @param {string|number} value 转换的值
+ * @param {number} radix 进制数，默认10进制
+ * @returns {number} 返回转换后的数字
+ */
+export declare function parseInt(value: string | number, radix?: number): number;
+/**
+ * 转为小数类型
+ * @param {string|number} value 转换的值
+ * @returns {number} 返回转换后的数字
+ */
+export declare function parseFloat(value: string | number): number;

package/dist/es/number/index.mjs

@@ -0,0 +1,31 @@
+import { isNull } from '../validate/index.mjs';
+
+/**
+ * @module 数字
+ */
+/**
+ * 转为数字类型
+ * @description 解决部分浏览器在转换 '08','09'等是0开头时被默认转8进制问题
+ * @param {string|number} value 转换的值
+ * @param {number} radix 进制数，默认10进制
+ * @returns {number} 返回转换后的数字
+ */
+function parseInt(value, radix = 10) {
+    if (isNull(value)) {
+        return 0;
+    }
+    return Number.parseInt(String(value), radix);
+}
+/**
+ * 转为小数类型
+ * @param {string|number} value 转换的值
+ * @returns {number} 返回转换后的数字
+ */
+function parseFloat(value) {
+    if (isNull(value)) {
+        return 0.0;
+    }
+    return Number.parseFloat(String(value));
+}
+
+export { parseFloat, parseInt };

package/dist/es/object/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * map转object
+ * @param {Map} map 参数
+ * @returns {Object} 返回Object
+ */
+export declare function mapToObject(map: Map<any, any>): Record<any, any>;
+/**
+ * map转json字符串
+ * @param {Map} map 参数
+ * @returns {string} 返回Json字符串
+ */
+export declare function mapToJson(map: Map<any, any>): string;
+/**
+ * object转map
+ * @param {Object} obj 参数
+ * @returns {Map} 返回Map
+ */
+export declare function objectToMap(obj: Record<any, any>): Map<any, any>;
+/**
+ * json字符串转map
+ * @param {string} json json字符串
+ * @returns {Map} 返回Map
+ */
+export declare function jsonToMap(json: string): Map<any, any>;
+/**
+ * json对象转json字符串
+ * @param {Object} json json对象
+ * @param {boolean} replacer 是否处理循环引用
+ * @returns {string} 返回Json字符串
+ */
+export declare function stringifyJson(json: Record<any, any>, replacer?: boolean): string;
+/**
+ * json字符串转json对象
+ * @param {string} json json字符串
+ * @returns {Object} 返回Json对象
+ */
+export declare function parseJson(json: string): Record<any, any> | null;
+/**
+ * 浅拷贝数据
+ * @param {*} source 拷贝的数据
+ * @returns {*} 返回浅拷贝的数据
+ */
+export declare function clone(source: any): any;
+/**
+ * 深拷贝数据
+ * @param {*} source 拷贝的数据
+ * @returns {*} 返回深拷贝的数据
+ */
+export declare function deepClone(source: any): any;
+/**
+ * 比较两个对象是否相等
+ * @description 方法只能对比简单的对象，不能包含function，另外对象的属性顺序不一致也是相等的
+ * @param {Object} obj1 对象1
+ * @param {Object} obj2 对象2
+ * @returns {boolean} 返回true和false
+ */
+export declare function objectEquals(obj1: Record<any, any>, obj2: Record<any, any>): boolean;
+/**
+ * 合并对象
+ * @param {Object} target 目标对象
+ * @param {Object[]} source 原对象列表
+ * @returns {Object} 返回合并后的对象
+ */
+export declare function merge(target: Record<any, any>, ...source: Record<any, any>[]): any;
+/**
+ * 根据字符串属性路径获取目标对象的值
+ * @example
+ * let res = {code:200, data:{rows:[], pages:{current:1,pageSize:20}}}
+ * this._getValueByPath(res, 'data.pages.pageSize'); // 这里会输出20
+ * @param {Object} target 目标对象
+ * @param {string} path 字符串属性路径
+ * @returns {Object} 返回目标对象
+ */
+export declare function getValueByPath(target: Record<any, any>, path?: string): any;
+/**
+ * 根据字符串属性路径设置目标对象的值
+ * @example
+ * let res = {code:200, data:{rows:[], pages:{current:1,pageSize:20}}}
+ * this._setValueByPath(res, 'data.pages.pageSize', 30); // 打印res对象会发现pageSize的值改为了30
+ * @param {Object} target 目标对象
+ * @param {string} path 字符串属性路径
+ * @param {*} value 值
+ */
+export declare function setValueByPath(target: Record<any, any>, path: string | undefined, value: any): Record<any, any>;