tools-for-js 0.0.2 → 0.1.0

package/README.md

@@ -16,18 +16,23 @@ import { API } from 'tools-for-js'
 
 ### API
 
-| 名称                 | API             | 说明 |
-| -------------------- | --------------- | ---- |
-| 阿拉伯数字转中文数字 | numToChinese    |      |
-| 金额格式化           | moneyFormat     |      |
-| 时间格式化           | dateFormat      |      |
-| 获取时间间隔         | getTimeDistance |      |
-| 转换时间戳           | timeStamp       |      |
-| 获取倒计时           | countDown       |      |
-| 变量类型判断         | IsType          |      |
-| 深拷贝变量           | deepCopy        |      |
-| 校验空值参数         | isEmpty         |      |
-| 校验两个参数是否相等 | isEqual         |      |
-| 数组去重             | deWeightArray   |      |
-| 生成 UUID            | createUUID      |      |
-|                      |                 |      |
+| 名称                         | API              | 说明 |
+| ---------------------------- | ---------------- | ---- |
+| 阿拉伯数字转中文数字         | numToChinese     |      |
+| 金额格式化                   | moneyFormat      |      |
+| 时间格式化                   | dateFormat       |      |
+| 下划线转小驼峰               | convertSmallHump |      |
+| 获取时间间隔                 | getTimeDistance  |      |
+| 转换时间戳                   | timeStamp        |      |
+| 获取倒计时                   | countDown        |      |
+| 变量类型判断                 | IsType           |      |
+| 深拷贝变量                   | deepCopy         |      |
+| 校验空值参数                 | isEmpty          |      |
+| 校验两个参数是否相等         | isEqual          |      |
+| 生成 UUID                    | createUUID       |      |
+| 数组去重                     | deWeightArray    |      |
+| 计算树的最后节点某字段的总和 | treeLastChildSum |      |
+| 精确加法                     | exactAdd         |      |
+| 计算数组元素的和             | summation        |      |
+| 计算两个参数                 | countNumber      |      |
+|                              |                  |      |

package/lib/index.js

@@ -9,12 +9,24 @@ Object.defineProperty(exports, "IsType", {
     return _common.IsType;
   }
 });
+Object.defineProperty(exports, "convertSmallHump", {
+  enumerable: true,
+  get: function get() {
+    return _transform.convertSmallHump;
+  }
+});
 Object.defineProperty(exports, "countDown", {
   enumerable: true,
   get: function get() {
     return _time.countDown;
   }
 });
