@ivujs/i-utils 1.1.18 → 2.0.0

package/dist/es/math/index.mjs

@@ -0,0 +1,268 @@
+import { isNaN } from '../validate/index.mjs';
+import { MATH } from '../constants/math.mjs';
+
+/* 数字计算 */
+/**
+ * 两个数字相加
+ * @param {String|Number} arg1 第一个数字
+ * @param {String|Number} arg2 第二个数字
+ * @returns {Number} 返回计算后的数字
+ */
+function add(arg1, arg2) {
+    let r1, r2, m;
+    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));
+    return (arg1 * m + 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 ((arg1 * m - arg2 * m) / m).toFixed(n);
+}
+/**
+ * 两个数字相乘
+ * @param {String|Number} arg1 第一个数字
+ * @param {String|Number} arg2 第二个数字
+ * @returns 返回计算后的数字
+ */
+function multiply(arg1, arg2) {
+    let m = 0, s1 = arg1.toString(), 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, r1, r2;
+    try {
+        t1 = arg1.toString().split(".")[1].length;
+    }
+    catch (e) { }
+    try {
+        t2 = arg2.toString().split(".")[1].length;
+    }
+    catch (e) { }
+    r1 = Number(arg1.toString().replace(".", ""));
+    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) {
+    return !arg2 ? arg1 : gcd(arg2, arg1 % arg2);
+}
+/**
+ * 最小公倍数
+ * @param {String|Number} arg1 第一个数字
+ * @param {String|Number} arg2 第二个数字
+ * @returns {Number} 返回计算后的数字
+ */
+function scm(arg1, arg2) {
+    return (arg1 * arg2) / gcd(arg1, arg2);
+}
+/* 数字精度 */
+/**
+ * 强制保留小数位数
+ * @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(num)) {
+        return "--";
+    }
+    let s = String(num);
+    if (!decimals)
+        decimals = 0;
+    if (s.indexOf(".") === -1)
+        s += ".";
+    s += new Array(decimals + 1).join("0");
+    if (new RegExp("^(-|\\+)?(\\d+(\\.\\d{0," + (decimals + 1) + "})?)\\d*$").test(s)) {
+        let s = "0" + RegExp.$2, pm = RegExp.$1, a = RegExp.$3.length, b = true;
+        if (a === decimals + 2) {
+            a = s.match(/\d/g);
+            if (parseInt(a[a.length - 1]) > 4) {
+                for (let i = a.length - 2; i >= 0; i--) {
+                    a[i] = parseInt(a[i]) + 1;
+                    if (a[i] === 10) {
+                        a[i] = 0;
+                        b = i !== 1;
+                    }
+                    else
+                        break;
+                }
+            }
+            s = a.join("").replace(new RegExp("(\\d+)(\\d{" + decimals + "})\\d$"), "$1.$2");
+        }
+        if (b)
+            s = s.substr(1);
+        return (pm + s).replace(/\.$/, "");
+    }
+    return String(num);
+}
+/**
+ * 向下舍出，强制保留小数位数
+ * @description 默认保留两位小数，此方法相当于强制截取小数位数
+ * @param {String|Number} num 数字
+ * @param {Number} decimals 保留小数的位数，默认2位
+ * @returns {Number} 返回字符串的数字
+ */
+function _toFixedFloor(num, decimals = 2) {
+    if (isNaN(num)) {
+        return "--";
+    }
+    // 默认为保留的小数点后两位
+    let dec = decimals;
+    let tempNum = Number(num);
+    let pointIndex = String(tempNum).indexOf(".") + 1; // 获取小数点的位置 + 1
+    let pointCount = pointIndex ? String(tempNum).length - pointIndex : 0; // 获取小数点后的个数(需要保证有小数位)
+    // 源数据为整数或者小数点后面小于decimals位的作补零处理
+    if (pointIndex === 0 || pointCount <= dec) {
+        let tempNumA = tempNum;
+        if (pointIndex === 0) {
+            tempNumA = `${tempNumA}.`;
+            for (let index = 0; index < dec - pointCount; index++) {
+                tempNumA = `${tempNumA}0`;
+            }
+        }
+        else {
+            for (let index = 0; index < dec - pointCount; index++) {
+                tempNumA = `${tempNumA}0`;
+            }
+        }
+        return tempNumA;
+    }
+    let realVal = "";
+    // 截取当前数据到小数点后decimals位
+    realVal = `${String(tempNum).split(".")[0]}.${String(tempNum).split(".")[1].substring(0, dec)}`;
+    return String(realVal);
+}
+/**
+ * 四舍五入，尽可能保留小数
+ * @param {String|Number} num 数字
+ * @param {Number} decimals 保留小数的位数，默认2位
+ * @returns {Number} 返回保留后的数字
+ */
+function _toDecimalRound(num, decimals = 2) {
+    if (isNaN(num)) {
+        return "--";
+    }
+    let n = Math.pow(10, decimals);
+    return Math.round(num * n) / n;
+}
+/**
+ * 向下舍入，尽可能保留小数
+ * @param {String|Number} num 数字
+ * @param {Number} decimals 保留小数的位数，默认2位
+ * @returns {Number} 返回保留后的数字
+ */
+function _toDecimalFloor(num, decimals = 2) {
+    if (isNaN(num)) {
+        return "--";
+    }
+    let n = Math.pow(10, decimals);
+    return Math.floor(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 function parseInt(value: any, radix?: number): number;
+/**
+ * 转为小数类型
+ * @param {String,number} value 转换的值
+ * @returns {Number} 返回转换后的数字
+ */
+export function parseFloat(value: any): number;

package/dist/es/number/index.mjs

@@ -0,0 +1,28 @@
+import { isNull } from '../validate/index.mjs';
+
+/**
+ * 转为数字类型
+ * @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(value, radix);
+}
+/**
+ * 转为小数类型
+ * @param {String,number} value 转换的值
+ * @returns {Number} 返回转换后的数字
+ */
+function parseFloat(value) {
+    if (isNull(value)) {
+        return 0.0;
+    }
+    return Number.parseFloat(value);
+}
+
+export { parseFloat, parseInt };

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

@@ -0,0 +1,83 @@
+/**
+ * map转object
+ * @param {Map} map 参数
+ * @returns {Object} 返回Object
+ */
+export function mapToObject(map: Map<any, any>): Object;
+/**
+ * map转json字符串
+ * @param {Map} map 参数
+ * @returns {String} 返回Json字符串
+ */
+export function mapToJson(map: Map<any, any>): string;
+/**
+ * object转map
+ * @param {Object} obj 参数
+ * @returns {Map} 返回Map
+ */
+export function objectToMap(obj: Object): Map<any, any>;
+/**
+ * json字符串转map
+ * @param {String} json json字符串
+ * @returns {Map} 返回Map
+ */
+export function jsonToMap(json: string): Map<any, any>;
+/**
+ * json对象转json字符串
+ * @param {Object} json json对象
+ * @returns {String} 返回Json字符串
+ */
+export function stringifyJson(json: Object): string;
+/**
+ * json字符串转json对象
+ * @param {String} json json字符串
+ * @returns {Object} 返回Json对象
+ */
+export function parseJson(json: string): Object;
+/**
+ * 浅拷贝数据
+ * @param {*} source 拷贝的数据
+ * @returns {*} 返回浅拷贝的数据
+ */
+export function clone(source: any): any;
+/**
+ * 深拷贝数据
+ * @param {*} source 拷贝的数据
+ * @returns {*} 返回深拷贝的数据
+ */
+export function deepClone(source: any): any;
+/**
+ * 比较两个对象是否相等
+ * @description 方法只能对比简单的对象，不能包含function，另外对象的属性顺序不一致也是相等的
+ * @param {Object} obj1 对象1
+ * @param {Object} obj2 对象2
+ * @returns {Boolean} 返回true和false
+ */
+export function objectEquals(obj1: Object, obj2: Object): boolean;
+/**
+ * 合并对象
+ * @param {Object} target 目标对象
+ * @param {Object[]} source 原对象列表
+ * @returns {Object} 返回合并后的对象
+ */
+export function merge(target: Object, ...source: Object[]): Object;
+/**
+ * 根据字符串属性路径获取目标对象的值
+ * @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 function getValueByPath(target: Object, path?: string): Object;
+/**
+ * 根据字符串属性路径设置目标对象的值
+ * @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 function setValueByPath(target: Object, path: string, value: any): Object;

package/dist/es/object/index.mjs

@@ -0,0 +1,259 @@
+import { isEmpty, isObject, isArray, isDate, isNaN } from '../validate/index.mjs';
+
+/* 对象转换 */
+/**
+ * map转object
+ * @param {Map} map 参数
+ * @returns {Object} 返回Object
+ */
+function mapToObject(map) {
+    let obj = Object.create(null);
+    for (let [k, v] of map) {
+        obj[k] = v;
+    }
+    return obj;
+}
+/**
+ * map转json字符串
+ * @param {Map} map 参数
+ * @returns {String} 返回Json字符串
+ */
+function mapToJson(map) {
+    return JSON.stringify(mapToObject(map));
+}
+/**
+ * object转map
+ * @param {Object} obj 参数
+ * @returns {Map} 返回Map
+ */
+function objectToMap(obj) {
+    let map = new Map();
+    for (let k of Object.keys(obj)) {
+        map.set(k, obj[k]);
+    }
+    return map;
+}
+/**
+ * json字符串转map
+ * @param {String} json json字符串
+ * @returns {Map} 返回Map
+ */
+function jsonToMap(json) {
+    return objectToMap(JSON.parse(json));
+}
+/**
+ * json对象转json字符串
+ * @param {Object} json json对象
+ * @returns {String} 返回Json字符串
+ */
+function stringifyJson(json) {
+    return JSON.stringify(json);
+}
+/**
+ * json字符串转json对象
+ * @param {String} json json字符串
+ * @returns {Object} 返回Json对象
+ */
+function parseJson(json) {
+    if (isEmpty(json))
+        return;
+    return JSON.parse(json);
+}
+/* 数据拷贝，对比，合并等操作 */
+/**
+ * 浅拷贝数据
+ * @param {*} source 拷贝的数据
+ * @returns {*} 返回浅拷贝的数据
+ */
+function clone(source) {
+    return Object.assign(source);
+}
+/**
+ * 深拷贝数据
+ * @param {*} source 拷贝的数据
+ * @returns {*} 返回深拷贝的数据
+ */
+function deepClone(source) {
+    // Object
+    if (isObject(source)) {
+        let copy = {};
+        for (let attr in source) {
+            if (source.hasOwnProperty(attr))
+                copy[attr] = deepClone(source[attr]);
+        }
+        return copy;
+    }
+    // Array
+    else if (isArray(source)) {
+        let copy = [];
+        for (let i = 0, len = source.length; i < len; i++) {
+            copy[i] = deepClone(source[i]);
+        }
+        return copy;
+    }
+    // Date
+    else if (isDate(source)) {
+        let copy = new Date();
+        copy.setTime(source.getTime());
+        return copy;
+    }
+    // Other 返回原数据
+    else {
+        return source;
+    }
+}
+/**
+ * 比较两个对象是否相等
+ * @description 方法只能对比简单的对象，不能包含function，另外对象的属性顺序不一致也是相等的
+ * @param {Object} obj1 对象1
+ * @param {Object} obj2 对象2
+ * @returns {Boolean} 返回true和false
+ */
+function objectEquals(obj1, obj2) {
+    // 比较值相等
+    if (obj1 === obj2) {
+        return true;
+    }
+    // 比较Date
+    if (obj1 instanceof Date && obj2 instanceof Date) {
+        return obj1.getTime() === obj2.getTime();
+    }
+    // 对象比较引用
+    if (!obj1 || !obj2 || (typeof obj1 !== "object" && typeof obj2 !== "object")) {
+        return obj1 === obj2;
+    }
+    // 比较原型
+    if (obj1.prototype !== obj2.prototype) {
+        return false;
+    }
+    // 比较对象的值
+    const keys = Object.keys(obj1);
+    if (keys.length !== Object.keys(obj2).length) {
+        return false;
+    }
+    else {
+        return keys.every((k) => objectEquals(obj1[k], obj2[k]));
+    }
+}
+/**
+ * 合并对象
+ * @param {Object} target 目标对象
+ * @param {Object[]} source 原对象列表
+ * @returns {Object} 返回合并后的对象
+ */
+function merge(target, ...source) {
+    return Object.assign(target, ...source);
+}
+/* 根据字符串属性路径操作目标对象 */
+/**
+ * 根据字符串属性路径获取目标对象的值
+ * @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} 返回目标对象
+ */
+function getValueByPath(target, path = "data") {
+    const paths = (path || "data").split(".");
+    let current = target;
+    for (const index in paths) {
+        let part = paths[index];
+        // 判断属性是取的数组
+        let { propName, propIndex, isArray } = _getTargetPathPart(paths[index]);
+        if (isArray) {
+            // 获取的数组下标超出实际的长度
+            if (propIndex < 0 || propIndex >= current[propName].length) {
+                return undefined;
+            }
+            // 逐层向下找到对应属性的值
+            current = current[propName][propIndex];
+        }
+        // 判断属性是取的对象属性
+        else {
+            // 如果属性不存在，则返回空的
+            if (!current || !current.hasOwnProperty(part) || typeof current !== "object") {
+                return undefined;
+            }
+            // 逐层向下找到对应属性的值
+            current = current[part];
+        }
+    }
+    return current;
+}
+/**
+ * 根据字符串属性路径设置目标对象的值
+ * @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 值
+ */
+function setValueByPath(target, path = "data", value) {
+    const paths = (path || "data").split(".");
+    let current = target;
+    // 遍历到路径的倒数第二个属性
+    for (let index = 0; index < paths.length - 1; index++) {
+        let part = paths[index];
+        let nextPart = paths[index + 1];
+        // 判断属性是取的数组
+        let { propName, propIndex, isArray } = _getTargetPathPart(part);
+        if (isArray) {
+            // 检查当前属性是否存在，若不存在或者不是数组，则创建一个数组
+            if (!current || !current.hasOwnProperty(propName)) {
+                current[propName] = [];
+            }
+            // 确保数组长度足够容纳指定索引
+            while (current[propName].length <= propIndex) {
+                current[propName].push({});
+            }
+            // 逐层向下找到对应属性的值
+            current = current[propName][propIndex];
+        }
+        else {
+            // 如果不是数组索引形式，处理普通对象属性，如果是.1.数组形式，则还是返回数组
+            if (!current || !current.hasOwnProperty(part) || typeof current[part] !== "object") {
+                current[part] = isNaN(nextPart) ? [] : {};
+            }
+            // 移动到对象的下一层属性
+            current = current[part];
+        }
+    }
+    // 处理最后一个路径部分
+    let lastPath = paths[paths.length - 1];
+    let { propName, propIndex, isArray } = _getTargetPathPart(lastPath);
+    if (isArray) {
+        // 检查当前属性是否存在，若不存在或者不是数组，则创建一个数组
+        if (!current.hasOwnProperty(propName) || !Array.isArray(current[propName])) {
+            current[propName] = [];
+        }
+        // 确保数组长度足够容纳指定索引
+        while (current[propName].length <= propIndex) {
+            current[propName].push({});
+        }
+        // 逐层向下找到对应属性的值
+        current[propName][propIndex] = value;
+    }
+    else {
+        current[lastPath] = value;
+    }
+    // 返回源对象
+    return target;
+}
+/* 内部方法 */
+/**
+ * 获得目标路径的片段
+ * @param path
+ * @returns {{propName: (*|undefined), propIndex: (*|number|undefined), isArray: boolean}}
+ */
+function _getTargetPathPart(path) {
+    let pathArrayMatch = path.match(/^(\w+)\[(\d+)]$/);
+    return {
+        propName: (pathArrayMatch && pathArrayMatch[1]) || undefined, // 属性名
+        propIndex: pathArrayMatch ? parseInt(pathArrayMatch[2], 10) : undefined, // 属性数组时候的下标
+        isArray: !!pathArrayMatch, // 是否是数组
+    };
+}
+
+export { clone, deepClone, getValueByPath, jsonToMap, mapToJson, mapToObject, merge, objectEquals, objectToMap, parseJson, setValueByPath, stringifyJson };

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

@@ -0,0 +1,34 @@
+/**
+ * 获得分页起始数
+ * @param {Object} pagination 分页参数
+ * @returns {Array} 返回起始数
+ */
+export function getLimit(pagination?: Object): any[];
+/**
+ * 获得总条数
+ * @param {Object} pagination 分页参数
+ * @returns {Number} 返回总条数
+ */
+export function getTotalPage(pagination?: Object): number;
+/**
+ * 获得彩虹分页器
+ * @param {Object} pagination 分页参数
+ * @param {Function} callback 回调函数
+ * @returns {Promise} 返回彩虹分页器数据
+ */
+export function getRainbowPager(pagination: Object | undefined, callback: Function): Promise<any>;
+/**
+ * 获得上一页
+ * @param {Object} pagination 分页参数
+ * @param {Function} callback 回调函数
+ * @returns {Promise} 返回上一页
+ */
+export function getPrevPage(pagination: Object | undefined, callback: Function): Promise<any>;
+/**
+ * 获得下一页
+ * @description 最后一页会根据totalPage参数判断，如果不传此参数，则会根据参数中pageSize和total重新计算总页数
+ * @param {Object} pagination 分页参数
+ * @param {Function} callback 回调函数
+ * @returns {Promise} 返回下一页
+ */
+export function getNextPage(pagination: Object | undefined, callback: Function): Promise<any>;