util-helpers 4.11.1 → 4.12.2

package/dist/util-helpers.js

@@ -562,6 +562,8 @@
     return lastCode === checkCode;
   }
 
+  const version = "4.12.2";
+
   var config = {
     // 禁用warning提示
     disableWarning: true
@@ -1575,12 +1577,92 @@
 
   var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER || -9007199254740991;
 
+  /**
+   * 检查值是否为NaN
+   *
+   * @static
+   * @alias module:Type.isNaN
+   * @since 1.1.0
+   * @param {*} value 检查值
+   * @returns {boolean} 是否为NaN
+   * @example
+   *
+   * isNaN(NaN)
+   * // => true
+   *
+   * isNaN(1)
+   * // => false
+   */
+
+  function _isNaN(value) {
+    return isType(value, 'Number') && isNaN(value);
+  }
+
+  /**
+   * 检查值是否为Number
+   *
+   * @static
+   * @alias module:Type.isNumber
+   * @since 1.1.0
+   * @param {*} value 检查值
+   * @returns {boolean} 是否为Number
+   * @example
+   *
+   * isNumber(1)
+   * // => true
+   *
+   * isNumber(Number.MIN_VALUE)
+   * // => true
+   *
+   * isNumber(Infinity)
+   * // => true
+   *
+   * isNumber(NaN)
+   * // => true
+   *
+   * isNumber('1')
+   * // => false
+   */
+
+  function isNumber(value) {
+    return isType(value, 'Number');
+  }
+
   /**
    * 参考: https://github.com/nefe/number-precision/blob/master/src/index.ts
    *
    * 解决浮动运算问题，避免小数点后产生多位数和计算精度损失。
    * 问题示例：2.3 + 2.4 = 4.699999999999999，1.0 - 0.9 = 0.09999999999999998
    */
+  /**
+   * 值是否为有效的数值
+   * 
+   * @param {*} value 待检测的值
+   * @returns {boolean} 是否为有效的数值
+   */
+
+  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 (!isNaN(numValue)) {
+          return true;
+        }
+      }
+    }
+
+    devWarn("".concat(value, " is not a valid number."));
+    return false;
+  }
   /**
    * 是否为科学计数法数字
    *
@@ -1734,27 +1816,6 @@
     return trimLeftZero(ret);
   }
 
-  /**
-   * 检查值是否为NaN
-   *
-   * @static
-   * @alias module:Type.isNaN
-   * @since 1.1.0
-   * @param {*} value 检查值
-   * @returns {boolean} 是否为NaN
-   * @example
-   *
-   * isNaN(NaN)
-   * // => true
-   *
-   * isNaN(1)
-   * // => false
-   */
-
-  function _isNaN(value) {
-    return isType(value, 'Number') && isNaN(value);
-  }
-
   var reg = /^[+-]?\d*\.?\d*$/;
   /**
    * 检查数字或数字字符串
@@ -2674,36 +2735,6 @@
     return str;
   }
 
-  /**
-   * 检查值是否为Number
-   *
-   * @static
-   * @alias module:Type.isNumber
-   * @since 1.1.0
-   * @param {*} value 检查值
-   * @returns {boolean} 是否为Number
-   * @example
-   *
-   * isNumber(1)
-   * // => true
-   *
-   * isNumber(Number.MIN_VALUE)
-   * // => true
-   *
-   * isNumber(Infinity)
-   * // => true
-   *
-   * isNumber(NaN)
-   * // => true
-   *
-   * isNumber('1')
-   * // => false
-   */
-
-  function isNumber(value) {
-    return isType(value, 'Number');
-  }
-
   /**
    * 精确乘法，支持多个数相乘
    *
@@ -2735,12 +2766,13 @@
 
     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);
@@ -2782,12 +2814,13 @@
 
     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)));
@@ -2825,12 +2858,13 @@
 
     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)));
@@ -2868,12 +2902,13 @@
 
     if (rest.length > 0) {
       return divide.apply(void 0, [divide(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);
@@ -2908,10 +2943,9 @@
   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);
@@ -3133,6 +3167,7 @@
   exports.strlen = strlen;
   exports.times = times;
   exports.validatePassword = validatePassword;
+  exports.version = version;
   exports.waitTime = waitTime;
 
   Object.defineProperty(exports, '__esModule', { value: true });