util-helpers 4.11.1 → 4.12.0

package/esm/index.js

@@ -53,6 +53,38 @@ export { default as padZero } from './padZero';
  * @since 3.1.0
  * @see 参考 {@link https://github.com/camsong/blog/issues/9|JavaScript 浮点数陷阱及解法}
  * @see 参考 {@link https://2zbuy.csb.app/|JS浮点数计算测试}
+ * @example
+ * // 从 4.12.0 版本开始，规范了有效数值参数校验。有效数值即数字或字符串类型，能通过 Number(value) 转为数字，且不为 NaN 、空字符串、空格字符串。
+ * 
+ * // 以下为有效数值：
+ * // 1. 数字: 1, -1, 1e-2, 1.312, 0.1, Infinity
+ * // 2. 数字字符串: '1', '10e2', '-1', '0.1'
+ * 
+ * // 以下为无效数值：
+ * // 1. 非数字的字符串: '', ' ', '1a', '-12a', '10.2.2', '10e2.1'
+ * // 2. 其他类型值: undefined, null, true, false, [], {}, new Date(), ...
+ * 
+ * // *注意：Number('') 、 Number(' ') 、 Number(new Date) 、 Number(true)等等是可以返回数字，但都不是有效数值。因为它们分别是空字符串、空格字符串和非数字或字符串类型。
+ * 
+ * 
+ * // 计算说明：
+ * // 1. 全部参数都是无效数值将返回 NaN 。
+ * plus(); // NaN
+ * plus(new Date()); // NaN
+ * plus(true, null); // NaN
+ * 
+ * // 2. 参数中包含有效数值和无效数值，将忽略无效数值。
+ * plus(0.1); // 0.1
+ * plus('0.1', ' ', true, ); // 0.1
+ * plus(true, 0.1); // 0.1
+ * plus(true, 0.1, 0.2); // 0.3
+ * plus('', 0.1, ' ', new Date(), 0.2); // 0.3
+ * plus(0.1, true, 0.2, null); // 0.3
+ * 
+ * // 3. 数字和数字字符串将正常的使用安全计算
+ * plus(0.1, 0.2); // 0.3
+ * plus(0.1, 0.2, 0.3); // 0.6
+ * 
  */
 
 export { default as plus } from './plus';

package/esm/minus.js

@@ -1,7 +1,6 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { digitLength } from './utils/math.util';
+import { digitLength, isEffectiveNumeric } from './utils/math.util';
 import times from './times';
-import { isNumber, isNaN, isString } from './utils/type';
 /**
  * 精确减法，支持多个数相减
  *
@@ -33,12 +32,13 @@ function minus() {
 
   if (rest.length > 0) {
     return minus.apply(void 0, [minus(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果第2个参数为非数字或字符串时，返回第一个参数
+  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
 
 
-  if ((!isNumber(num2) || isNaN(num2)) && !isString(num2)) {
-    // @ts-ignore
-    return num1;
+  if (!isEffectiveNumeric(num1)) {
+    return isEffectiveNumeric(num2) ? Number(num2) : NaN;
+  } else if (!isEffectiveNumeric(num2)) {
+    return Number(num1);
   }
 
   var baseNum = Math.pow(10, Math.max(digitLength(num1), digitLength(num2)));

package/esm/plus.js

@@ -1,7 +1,6 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { digitLength } from './utils/math.util';
+import { digitLength, isEffectiveNumeric } from './utils/math.util';
 import times from './times';
-import { isNumber, isNaN, isString } from './utils/type';
 /**
  * 精确加法，支持多个数相加
  *
@@ -33,12 +32,13 @@ function plus() {
 
   if (rest.length > 0) {
     return plus.apply(void 0, [plus(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果第2个参数为非数字或字符串时，返回第一个参数
+  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
 
 
-  if ((!isNumber(num2) || isNaN(num2)) && !isString(num2)) {
-    // @ts-ignore
-    return num1;
+  if (!isEffectiveNumeric(num1)) {
+    return isEffectiveNumeric(num2) ? Number(num2) : NaN;
+  } else if (!isEffectiveNumeric(num2)) {
+    return Number(num1);
   }
 
   var baseNum = Math.pow(10, Math.max(digitLength(num1), digitLength(num2)));

package/esm/round.js

@@ -1,6 +1,6 @@
 import divide from './divide';
 import times from './times';
-import { isNumber, isString, isNaN } from './utils/type';
+import { isEffectiveNumeric } from './utils/math.util';
 /**
  * 四舍五入，支持设置精度
  *
@@ -25,10 +25,9 @@ import { isNumber, isString, isNaN } from './utils/type';
 function round(num) {
   var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
 
-  // 兼容处理，如果参数为非数字或字符串时，直接返回
-  if ((!isNumber(num) || isNaN(num)) && !isString(num)) {
-    // @ts-ignore
-    return num;
+  // 兼容处理，如果参数包含无效数值时，返回第一个参数
+  if (!isEffectiveNumeric(num)) {
+    return NaN;
   }
 
   var base = Math.pow(10, precision);

package/esm/times.js

@@ -1,6 +1,5 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { digitLength, float2Fixed, checkBoundary } from './utils/math.util';
-import { isNumber, isNaN, isString } from './utils/type';
+import { digitLength, float2Fixed, checkBoundary, isEffectiveNumeric } from './utils/math.util';
 /**
  * 精确乘法，支持多个数相乘
  *
@@ -32,12 +31,13 @@ function times() {
 
   if (rest.length > 0) {
     return times.apply(void 0, [times(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果第2个参数为非数字或字符串时，返回第一个参数
+  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
 
 
-  if ((!isNumber(num2) || isNaN(num2)) && !isString(num2)) {
-    // @ts-ignore
-    return num1;
+  if (!isEffectiveNumeric(num1)) {
+    return isEffectiveNumeric(num2) ? Number(num2) : NaN;
+  } else if (!isEffectiveNumeric(num2)) {
+    return Number(num1);
   }
 
   var num1Changed = float2Fixed(num1);

package/esm/utils/math.util.js

@@ -6,6 +6,36 @@
  */
 import { MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from './constants';
 import devWarn from './devWarn';
+import { isNumber, isString } from './type';
+/**
+ * 值是否为有效的数值
+ * 
+ * @param {*} value 待检测的值
+ * @returns {boolean} 是否为有效的数值
+ */
+
+export function isEffectiveNumeric(value) {
+  if (isNumber(value) && !isNaN(value)) {
+    return true;
+  } // 避免空字符串 或 带空格的字符串
+
+
+  if (isString(value)) {
+    var fmtStrValue = value.trim(); // 带空格的字符串也不转换数字
+    // Number(' ') => 0
+
+    if (fmtStrValue === value) {
+      var numValue = fmtStrValue ? Number(fmtStrValue) : NaN;
+
+      if (isNumber(numValue) && !isNaN(numValue)) {
+        return true;
+      }
+    }
+  }
+
+  devWarn("".concat(value, " is not a valid number."));
+  return false;
+}
 /**
  * 是否为科学计数法数字
  *

package/lib/divide.js

@@ -9,8 +9,6 @@ var _math = require("./utils/math.util");
 
 var _times = _interopRequireDefault(require("./times"));
 
-var _type = require("./utils/type");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
@@ -55,12 +53,13 @@ function divide() {
 
   if (rest.length > 0) {
     return divide.apply(void 0, [divide(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果第2个参数为非数字或字符串时，返回第一个参数
+  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
 
 
-  if ((!(0, _type.isNumber)(num2) || (0, _type.isNaN)(num2)) && !(0, _type.isString)(num2)) {
-    // @ts-ignore
-    return num1;
+  if (!(0, _math.isEffectiveNumeric)(num1)) {
+    return (0, _math.isEffectiveNumeric)(num2) ? Number(num2) : NaN;
+  } else if (!(0, _math.isEffectiveNumeric)(num2)) {
+    return Number(num1);
   }
 
   var num1Changed = (0, _math.float2Fixed)(num1);

package/lib/minus.js

@@ -9,8 +9,6 @@ var _math = require("./utils/math.util");
 
 var _times = _interopRequireDefault(require("./times"));
 
-var _type = require("./utils/type");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
@@ -55,12 +53,13 @@ function minus() {
 
   if (rest.length > 0) {
     return minus.apply(void 0, [minus(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果第2个参数为非数字或字符串时，返回第一个参数
+  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
 
 
-  if ((!(0, _type.isNumber)(num2) || (0, _type.isNaN)(num2)) && !(0, _type.isString)(num2)) {
-    // @ts-ignore
-    return num1;
+  if (!(0, _math.isEffectiveNumeric)(num1)) {
+    return (0, _math.isEffectiveNumeric)(num2) ? Number(num2) : NaN;
+  } else if (!(0, _math.isEffectiveNumeric)(num2)) {
+    return Number(num1);
   }
 
   var baseNum = Math.pow(10, Math.max((0, _math.digitLength)(num1), (0, _math.digitLength)(num2)));

package/lib/plus.js

@@ -9,8 +9,6 @@ var _math = require("./utils/math.util");
 
 var _times = _interopRequireDefault(require("./times"));
 
-var _type = require("./utils/type");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
@@ -55,12 +53,13 @@ function plus() {
 
   if (rest.length > 0) {
     return plus.apply(void 0, [plus(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果第2个参数为非数字或字符串时，返回第一个参数
+  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
 
 
-  if ((!(0, _type.isNumber)(num2) || (0, _type.isNaN)(num2)) && !(0, _type.isString)(num2)) {
-    // @ts-ignore
-    return num1;
+  if (!(0, _math.isEffectiveNumeric)(num1)) {
+    return (0, _math.isEffectiveNumeric)(num2) ? Number(num2) : NaN;
+  } else if (!(0, _math.isEffectiveNumeric)(num2)) {
+    return Number(num1);
   }
 
   var baseNum = Math.pow(10, Math.max((0, _math.digitLength)(num1), (0, _math.digitLength)(num2)));

package/lib/round.js

@@ -9,7 +9,7 @@ var _divide = _interopRequireDefault(require("./divide"));
 
 var _times = _interopRequireDefault(require("./times"));
 
-var _type = require("./utils/type");
+var _math = require("./utils/math.util");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
@@ -36,10 +36,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "d
 function round(num) {
   var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
 
-  // 兼容处理，如果参数为非数字或字符串时，直接返回
-  if ((!(0, _type.isNumber)(num) || (0, _type.isNaN)(num)) && !(0, _type.isString)(num)) {
-    // @ts-ignore
-    return num;
+  // 兼容处理，如果参数包含无效数值时，返回第一个参数
+  if (!(0, _math.isEffectiveNumeric)(num)) {
+    return NaN;
   }
 
   var base = Math.pow(10, precision);

package/lib/times.js

@@ -7,8 +7,6 @@ exports["default"] = void 0;
 
 var _math = require("./utils/math.util");
 
-var _type = require("./utils/type");
-
 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."); }
@@ -51,12 +49,13 @@ function times() {
 
   if (rest.length > 0) {
     return times.apply(void 0, [times(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果第2个参数为非数字或字符串时，返回第一个参数
+  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
 
 
-  if ((!(0, _type.isNumber)(num2) || (0, _type.isNaN)(num2)) && !(0, _type.isString)(num2)) {
-    // @ts-ignore
-    return num1;
+  if (!(0, _math.isEffectiveNumeric)(num1)) {
+    return (0, _math.isEffectiveNumeric)(num2) ? Number(num2) : NaN;
+  } else if (!(0, _math.isEffectiveNumeric)(num2)) {
+    return Number(num1);
   }
 
   var num1Changed = (0, _math.float2Fixed)(num1);

package/lib/utils/math.util.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.isEffectiveNumeric = isEffectiveNumeric;
 exports.isScientificNumber = isScientificNumber;
 exports.strip = strip;
 exports.digitLength = digitLength;
@@ -15,6 +16,8 @@ var _constants = require("./constants");
 
 var _devWarn = _interopRequireDefault(require("./devWarn"));
 
+var _type = require("./type");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
 /**
@@ -24,12 +27,42 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "d
  * 问题示例：2.3 + 2.4 = 4.699999999999999，1.0 - 0.9 = 0.09999999999999998
  */
 
+/**
+ * 值是否为有效的数值
+ * 
+ * @param {*} value 待检测的值
+ * @returns {boolean} 是否为有效的数值
+ */
+function isEffectiveNumeric(value) {
+  if ((0, _type.isNumber)(value) && !isNaN(value)) {
+    return true;
+  } // 避免空字符串 或 带空格的字符串
+
+
+  if ((0, _type.isString)(value)) {
+    var fmtStrValue = value.trim(); // 带空格的字符串也不转换数字
+    // Number(' ') => 0
+
+    if (fmtStrValue === value) {
+      var numValue = fmtStrValue ? Number(fmtStrValue) : NaN;
+
+      if ((0, _type.isNumber)(numValue) && !isNaN(numValue)) {
+        return true;
+      }
+    }
+  }
+
+  (0, _devWarn["default"])("".concat(value, " is not a valid number."));
+  return false;
+}
 /**
  * 是否为科学计数法数字
  *
  * @param {string} num 检查值
  * @returns {boolean}
  */
+
+
 function isScientificNumber(num) {
   return /\d+\.?\d*e[\+\-]*\d+/i.test(num);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "util-helpers",
-  "version": "4.11.1",
+  "version": "4.12.0",
   "description": "一个基于业务场景的工具方法库",
   "main": "lib/index.js",
   "module": "esm/index.js",

package/types/utils/math.util.d.ts

@@ -1,3 +1,10 @@
+/**
+ * 值是否为有效的数值
+ *
+ * @param {*} value 待检测的值
+ * @returns {boolean} 是否为有效的数值
+ */
+export function isEffectiveNumeric(value: any): boolean;
 /**
  * 是否为科学计数法数字
  *