util-helpers 4.12.2 → 4.12.3

package/esm/divide.js

@@ -1,24 +1,24 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { strip, digitLength, float2Fixed, checkBoundary, isEffectiveNumeric } from './utils/math.util';
+import { strip, digitLength, float2Fixed, checkBoundary, transformEffectiveNumber } from './utils/math.util';
 import times from './times';
 /**
- * 精确除法，支持多个数相除
+ * 精确除法，支持多个数相除，除数默认为 1 。
  *
  * @static
  * @alias module:Math.divide
  * @since 3.1.0
- * @param {...number|string} nums 除数和被除数
+ * @param {...number|string} nums 被除数和除数
  * @returns {number} 商数
  * @example
  *
- * divide(1.21, 1.1);
- * // => 1.1
- *
- * divide(1000, 10, 10);
- * // => 10
- *
- * divide(1000, 10, 10, 10);
- * // => 1
+ * divide(1.21); // 1.21 除数默认为 1 ，即 1.21/1 = 1.21
+ * divide(1.21, 1.1); // 1.1
+ * divide(1000, 10, 10); // 10
+ * divide(1000, 10, 10, 10); // 1
+ * 
+ * divide(); // NaN  如果没有传入参数，被除数默认为 undefined 。 Number(undefined) 转换为 NaN ，NaN/1 = NaN
+ * divide(null); // 0  Number(null) 转换为 0 ， 0/1 = 0
+ * divide('1.5 ', 0.5); // 3  Number('1.5 ') 转换为 1.5 ，1.5/0.5 = 3
  */
 
 function divide() {
@@ -27,18 +27,20 @@ function divide() {
   }
 
   var num1 = nums[0],
-      num2 = nums[1],
+      _nums$ = nums[1],
+      num2 = _nums$ === void 0 ? 1 : _nums$,
       rest = nums.slice(2);
 
   if (rest.length > 0) {
     return divide.apply(void 0, [divide(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
+  }
 
+  num1 = transformEffectiveNumber(num1);
+  num2 = transformEffectiveNumber(num2); // 兼容处理，如果参数包含无效数值时，返回 NaN
+  // @ts-ignore
 
-  if (!isEffectiveNumeric(num1)) {
-    return isEffectiveNumeric(num2) ? Number(num2) : NaN;
-  } else if (!isEffectiveNumeric(num2)) {
-    return Number(num1);
+  if (isNaN(num1) || isNaN(num2)) {
+    return Number.NaN;
   }
 
   var num1Changed = float2Fixed(num1);

package/esm/index.js

@@ -54,38 +54,35 @@ export { default as padZero } from './padZero';
  * @see 参考 {@link https://github.com/camsong/blog/issues/9|JavaScript 浮点数陷阱及解法}
  * @see 参考 {@link https://2zbuy.csb.app/|JS浮点数计算测试}
  * @example
- * // 从 4.12.0 版本开始，规范了有效数值参数校验。
- * // 有效数值即数字或字符串类型，字符串不能为空或空白符，能通过 Number(value) 转为数字，且不能为 NaN 。
+ * // 从 4.12.0 版本开始，规范了有效数值。（注意：4.12.3 对有效数值重新定义）
+ * // 有效数值即能通过 Number(value) 转为数字，且不能为 NaN 。
  * 
  * // 以下为有效数值：
  * // 1. 数字: 1, -1, 1e-2, 1.312, 0.1, Infinity
- * // 2. 数字字符串: '1', '10e2', '-1', '0.1'
+ * // 2. 字符串: '1', '10e2', '-1', '0.1', '', ' ', '  15', ' 15   '
+ * // 4. 其他类型: null, new Date(), [], new Array(), true, false,...
  * 
  * // 以下为无效数值：
- * // 1. 非数字的字符串: '', ' ', '1a', '-12a', '10.2.2', '10e2.1'
- * // 2. 其他类型值: undefined, null, true, false, [], {}, new Date(), ...
- * 
- * // 注意：Number('') 、 Number(' ') 、 Number(new Date) 、 Number(true)等虽然可以返回数字，但都不是有效数值。
- * // 因为它们分别是空字符串、空格字符串和非数字或字符串类型。
- * 
+ * // 1. 字符串: '1a', '-12a', '10.2.2', '10e2.1'
+ * // 2. 其他类型: undefined, [], {}, Symbol(), function(){}, ()=>{}
  * 
  * // 计算说明：
- * // 1. 全部参数都是无效数值将返回 NaN 。
- * plus(); // NaN
- * plus(new Date()); // NaN
- * plus(true, null); // NaN
+ * // 四则运算的第二个参数都是有默认值（乘数和除数默认1，加数和减数默认0）
+ * plus(); // NaN  0个参数时，被加数转换为 Number(undefined) NaN ，NaN+0 = NaN 。其他计算方法如果没有参数一样返回 NaN 。
+ * plus(0.1); // 0.1  第二个参数，加数默认为 0
+ * plus(undefined, 0.1); // NaN  第一个参数被加数转换为 Number(undefined) NaN ，NaN+0 = NaN 。其他计算方法如果第一个参数为无效数值一样返回 NaN 。
+ * plus(true, null); // 1  Number(true) 转换为 1 ， Number(null) 转换为 0 ， 1+0=1
  * 
- * // 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
+ * // 2. 参数中包含无效数值，返回NaN
+ * plus('0.1', ' a'); // NaN
+ * plus(true, {}); // NaN
+ * plus(true, 0.1, Symbol()); // NaN
  * 
- * // 3. 数字和数字字符串将正常的使用安全计算
- * plus(0.1, 0.2); // 0.3
- * plus(0.1, 0.2, 0.3); // 0.6
+ * // 注意：
+ * // 如果第二个及后面的参数如果值为 undefined 取默认值，即乘除数取 1 ，加减法取 0 。
+ * plus(0.1, undefined); // 0.1  
+ * plus(0.1, undefined, 0.2, undefined); // 0.3  后面的 undefined 取默认值 0
+ * times(0.1, undefined, 0.2, undefined); // 0.02  后面的 undefined 取默认值 1
  * 
  */
 

package/esm/minus.js

@@ -1,8 +1,8 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { digitLength, isEffectiveNumeric } from './utils/math.util';
+import { digitLength, transformEffectiveNumber } from './utils/math.util';
 import times from './times';
 /**
- * 精确减法，支持多个数相减
+ * 精确减法，支持多个数相减，减数默认为 0 。
  *
  * @static
  * @alias module:Math.minus
@@ -27,18 +27,20 @@ function minus() {
   }
 
   var num1 = nums[0],
-      num2 = nums[1],
+      _nums$ = nums[1],
+      num2 = _nums$ === void 0 ? 0 : _nums$,
       rest = nums.slice(2);
 
   if (rest.length > 0) {
     return minus.apply(void 0, [minus(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
+  }
 
+  num1 = transformEffectiveNumber(num1);
+  num2 = transformEffectiveNumber(num2); // 兼容处理，如果参数包含无效数值时，返回 NaN
+  // @ts-ignore
 
-  if (!isEffectiveNumeric(num1)) {
-    return isEffectiveNumeric(num2) ? Number(num2) : NaN;
-  } else if (!isEffectiveNumeric(num2)) {
-    return Number(num1);
+  if (isNaN(num1) || isNaN(num2)) {
+    return Number.NaN;
   }
 
   var baseNum = Math.pow(10, Math.max(digitLength(num1), digitLength(num2)));

package/esm/plus.js

@@ -1,8 +1,8 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { digitLength, isEffectiveNumeric } from './utils/math.util';
+import { digitLength, transformEffectiveNumber } from './utils/math.util';
 import times from './times';
 /**
- * 精确加法，支持多个数相加
+ * 精确加法，支持多个数相加，加数默认为 0 。
  *
  * @static
  * @alias module:Math.plus
@@ -27,18 +27,20 @@ function plus() {
   }
 
   var num1 = nums[0],
-      num2 = nums[1],
+      _nums$ = nums[1],
+      num2 = _nums$ === void 0 ? 0 : _nums$,
       rest = nums.slice(2);
 
   if (rest.length > 0) {
     return plus.apply(void 0, [plus(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
+  }
 
+  num1 = transformEffectiveNumber(num1);
+  num2 = transformEffectiveNumber(num2); // 兼容处理，如果参数包含无效数值时，返回 NaN
+  // @ts-ignore
 
-  if (!isEffectiveNumeric(num1)) {
-    return isEffectiveNumeric(num2) ? Number(num2) : NaN;
-  } else if (!isEffectiveNumeric(num2)) {
-    return Number(num1);
+  if (isNaN(num1) || isNaN(num2)) {
+    return Number.NaN;
   }
 
   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 { isEffectiveNumeric } from './utils/math.util';
+import { transformEffectiveNumber } from './utils/math.util';
 /**
  * 四舍五入，支持设置精度
  *
@@ -24,10 +24,11 @@ import { isEffectiveNumeric } from './utils/math.util';
 
 function round(num) {
   var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  num = transformEffectiveNumber(num); // 兼容处理，如果参数包含无效数值时，返回 NaN
+  // @ts-ignore
 
-  // 兼容处理，如果参数包含无效数值时，返回第一个参数
-  if (!isEffectiveNumeric(num)) {
-    return NaN;
+  if (isNaN(num)) {
+    return Number.NaN;
   }
 
   var base = Math.pow(10, precision);

package/esm/times.js

@@ -1,7 +1,7 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { digitLength, float2Fixed, checkBoundary, isEffectiveNumeric } from './utils/math.util';
+import { digitLength, float2Fixed, checkBoundary, transformEffectiveNumber } from './utils/math.util';
 /**
- * 精确乘法，支持多个数相乘
+ * 精确乘法，支持多个数相乘，乘数默认为 1 。
  *
  * @static
  * @alias module:Math.times
@@ -26,18 +26,20 @@ function times() {
   }
 
   var num1 = nums[0],
-      num2 = nums[1],
+      _nums$ = nums[1],
+      num2 = _nums$ === void 0 ? 1 : _nums$,
       rest = nums.slice(2);
 
   if (rest.length > 0) {
     return times.apply(void 0, [times(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
+  }
 
+  num1 = transformEffectiveNumber(num1);
+  num2 = transformEffectiveNumber(num2); // 兼容处理，如果参数包含无效数值时，返回 NaN
+  // @ts-ignore
 
-  if (!isEffectiveNumeric(num1)) {
-    return isEffectiveNumeric(num2) ? Number(num2) : NaN;
-  } else if (!isEffectiveNumeric(num2)) {
-    return Number(num1);
+  if (isNaN(num1) || isNaN(num2)) {
+    return Number.NaN;
   }
 
   var num1Changed = float2Fixed(num1);

package/esm/utils/config.js

@@ -1,4 +1,4 @@
-var version = "4.12.2";
+var version = "4.12.3";
 var config = {
   // 禁用warning提示
   disableWarning: true

package/esm/utils/math.util.js

@@ -6,15 +6,18 @@
  */
 import { MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from './constants';
 import devWarn from './devWarn';
-import { isNumber, isString } from './type';
+import { isNumber, isString, isSymbol } from './type';
 /**
  * 值是否为有效的数值
  * 
+ * @deprecated 已废弃
  * @param {*} value 待检测的值
  * @returns {boolean} 是否为有效的数值
  */
 
-export function isEffectiveNumeric(value) {
+export function isEffectiveNumeric() {
+  var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
   if (isNumber(value) && !isNaN(value)) {
     return true;
   } // 避免空字符串 或 带空格的字符串
@@ -36,6 +39,50 @@ export function isEffectiveNumeric(value) {
   devWarn("".concat(value, " is not a valid number."));
   return false;
 }
+/**
+ * 将值转换为有效数值
+ * 
+ * @param {*} value 要转换的值
+ * @returns {number|string} 有效数值
+ */
+
+export function transformEffectiveNumber(value) {
+  /** @type {string|number|undefined} */
+  var ret;
+
+  if (isString(value)) {
+    ret = value.trim(); // ' 15'  ' 15  ' 兼容 Number(string) 处理
+
+    if (ret === '') {
+      ret = Number(ret);
+    } else if (Number.isNaN(Number(ret))) {
+      // string如果可以转换为number，默认不转换为number类型
+      ret = Number.NaN;
+    }
+  } else if (isSymbol(value)) {
+    ret = Number.NaN;
+  } else if (!isNumber(value)) {
+    // 其余非数字类型通过 Number 转换
+    // 例如 Symbol 包装器对象将会报错
+    // symObj = Object(Symbol());
+    // Number(symObj); // TypeError: Cannot convert a Symbol value to a number
+    try {
+      ret = Number(value);
+    } catch (err) {
+      ret = Number.NaN;
+      console.error(err);
+    }
+  } else {
+    ret = value;
+  }
+
+  if (Number.isNaN(ret)) {
+    return Number.NaN;
+  } // @ts-ignore
+
+
+  return ret;
+}
 /**
  * 是否为科学计数法数字
  *

package/lib/divide.js

@@ -24,23 +24,23 @@ function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToAr
 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; }
 
 /**
- * 精确除法，支持多个数相除
+ * 精确除法，支持多个数相除，除数默认为 1 。
  *
  * @static
  * @alias module:Math.divide
  * @since 3.1.0
- * @param {...number|string} nums 除数和被除数
+ * @param {...number|string} nums 被除数和除数
  * @returns {number} 商数
  * @example
  *
- * divide(1.21, 1.1);
- * // => 1.1
- *
- * divide(1000, 10, 10);
- * // => 10
- *
- * divide(1000, 10, 10, 10);
- * // => 1
+ * divide(1.21); // 1.21 除数默认为 1 ，即 1.21/1 = 1.21
+ * divide(1.21, 1.1); // 1.1
+ * divide(1000, 10, 10); // 10
+ * divide(1000, 10, 10, 10); // 1
+ * 
+ * divide(); // NaN  如果没有传入参数，被除数默认为 undefined 。 Number(undefined) 转换为 NaN ，NaN/1 = NaN
+ * divide(null); // 0  Number(null) 转换为 0 ， 0/1 = 0
+ * divide('1.5 ', 0.5); // 3  Number('1.5 ') 转换为 1.5 ，1.5/0.5 = 3
  */
 function divide() {
   for (var _len = arguments.length, nums = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -48,18 +48,20 @@ function divide() {
   }
 
   var num1 = nums[0],
-      num2 = nums[1],
+      _nums$ = nums[1],
+      num2 = _nums$ === void 0 ? 1 : _nums$,
       rest = nums.slice(2);
 
   if (rest.length > 0) {
     return divide.apply(void 0, [divide(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
+  }
 
+  num1 = (0, _math.transformEffectiveNumber)(num1);
+  num2 = (0, _math.transformEffectiveNumber)(num2); // 兼容处理，如果参数包含无效数值时，返回 NaN
+  // @ts-ignore
 
-  if (!(0, _math.isEffectiveNumeric)(num1)) {
-    return (0, _math.isEffectiveNumeric)(num2) ? Number(num2) : NaN;
-  } else if (!(0, _math.isEffectiveNumeric)(num2)) {
-    return Number(num1);
+  if (isNaN(num1) || isNaN(num2)) {
+    return Number.NaN;
   }
 
   var num1Changed = (0, _math.float2Fixed)(num1);

package/lib/minus.js

@@ -24,7 +24,7 @@ function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToAr
 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; }
 
 /**
- * 精确减法，支持多个数相减
+ * 精确减法，支持多个数相减，减数默认为 0 。
  *
  * @static
  * @alias module:Math.minus
@@ -48,18 +48,20 @@ function minus() {
   }
 
   var num1 = nums[0],
-      num2 = nums[1],
+      _nums$ = nums[1],
+      num2 = _nums$ === void 0 ? 0 : _nums$,
       rest = nums.slice(2);
 
   if (rest.length > 0) {
     return minus.apply(void 0, [minus(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
+  }
 
+  num1 = (0, _math.transformEffectiveNumber)(num1);
+  num2 = (0, _math.transformEffectiveNumber)(num2); // 兼容处理，如果参数包含无效数值时，返回 NaN
+  // @ts-ignore
 
-  if (!(0, _math.isEffectiveNumeric)(num1)) {
-    return (0, _math.isEffectiveNumeric)(num2) ? Number(num2) : NaN;
-  } else if (!(0, _math.isEffectiveNumeric)(num2)) {
-    return Number(num1);
+  if (isNaN(num1) || isNaN(num2)) {
+    return Number.NaN;
   }
 
   var baseNum = Math.pow(10, Math.max((0, _math.digitLength)(num1), (0, _math.digitLength)(num2)));

package/lib/plus.js

@@ -24,7 +24,7 @@ function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToAr
 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; }
 
 /**
- * 精确加法，支持多个数相加
+ * 精确加法，支持多个数相加，加数默认为 0 。
  *
  * @static
  * @alias module:Math.plus
@@ -48,18 +48,20 @@ function plus() {
   }
 
   var num1 = nums[0],
-      num2 = nums[1],
+      _nums$ = nums[1],
+      num2 = _nums$ === void 0 ? 0 : _nums$,
       rest = nums.slice(2);
 
   if (rest.length > 0) {
     return plus.apply(void 0, [plus(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
+  }
 
+  num1 = (0, _math.transformEffectiveNumber)(num1);
+  num2 = (0, _math.transformEffectiveNumber)(num2); // 兼容处理，如果参数包含无效数值时，返回 NaN
+  // @ts-ignore
 
-  if (!(0, _math.isEffectiveNumeric)(num1)) {
-    return (0, _math.isEffectiveNumeric)(num2) ? Number(num2) : NaN;
-  } else if (!(0, _math.isEffectiveNumeric)(num2)) {
-    return Number(num1);
+  if (isNaN(num1) || isNaN(num2)) {
+    return Number.NaN;
   }
 
   var baseNum = Math.pow(10, Math.max((0, _math.digitLength)(num1), (0, _math.digitLength)(num2)));

package/lib/round.js

@@ -35,10 +35,11 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "d
  */
 function round(num) {
   var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  num = (0, _math.transformEffectiveNumber)(num); // 兼容处理，如果参数包含无效数值时，返回 NaN
+  // @ts-ignore
 
-  // 兼容处理，如果参数包含无效数值时，返回第一个参数
-  if (!(0, _math.isEffectiveNumeric)(num)) {
-    return NaN;
+  if (isNaN(num)) {
+    return Number.NaN;
   }
 
   var base = Math.pow(10, precision);

package/lib/times.js

@@ -20,7 +20,7 @@ function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToAr
 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; }
 
 /**
- * 精确乘法，支持多个数相乘
+ * 精确乘法，支持多个数相乘，乘数默认为 1 。
  *
  * @static
  * @alias module:Math.times
@@ -44,18 +44,20 @@ function times() {
   }
 
   var num1 = nums[0],
-      num2 = nums[1],
+      _nums$ = nums[1],
+      num2 = _nums$ === void 0 ? 1 : _nums$,
       rest = nums.slice(2);
 
   if (rest.length > 0) {
     return times.apply(void 0, [times(num1, num2)].concat(_toConsumableArray(rest)));
-  } // 兼容处理，如果参数包含无效数值时，尝试取出有效数值参数
+  }
 
+  num1 = (0, _math.transformEffectiveNumber)(num1);
+  num2 = (0, _math.transformEffectiveNumber)(num2); // 兼容处理，如果参数包含无效数值时，返回 NaN
+  // @ts-ignore
 
-  if (!(0, _math.isEffectiveNumeric)(num1)) {
-    return (0, _math.isEffectiveNumeric)(num2) ? Number(num2) : NaN;
-  } else if (!(0, _math.isEffectiveNumeric)(num2)) {
-    return Number(num1);
+  if (isNaN(num1) || isNaN(num2)) {
+    return Number.NaN;
   }
 
   var num1Changed = (0, _math.float2Fixed)(num1);

package/lib/utils/config.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.setDisableWarning = setDisableWarning;
 exports.version = exports.config = void 0;
-var version = "4.12.2";
+var version = "4.12.3";
 exports.version = version;
 var config = {
   // 禁用warning提示

package/lib/utils/math.util.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.isEffectiveNumeric = isEffectiveNumeric;
+exports.transformEffectiveNumber = transformEffectiveNumber;
 exports.isScientificNumber = isScientificNumber;
 exports.strip = strip;
 exports.digitLength = digitLength;
@@ -30,10 +31,13 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "d
 /**
  * 值是否为有效的数值
  * 
+ * @deprecated 已废弃
  * @param {*} value 待检测的值
  * @returns {boolean} 是否为有效的数值
  */
-function isEffectiveNumeric(value) {
+function isEffectiveNumeric() {
+  var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
   if ((0, _type.isNumber)(value) && !isNaN(value)) {
     return true;
   } // 避免空字符串 或 带空格的字符串
@@ -55,6 +59,51 @@ function isEffectiveNumeric(value) {
   (0, _devWarn["default"])("".concat(value, " is not a valid number."));
   return false;
 }
+/**
+ * 将值转换为有效数值
+ * 
+ * @param {*} value 要转换的值
+ * @returns {number|string} 有效数值
+ */
+
+
+function transformEffectiveNumber(value) {
+  /** @type {string|number|undefined} */
+  var ret;
+
+  if ((0, _type.isString)(value)) {
+    ret = value.trim(); // ' 15'  ' 15  ' 兼容 Number(string) 处理
+
+    if (ret === '') {
+      ret = Number(ret);
+    } else if (Number.isNaN(Number(ret))) {
+      // string如果可以转换为number，默认不转换为number类型
+      ret = Number.NaN;
+    }
+  } else if ((0, _type.isSymbol)(value)) {
+    ret = Number.NaN;
+  } else if (!(0, _type.isNumber)(value)) {
+    // 其余非数字类型通过 Number 转换
+    // 例如 Symbol 包装器对象将会报错
+    // symObj = Object(Symbol());
+    // Number(symObj); // TypeError: Cannot convert a Symbol value to a number
+    try {
+      ret = Number(value);
+    } catch (err) {
+      ret = Number.NaN;
+      console.error(err);
+    }
+  } else {
+    ret = value;
+  }
+
+  if (Number.isNaN(ret)) {
+    return Number.NaN;
+  } // @ts-ignore
+
+
+  return ret;
+}
 /**
  * 是否为科学计数法数字
  *

package/package.json

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

package/types/src/divide.d.ts

@@ -1,21 +1,21 @@
 export default divide;
 /**
- * 精确除法，支持多个数相除
+ * 精确除法，支持多个数相除，除数默认为 1 。
  *
  * @static
  * @alias module:Math.divide
  * @since 3.1.0
- * @param {...number|string} nums 除数和被除数
+ * @param {...number|string} nums 被除数和除数
  * @returns {number} 商数
  * @example
  *
- * divide(1.21, 1.1);
- * // => 1.1
+ * divide(1.21); // 1.21 除数默认为 1 ，即 1.21/1 = 1.21
+ * divide(1.21, 1.1); // 1.1
+ * divide(1000, 10, 10); // 10
+ * divide(1000, 10, 10, 10); // 1
  *
- * divide(1000, 10, 10);
- * // => 10
- *
- * divide(1000, 10, 10, 10);
- * // => 1
+ * divide(); // NaN  如果没有传入参数，被除数默认为 undefined 。 Number(undefined) 转换为 NaN ，NaN/1 = NaN
+ * divide(null); // 0  Number(null) 转换为 0 ， 0/1 = 0
+ * divide('1.5 ', 0.5); // 3  Number('1.5 ') 转换为 1.5 ，1.5/0.5 = 3
  */
 declare function divide(...nums: (number | string)[]): number;

package/types/src/minus.d.ts

@@ -1,6 +1,6 @@
 export default minus;
 /**
- * 精确减法，支持多个数相减
+ * 精确减法，支持多个数相减，减数默认为 0 。
  *
  * @static
  * @alias module:Math.minus