@ivujs/i-utils 1.1.1 → 1.1.2

package/dist/cjs/math/index.cjs

@@ -1,284 +0,0 @@
-'use strict';
-
-var index = require('../validate/index.cjs');
-var math = require('../constants/math.cjs');
-
-/* 数字计算 */
-/**
- * 两个数字相加
- * @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.MATH.ROUND) {
-  // 四舍五入
-  if (mode === math.MATH.ROUND) {
-    return _toFixedRound(num, decimals);
-  }
-  // 向下舍出
-  if (mode === math.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.MATH.ROUND) {
-  // 四舍五入
-  if (mode === math.MATH.ROUND) {
-    return _toDecimalRound(num, decimals);
-  }
-  // 向下舍出
-  if (mode === math.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 (index.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 (index.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 (index.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 (index.isNaN(num)) {
-    return "--";
-  }
-  let n = Math.pow(10, decimals);
-  return Math.floor(num * n) / n;
-}
-
-exports.add = add;
-exports.divide = divide;
-exports.gcd = gcd;
-exports.modulo = modulo;
-exports.multiply = multiply;
-exports.scm = scm;
-exports.subtract = subtract;
-exports.toDecimal = toDecimal;
-exports.toFixed = toFixed;

package/dist/cjs/number/index.cjs

@@ -1,14 +0,0 @@
-'use strict';
-
-/**
- * 转为数字类型
- * @description 解决部分浏览器在转换 '08','09'等是0开头时被默认转8进制问题
- * @param {String,number} value 转换的值
- * @param {Number} radix 进制数，默认10进制
- * @returns {Number} 返回转换后的数字
- */
-function parseInt(value, radix = 10) {
-  return Number.parseInt(value, radix);
-}
-
-exports.parseInt = parseInt;

package/dist/cjs/object/index.cjs

