util-helpers 4.12.2 → 4.12.3

package/dist/util-helpers.js

@@ -562,7 +562,7 @@
     return lastCode === checkCode;
   }
 
-  const version = "4.12.2";
+  const version = "4.12.3";
 
   var config = {
     // 禁用warning提示
@@ -1628,6 +1628,27 @@
     return isType(value, 'Number');
   }
 
+  /**
+   * 检查值是否为Symbol
+   *
+   * @static
+   * @alias module:Type.isSymbol
+   * @since 1.1.0
+   * @param {*} value 检查值
+   * @returns {boolean} 是否为Symbol
+   * @example
+   *
+   * isSymbol(Symbol.iterator)
+   * // => true
+   *
+   * isSymbol("abc")
+   * // => false
+   */
+
+  function isSymbol(value) {
+    return isType(value, 'Symbol');
+  }
+
   /**
    * 参考: https://github.com/nefe/number-precision/blob/master/src/index.ts
    *
@@ -1635,33 +1656,48 @@
    * 问题示例：2.3 + 2.4 = 4.699999999999999，1.0 - 0.9 = 0.09999999999999998
    */
   /**
-   * 值是否为有效的数值
+   * 将值转换为有效数值
    * 
-   * @param {*} value 待检测的值
-   * @returns {boolean} 是否为有效的数值
+   * @param {*} value 要转换的值
+   * @returns {number|string} 有效数值
    */
 
-  function isEffectiveNumeric(value) {
-    if (isNumber(value) && !isNaN(value)) {
-      return true;
-    } // 避免空字符串 或 带空格的字符串
-
+  function transformEffectiveNumber(value) {
+    /** @type {string|number|undefined} */
+    var ret;
 
     if (isString(value)) {
-      var fmtStrValue = value.trim(); // 带空格的字符串也不转换数字
-      // Number(' ') => 0
-
-      if (fmtStrValue === value) {
-        var numValue = fmtStrValue ? Number(fmtStrValue) : NaN;
+      ret = value.trim(); // ' 15'  ' 15  ' 兼容 Number(string) 处理
 
-        if (!isNaN(numValue)) {
-          return true;
-        }
+      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;
     }
 
-    devWarn("".concat(value, " is not a valid number."));
-    return false;
+    if (Number.isNaN(ret)) {
+      return Number.NaN;
+    } // @ts-ignore
+
+
+    return ret;
   }
   /**
    * 是否为科学计数法数字
@@ -2736,7 +2772,7 @@
   }
 
   /**
-   * 精确乘法，支持多个数相乘
+   * 精确乘法，支持多个数相乘，乘数默认为 1 。
    *
    * @static
    * @alias module:Math.times
@@ -2761,18 +2797,20 @@
     }
 
     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);
@@ -2784,7 +2822,7 @@
   }
 
   /**
-   * 精确加法，支持多个数相加
+   * 精确加法，支持多个数相加，加数默认为 0 。
    *
    * @static
    * @alias module:Math.plus
@@ -2809,18 +2847,20 @@
     }
 
     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)));
@@ -2828,7 +2868,7 @@
   }
 
   /**
-   * 精确减法，支持多个数相减
+   * 精确减法，支持多个数相减，减数默认为 0 。
    *
    * @static
    * @alias module:Math.minus
@@ -2853,18 +2893,20 @@
     }
 
     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)));
@@ -2872,23 +2914,23 @@
   }
 
   /**
-   * 精确除法，支持多个数相除
+   * 精确除法，支持多个数相除，除数默认为 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() {
@@ -2897,18 +2939,20 @@
     }
 
     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);
@@ -2942,10 +2986,11 @@
 
   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);