+Object.defineProperty(exports, "countNumber", {
+  enumerable: true,
+  get: function get() {
+    return _calculate.countNumber;
+  }
+});
 Object.defineProperty(exports, "createUUID", {
   enumerable: true,
   get: function get() {
@@ -30,7 +42,7 @@ Object.defineProperty(exports, "dateFormat", {
 Object.defineProperty(exports, "deWeightArray", {
   enumerable: true,
   get: function get() {
-    return _common.deWeightArray;
+    return _array.deWeightArray;
   }
 });
 Object.defineProperty(exports, "deepCopy", {
@@ -39,6 +51,12 @@ Object.defineProperty(exports, "deepCopy", {
     return _common.deepCopy;
   }
 });
+Object.defineProperty(exports, "exactAdd", {
+  enumerable: true,
+  get: function get() {
+    return _calculate.exactAdd;
+  }
+});
 Object.defineProperty(exports, "getTimeDistance", {
   enumerable: true,
   get: function get() {
@@ -69,6 +87,12 @@ Object.defineProperty(exports, "numToChinese", {
     return _transform.numToChinese;
   }
 });
+Object.defineProperty(exports, "summation", {
+  enumerable: true,
+  get: function get() {
+    return _calculate.summation;
+  }
+});
 Object.defineProperty(exports, "textTransform", {
   enumerable: true,
   get: function get() {
@@ -83,4 +107,6 @@ Object.defineProperty(exports, "timeStamp", {
 });
 var _transform = require("./utils/transform");
 var _time = require("./utils/time");
+var _array = require("./utils/array");
+var _calculate = require("./utils/calculate");
 var _common = require("./utils/common");

package/lib/utils/array.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.treeLastChildSum = exports.deWeightArray = void 0;
+var _calculate = require("./calculate");
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/*******
+ * @description: 数组去重
+ * @author: 琴时
+ * @param {Array} list [需要去重的数组对象]
+ * @param {String} key [指定数组对象元素主键]
+ * 以该主键的值为标准判断数据是否重复|如果数组元素是一般数据类型,key传空即可
+ * @param {Function} callback [回调函数,用于处理去重后重复的数据(可不传)]
+ * @return {Array} 去重后的新数组对象
+ */
+var deWeightArray = exports.deWeightArray = function deWeightArray(list, key, callback) {
+  /* 如果数组的元素是基本数据类型那就不传第二个参数 */
+  if (!key) {
+    var set = new Set(list);
+    return _toConsumableArray(set);
+  }
+  var tempList = []; //重复数据
+  var map = new Map(); //创建Map对象数据结构
+  // 遍历需要去重的数组对象
+  list.forEach(function (item) {
+    // 判断map对象中该key是否已经存在
+    if (!map.has(item[key])) {
+      map.set(item[key], item); //如果不存在，将该数据插入
+    } else {
+      tempList.push(item);
+    }
+  });
+  IsType('Function', callback) && callback(tempList);
+  return _toConsumableArray(map.values()); //将map对象转换回数组再返回
+};
+
+/*******
+ * @description: [递归]计算树的最后节点某字段的总和
+ * @author: 琴时
+ * @param {Array}  tree            [数组树对象]
+ * @param {Object} config          [配置参数]
+ * @param {String} config.key      [目标节点名称]
+ * @param {String} config.children [递归树节点名称]
+ * @returns {Number} [目标节点某字段的总和]
+ * @example: treeLastChildSum(tree, { key: 'price', children: 'children' })
+ */
+
+var treeLastChildSum = exports.treeLastChildSum = function treeLastChildSum(tree, config) {
+  var _ref = config || {},
+    _ref$key = _ref.key,
+    key = _ref$key === void 0 ? 'id' : _ref$key,
+    _ref$children = _ref.children,
+    children = _ref$children === void 0 ? 'children' : _ref$children;
+  var sumList = []; //缓存目标节点值
+  var traverseTree = function traverseTree(tree, list, key, children) {
+    tree.forEach(function (item) {
+      if (item[children] && item[children].length > 0) {
+        traverseTree(item[children], list, key, children);
+      } else if (item[key]) {
+        list.push(item[key]);
+      }
+    });
+  };
+  traverseTree(tree, sumList, key, children);
+  return (0, _calculate.summation)(sumList);
+};

package/lib/utils/calculate.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.summation = exports.exactAdd = exports.countNumber = void 0;
+/**
+ * @description: 精确加法：
+ * js的加法结果会有丢失精度的情况，例如两个浮点数相加的时候
+ * @author: 琴时
+ * @param {Number|String} arg1
+ * @param {Number|String} arg2
+ * @return {Number}
+ */
+var exactAdd = exports.exactAdd = function exactAdd(arg1, arg2) {
+  if (isNaN(arg1)) arg1 = 0;
+  if (isNaN(arg2)) arg2 = 0;
+  arg1 = Number(arg1);
+  arg2 = Number(arg2);
+  var r1, r2, m, c;
+  try {
+    r1 = arg1.toString().split('.')[1].length;
+  } catch (e) {
+    r1 = 0;
+  }
+  try {
+    r2 = arg2.toString().split('.')[1].length;
+  } catch (e) {
+    r2 = 0;
+  }
+  c = Math.abs(r1 - r2);
+  m = Math.pow(10, Math.max(r1, r2));
+  if (c > 0) {
+    var cm = Math.pow(10, c);
+    if (r1 > r2) {
+      arg1 = Number(arg1.toString().replace('.', ''));
+      arg2 = Number(arg2.toString().replace('.', '')) * cm;
+    } else {
+      arg1 = Number(arg1.toString().replace('.', '')) * cm;
+      arg2 = Number(arg2.toString().replace('.', ''));
+    }
+  } else {
+    arg1 = Number(arg1.toString().replace('.', ''));
+    arg2 = Number(arg2.toString().replace('.', ''));
+  }
+  return (arg1 + arg2) / m;
+};
+/*******
+ * @description: 计算数组元素的和
+ * @author: 琴时
+ * @param {Array} list
+ * @return {Number}
+ */
+var summation = exports.summation = function summation(list) {
+  var sum = 0;
+  if (list && list.length > 0) {
+    sum = list.reduce(function (n, m) {
+      return exactAdd(n, m);
+    });
+  }
+  return sum;
+};
+
+/*******
+ * @description: 计算两个参数
+ * @param {Number|String} arg1
+ * @param {Number|String} arg2
+ * @param {String} type [计算类型:sum-加,subtract-减,multiply-乘,divide-除]
+ * @return {Number}
+ */
+var countNumber = exports.countNumber = function countNumber(arg1, arg2) {
+  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'sum';
+  if (arg1 === undefined || arg2 === undefined) {
+    console.log('参数格式不正确');
+    return NaN;
+  }
+  if (isNaN(arg1)) arg1 = 0;
+  if (isNaN(arg2)) arg2 = 0;
+
+  // 转字符串类型
+  arg1 = arg1.toString();
+  arg2 = arg2.toString();
+
+  // 获取小数点位置
+  var index1 = arg1.indexOf('.');
+  var index2 = arg2.indexOf('.');
+
+  // 获取小数点位数
+  var ws1 = 0;
+  var ws2 = 0;
+  if (index1 !== -1) {
+    ws1 = arg1.split('.')[1].length;
+  }
+  if (index2 !== -1) {
+    ws2 = arg2.split('.')[1].length;
+  }
+  var bigger = ws1 > ws2 ? ws1 : ws2; //位数较大值
+  var small = ws1 < ws2 ? ws1 : ws2; //位数较小值
+  var zeroCount = bigger - small; //位数差
+
+  // 去除小数点
+  arg1 = arg1.replace('.', '');
+  arg2 = arg2.replace('.', '');
+
+  // 位数差额补0
+  if (ws1 === small) {
+    for (var i = 0; i < zeroCount; i++) {
+      arg1 += '0';
+    }
+  } else {
+    for (var _i = 0; _i < zeroCount; _i++) {
+      arg2 += '0';
+    }
+  }
+  var result = 0; //结果
+  var multiple = 1; //倍数
+  for (var _i2 = 0; _i2 < bigger; _i2++) {
+    multiple = multiple * 10;
+  }
+
+  // 计算结果
+  if (type === 'sum') {
+    result = parseInt(arg1) + parseInt(arg2);
+    result = result / multiple;
+  } else if (type === 'subtract') {
+    result = parseInt(arg1) - parseInt(arg2);
+    result = result / multiple;
+  } else if (type === 'multiply') {
+    result = parseInt(arg1) * parseInt(arg2);
+    result = result / multiple / multiple;
+  } else if (type === 'divide') {
+    result = parseInt(arg1) / parseInt(arg2);
+  }
+  return result;
+};

package/lib/utils/common.js

@@ -3,13 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isEqual = exports.isEmpty = exports.deepCopy = exports.deWeightArray = exports.createUUID = exports.IsType = void 0;
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+exports.isEqual = exports.isEmpty = exports.deepCopy = exports.createUUID = exports.IsType = void 0;
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 /*******
  * @description: 变量类型判断
@@ -120,36 +114,6 @@ var isEqual = exports.isEqual = function isEqual(a, b) {
   return true;
 };
 
-/*******
- * @description: 数组去重
- * @author: 琴时
- * @param {Array} list [需要去重的数组对象]
- * @param {String} key [指定数组对象元素主键]
- * 以该主键的值为标准判断数据是否重复|如果数组元素是一般数据类型,key传空即可
- * @param {Function} callback [回调函数,用于处理去重后重复的数据(可不传)]
- * @return {Array} 去重后的新数组对象
- */
-var deWeightArray = exports.deWeightArray = function deWeightArray(list, key, callback) {
-  /* 如果数组的元素是基本数据类型那就不传第二个参数 */
-  if (!key) {
-    var set = new Set(list);
-    return _toConsumableArray(set);
-  }
-  var tempList = []; //重复数据
-  var map = new Map(); //创建Map对象数据结构
-  // 遍历需要去重的数组对象
-  list.forEach(function (item) {
-    // 判断map对象中该key是否已经存在
-    if (!map.has(item[key])) {
-      map.set(item[key], item); //如果不存在，将该数据插入
-    } else {
-      tempList.push(item);
-    }
-  });
-  IsType('Function', callback) && callback(tempList);
-  return _toConsumableArray(map.values()); //将map对象转换回数组再返回
-};
-
 /*******
  * @description: 生成UUID
  * UUID(Universally Unique IDentifier) 全局唯一标识符。

package/lib/utils/transform.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.textTransform = exports.numToChinese = exports.moneyFormat = void 0;
+exports.textTransform = exports.numToChinese = exports.moneyFormat = exports.convertSmallHump = void 0;
 var chnNumChar = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九'];
 var chnUnitSection = ['', '万', '亿', '万亿', '亿亿'];
 var chnUnitChar = ['', '十', '百', '千'];
@@ -159,4 +159,17 @@ var textTransform = exports.textTransform = function textTransform(params) {
     }
   });
   return arrayTemp;
+};
+
+/*******
+ * @description: 变量名下划线转小驼峰
+ * @author: 琴时
+ * @param {String} key
+ * @return {String}
+ * @example: convertSmallHump('user_name') => userName
+ */
+var convertSmallHump = exports.convertSmallHump = function convertSmallHump(key) {
+  return key.toLowerCase().replace(/_(\w)/g, function (all, letter) {
+    return letter.toUpperCase();
+  });
 };

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "tools-for-js",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "基于babel构建的javascript工具库",
   "main": "lib/index.js",
   "scripts": {
+    "start": "sh build/start.sh",
     "build": "sh build/build.sh",
     "release": "sh build/release.sh"
   },
@@ -27,6 +28,8 @@
   "devDependencies": {
     "@babel/cli": "^7.24.5",
     "@babel/core": "^7.24.5",
-    "@babel/preset-env": "^7.24.5"
+    "@babel/node": "^7.23.9",
+    "@babel/preset-env": "^7.24.5",
+    "nodemon": "^3.1.0"
   }
-}
+}