@@ -1,216 +0,0 @@
-'use strict';
-
-var index = require('../validate/index.cjs');
-
-/* 对象转换 */
-/**
- * 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 (index.isEmpty(json)) return;
-  return JSON.parse(json);
-}
-
-/* 数据拷贝，对比，合并等操作 */
-/**
- * 浅拷贝数据
- * @param {*} source 拷贝的数据
- * @returns {*} 返回浅拷贝的数据
- */
-function clone(source) {
-  return Object.assign(source);
-}
-
-/**
- * 深拷贝数据
- * @param {*} source 拷贝的数据
- * @returns {*} 返回深拷贝的数据
- */
-function cloneDeep(source) {
-  //  Object
-  if (index.isObject(source)) {
-    let copy = {};
-    for (let attr in source) {
-      if (source.hasOwnProperty(attr)) copy[attr] = cloneDeep(source[attr]);
-    }
-    return copy;
-  }
-
-  //  Array
-  else if (index.isArray(source)) {
-    let copy = [];
-    for (let i = 0, len = source.length; i < len; i++) {
-      copy[i] = cloneDeep(source[i]);
-    }
-    return copy;
-  }
-
-  //  Date
-  else if (index.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._getTargetValueByPath(res, 'data.pages.pageSize'); // 这里会输出20
- * @param {Object} target 目标对象
- * @param {String} path 字符串属性路径
- * @returns {Object} 返回目标对象
- */
-function getTargetValueByPath(target, path = "data") {
-  const paths = (path || "data").split(".");
-  let data = target;
-  // 属性总个数
-  let lastIndex = paths.length - 1;
-  for (const index in paths) {
-    // 如果路径中没有该属性，则创建一个
-    if (data[paths[index]] === null || data[paths[index]] === undefined) {
-      data[paths[index]] = Number(index) !== lastIndex ? {} : undefined;
-    }
-    // 逐层向下找到对应属性的值
-    data = data[paths[index]];
-  }
-  return data;
-}
-
-/**
- * 根据字符串属性路径设置目标对象的值
- * @example
- * let res = {code:200, data:{rows:[], pages:{current:1,pageSize:20}}}
- * this._setTargetValueByPath(res, 'data.pages.pageSize', 30); // 打印res对象会发现pageSize的值改为了30
- * @param {Object} target 目标对象
- * @param {String} path 字符串属性路径
- * @param {*} value 值
- */
-function setTargetValueByPath(target, path = "data", value) {
-  const paths = (path || "data").split(".");
-  // 变量表达式拼接，最终结果如：target['personInfo']['personName']='xxx';
-  let fxStr = "";
-  for (const name of paths) {
-    fxStr += `['${name}']`;
-  }
-  const fn = new Function("target", `target${fxStr}=${value}`);
-  fn(target);
-}
-
-exports.clone = clone;
-exports.cloneDeep = cloneDeep;
-exports.getTargetValueByPath = getTargetValueByPath;
-exports.jsonToMap = jsonToMap;
-exports.mapToJson = mapToJson;
-exports.mapToObject = mapToObject;
-exports.merge = merge;
-exports.objectEquals = objectEquals;
-exports.objectToMap = objectToMap;
-exports.parseJson = parseJson;
-exports.setTargetValueByPath = setTargetValueByPath;
-exports.stringifyJson = stringifyJson;

package/dist/cjs/pagination/index.cjs

@@ -1,140 +0,0 @@
-'use strict';
-
-/**
- * 获得分页起始数
- * @param {Object} pagination 分页参数
- * @returns {Array} 返回起始数
- */
-function getLimit(pagination = { page: 1, pageSize: 10, total: 0, totalPage: 0, pagerCount: 7 }) {
-  return [pagination.pageSize * (pagination.page - 1), pagination.pageSize * pagination.page];
-}
-
-/**
- * 获得总条数
- * @param {Object} pagination 分页参数
- * @returns {Number} 返回总条数
- */
-function getTotalPage(pagination = { page: 1, pageSize: 10, total: 0, totalPage: 0, pagerCount: 7 }) {
-  return Math.ceil((pagination.total || 0) / (pagination.pageSize || 0));
-}
-
-/**
- * 获得彩虹分页器
- * @param {Object} pagination 分页参数
- * @param {Function} callback 回调函数
- * @returns {Promise} 返回彩虹分页器数据
- */
-function getRainbowPager(
-  pagination = {
-    page: 1,
-    pageSize: 10,
-    total: 0,
-    totalPage: 0,
-    pagerCount: 7,
-  },
-  callback,
-) {
-  return new Promise((resolve) => {
-    // 分页参数
-    let page = pagination.page || 1;
-    let totalPage = pagination.totalPage > 0 ? pagination.totalPage : getTotalPage(pagination);
-    let pagerCount = pagination.pagerCount || 7;
-
-    // 计算参数
-    let isEven = (pagerCount & 1) === 0;
-    let left = pagerCount >> 1;
-    let right = pagerCount >> 1;
-    let pagerLength = pagerCount;
-
-    // 计算生成的分页器数量
-    if (isEven) {
-      right++;
-    }
-    if (totalPage < pagerCount) {
-      pagerLength = totalPage;
-    }
-
-    // 分页器数组
-    let pager = new Array(pagerLength);
-
-    // 生成分页器
-    if (totalPage >= pagerCount) {
-      if (page <= left) {
-        for (let i = 0; i < pager.length; i++) {
-          pager[i] = i + 1;
-        }
-      } else if (page > totalPage - right) {
-        for (let i = 0; i < pager.length; i++) {
-          pager[i] = i + totalPage - pagerCount + 1;
-        }
-      } else {
-        for (let i = 0; i < pager.length; i++) {
-          pager[i] = i + page - left + (isEven ? 1 : 0);
-        }
-      }
-    } else {
-      for (let i = 0; i < pager.length; i++) {
-        pager[i] = i + 1;
-      }
-    }
-
-    // 支持回调函数和Promise
-    callback && callback(pager);
-    resolve(pager);
-  });
-}
-
-/**
- * 获得上一页
- * @param {Object} pagination 分页参数
- * @param {Function} callback 回调函数
- * @returns {Promise} 返回上一页
- */
-function getPrevPage(pagination = { page: 1, pageSize: 10, total: 0, totalPage: 0, pagerCount: 7 }, callback) {
-  return new Promise((resolve) => {
-    if (pagination.page > 1) {
-      pagination.page--;
-    } else {
-      pagination.page = 1;
-    }
-
-    // 支持回调函数和Promise
-    callback && callback(pagination.page);
-    resolve(pagination.page);
-  });
-}
-
-/**
- * 获得下一页
- * @description 最后一页会根据totalPage参数判断，如果不传此参数，则会根据参数中pageSize和total重新计算总页数
- * @param {Object} pagination 分页参数
- * @param {Function} callback 回调函数
- * @returns {Promise} 返回下一页
- */
-function getNextPage(pagination = { page: 1, pageSize: 10, total: 0, totalPage: 0, pagerCount: 7 }, callback) {
-  return new Promise((resolve) => {
-    // 获得总页数，如果没有传totalPage，则需要根据传的pageSize和total计算
-    let totalPage = pagination.totalPage > 0 ? pagination.totalPage : getTotalPage(pagination);
-
-    // 计算当前页大于0和小与0的情况
-    if (pagination.page > 0) {
-      if (pagination.page < totalPage) {
-        pagination.page++;
-      } else {
-        pagination.page = totalPage;
-      }
-    } else {
-      pagination.page = 1;
-    }
-
-    // 支持回调函数和Promise
-    callback && callback(pagination.page);
-    resolve(pagination.page);
-  });
-}
-
-exports.getLimit = getLimit;
-exports.getNextPage = getNextPage;
-exports.getPrevPage = getPrevPage;
-exports.getRainbowPager = getRainbowPager;
-exports.getTotalPage = getTotalPage;

package/dist/cjs/random/index.cjs

@@ -1,25 +0,0 @@
-'use strict';
-
-/**
- * 生成指定大小的随机整数
- * @description n和m参数表示最小和最大范围值，默认0-9之间范围
- * @param {Number} min 随机数的最小值，默认 0
- * @param {Number} max 随机数的最大值，默认 9
- * @returns {Number} 返回指定大小的随机整数
- */
-function getRandom(min = 0, max = 9) {
-  return Math.floor(Math.random() * (max - min + 1) + min);
-}
-
-/**
- * 生成固定位数的随机整数
- * @description 默认是1，代表生成0-9之间一位，如果是2，则生成10-99之间两位，以此类推
- * @param {Number} len 固定的位数
- * @returns {Number} 返回固定位数的随机数
- */
-function getRandomDigit(len = 1) {
-  return Math.floor((Math.random() + Math.floor(Math.random() * 9 + 1)) * Math.pow(10, len - 1));
-}
-
-exports.getRandom = getRandom;
-exports.getRandomDigit = getRandomDigit;