Number类型

ゞ浴缸里的玫瑰 2022-11-30 15:58 192阅读 0赞

# Number数字类型 #

### **`1、Number` 对象由 `Number()` 构造器创建。** ###

JavaScript的`Number`类型为[双精度IEEE 754 64位浮点][IEEE 754 64]类型。最近出了stage3[`BigInt`][BigInt] 任意精度数字类型，已经进入stage3规范。

### **2、关于Number对象和Number字面量的区别：** ###

new Number(value); 
    var a = new Number('123'); // a === 123 is false
    var b = Number('123'); // b === 123 is true
    a instanceof Number; // is true
    b instanceof Number; // is false

### **3、Number()方法** ###

可以将参数转为数字，如果参数无法被转换为数字，则返回 [`NaN`][NaN]。

console.log(Number("3.14")) //3.14  
    console.log(Number(true))    //1
    console.log(Number(""))     //0
    console.log(Number(null))   //0
    console.log(Number([]))  //0
    Number('0x11')    // 17
    Number('0b11')    // 3
    Number('0o11')    // 9
    console.log(Number(undefined)) //NaN
    console.log(Number("3.14a")) //NaN
    console.log(Number({}))  //NaN

### 相关方法： ###

**（1）valueOf()**

返回一个 Number 对象的基本数字值。

var num = new Number(123);
    console.log(num, num.valueOf());

![20200901113607258.png][]

**（2）toString()**

2 ~ 36 之间的整数，省略该参数，则使用基数 10

指定数字转换为指定进制的数字字符串。

console.log((3).toString(2));//"11"

**（3）tofixed()**

规定数字保留几位小数，参数介于 0 到 20 （包括）之间，不传参数时为0，默认保留整数，该数值在必要时进行四舍五入，另外在必要时会用 0 来填充小数部分，以便小数部分有指定的位数。

浮点数不能精确地用二进制表示所有小数。这可能会导致意外的结果，例如 `0.1 + 0.2 === 0.3` 返回 `false` .

![20200901140151638.png][]

0.55 1.55 2.55 3.55 4.55等，实际存储的值要小一点。

![20200901140058800.png][]

console.log((3.245).toFixed(2));//3.25 
    console.log((3).toFixed(2));//3.00

**（4） toPrecision()**

保留数字的长度，也会进行四舍五入。该参数是 1 ~ 21 之间（且包括 1 和 21）的值

var num = new Number(13.3714);
    var a = num.toPrecision();  13.3714
    var b = num.toPrecision(2);  13
    var c = num.toPrecision(3);  13.4
    var d = num.toPrecision(10);  13.37140000

**（5）toExponential()**

转为科学计数法，且保留几位小数。是 0 ~ 20 之间的值，包括 0 和 20。

科学计数法的值，保留两位小数！

console.log((123.456789).toExponential(2));//1.23e+2

### [内置Math对象的几个常用方法 ][Math] ###

### **4、静态属性** ###

英文integer：整数

`整数的范围：-2^53`到`2^53`之间（不含两个端点）

**（1）最大安全数和最小安全数**

**`Number.MAX_SAFE_INTEGER`** 常量表示在 JavaScript 中最大的安全整数（maxinum safe integer)（`2^53 - 1）。`

MAX\_SAFE\_INTEGER 是一个值为 9007199254740991的常量。这里安全存储的意思是指能够准确区分两个不相同的值。

例如 `Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 将得到 true的结果，而这在数学上是错误的。`

可以通过Math对象的pow方法，计算（`2^53 - 1）`

console.log(Math.pow(2, 53) - 1 )  //9007199254740991

**`Number.MIN_SAFE_INTEGER`** 代表在 JavaScript中最小的安全的integer型数字 (`-(2^53 - 1)`).

Number.MIN_SAFE_INTEGER // -9007199254740991
    -(Math.pow(2, 53) - 1)  // -9007199254740991

**`（2）最大正（负）数和最小正（负）数`**

`Number.MAX_VALUE` 属性表示在 JavaScript 里所能表示的最大数值。`MAX_VALUE` 属性值接近于 `1.79E+308`。大于 `MAX_VALUE` 的值代表 "`Infinity`"。

最小的负数是 `-MAX_VALUE`。

`Number.MIN_VALUE` 属性表示在 JavaScript 中所能表示的最小的正值。`MIN_VALUE` 属性是 JavaScript 里最接近 0 的正值，而不是最小的负值。`MIN_VALUE` 的值约为 5e-324。小于 `MIN_VALUE` ("underflow values") 的值将会转换为 0。

最大的负数是 `-MIN_VALUE。`

**（3）正无穷和负无穷**

`Number.POSITIVE_INFINITY` 属性表示正无穷大。

`Number.POSITIVE_INFINITY` 的值同全局对象 [`Infinity`][Infinity] 属性的值相同。

该值的表现同数学上的无穷大有点儿不同：

*  任何正值，包括 `POSITIVE_INFINITY`，乘以 `POSITIVE_INFINITY` 为 `POSITIVE_INFINITY`。
 *  任何负值，包括 `NEGATIVE_INFINITY`，乘以 `POSITIVE_INFINITY` 为 `NEGATIVE_INFINITY`。
 *  0 乘以 `POSITIVE_INFINITY` 为 NaN。
 *  NaN 乘以 `POSITIVE_INFINITY` 为 NaN。
 *  `POSITIVE_INFINITY` 除以 `NEGATIVE_INFINITY` 以外的任何负值为 `NEGATIVE_INFINITY`。
 *  `POSITIVE_INFINITY` 除以 `POSITIVE_INFINITY` 以外的任何正值为 `POSITIVE_INFINITY`。
 *  `POSITIVE_INFINITY` 除以 `NEGATIVE_INFINITY` 或 `POSITIVE_INFINITY` 为 NaN。
 *  任何数除以 `POSITIVE_INFINITY` 为 0

`Number.NEGATIVE_INFINITY` 属性表示负无穷大。

该值的行为同数学上的无穷大（infinity）有一点儿不同：

*  任何正值，包括 `POSITIVE_INFINITY，`乘以 `NEGATIVE_INFINITY` 为 `NEGATIVE_INFINITY`。
 *  任何负值，包括 `NEGATIVE_INFINITY`，乘以 `NEGATIVE_INFINITY` 为 `POSITIVE_INFINITY`。
 *  0 乘以 `NEGATIVE_INFINITY` 为 `NaN`.
 *  NaN 乘以 `NEGATIVE_INFINITY` 为` NaN`.
 *  `NEGATIVE_INFINITY` 除以任何负值（除了 `NEGATIVE_INFINITY）`为 `POSITIVE_INFINITY`。
 *  `NEGATIVE_INFINITY` 除以任何正值（除了 `POSITIVE_INFINITY`）为 `NEGATIVE_INFINITY`。
 *  `NEGATIVE_INFINITY` 除以 `NEGATIVE_INFINITY` 或 `POSITIVE_INFINITY` 是 `NaN`。
 *  任何数除以 `NEGATIVE_INFINITY` 为 0。

**（4）NaN值**

`Number.NaN` 表示“非数字”（Not-A-Number）。和 [`NaN`][NaN] 相同。

### 5、方法 （ES6） ###

全局属性 **`NaN`** 的值表示不是一个数字（Not-A-Number）。

**`（1）Number.isNaN()`** 方法确定传递的值是否为 [`NaN`][NaN]，并且检查其类型是否为 [`Number`][Number]。它是原来的全局 [`isNaN()`][isNaN] 的更稳妥的版本。

Number.isNaN(NaN);        // true
    Number.isNaN(Number.NaN); // true
    Number.isNaN(0 / 0)       // true
    
    // 下面这几个如果使用全局的 isNaN() 时，会返回 true。
    Number.isNaN("NaN");      // false，字符串 "NaN" 不会被隐式转换成数字 NaN。
    Number.isNaN(undefined);  // false
    Number.isNaN({});         // false
    Number.isNaN("blabla");   // false
    
    // 下面的都返回 false
    Number.isNaN(true);
    Number.isNaN(null);
    Number.isNaN(37);
    Number.isNaN("37");
    Number.isNaN("37.37");
    Number.isNaN("");
    Number.isNaN(" ");

**Polyfill：**

Number.isNaN = Number.isNaN || function(value) {
        return typeof value === "number" && isNaN(value);
    }

**`（2）Number.isInteger()`** 方法用来判断给定的参数是否为整数。

Number.isInteger(0);         // true
    Number.isInteger(1);         // true
    Number.isInteger(-100000);   // true
    
    Number.isInteger(0.1);       // false
    Number.isInteger(Math.PI);   // false
    
    Number.isInteger(Infinity);  // false
    Number.isInteger(-Infinity); // false
    Number.isInteger("10");      // false
    Number.isInteger(true);      // false
    Number.isInteger(false);     // false
    Number.isInteger([1]);       // false

**Polyfill：**

Number.isInteger = Number.isInteger || function(value) {
        return typeof value === "number" && 
               isFinite(value) && 
               Math.floor(value) === value;
    };

**`（3）Number.isSafeInteger()`** 方法用来判断传入的参数值是否是一个“安全整数”（safe integer）

Number.isSafeInteger(3);                    // true
    Number.isSafeInteger(Math.pow(2, 53))       // false
    Number.isSafeInteger(Math.pow(2, 53) - 1)   // true
    Number.isSafeInteger(NaN);                  // false
    Number.isSafeInteger(Infinity);             // false
    Number.isSafeInteger("3");                  // false
    Number.isSafeInteger(3.1);                  // false
    Number.isSafeInteger(3.0);                  // true

**Polyfill：**

Number.isSafeInteger = Number.isSafeInteger || function (value) {
       return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
    };

**`（4）Number.isFinite()`** 方法用来检测传入的参数是否是一个有穷数（finite number）

和全局的 [`isFinite()`][isFinite] 函数相比，这个方法不会强制将一个非数值的参数转换成数值，这就意味着，只有数值类型的值，且是有穷的（finite），才返回 `true`

Number.isFinite(Infinity);  // false
    Number.isFinite(NaN);       // false
    Number.isFinite(-Infinity); // false
    
    Number.isFinite(0);         // true
    Number.isFinite(2e64);      // true
    
    Number.isFinite('0');       // false, 全局函数 isFinite('0') 会返回 true

**Polyfill：**

Number.isFinite = Number.isFinite || function(value) {
        return typeof value === "number" && isFinite(value);
    }

**`（5）Number.parseFloat()`** 方法可以把一个字符串解析成浮点数。该方法与全局的 [`parseFloat()`][parseFloat] 函数相同，并且处于 ECMAScript 6 规范中（用于全局变量的模块化）。

给定值被解析成浮点数，如果无法被解析成浮点数，则返回`NaN`

**`（6）Number.parseInt()`** 方法依据指定基数 \[ 参数 **radix **的值\]，把字符串 \[ 参数 **string** 的值\] 解析成整数。

### 与Number相关的全局属性 ###

1、全局属性 **`NaN`**

NaN的值表示不是一个数字（Not-A-Number）。编码中很少直接使用`到 NaN`。通常都是在计算失败时，作为 Math 的某个方法的返回值出现的。

2、全局属性 `Infinity` 是一个数值，表示无穷大。

`Infinity` 的初始值是 [`Number.POSITIVE_INFINITY`][Number.POSITIVE_INFINITY]。`Infinity`（正无穷大）大于任何值。该值和数学意义上的无穷大很像，例如任何正值乘以 `Infinity` 为 `Infinity`, 任何数值除以 `Infinity` 为 0

3、`parseFloat`是个全局函数。**`parseFloat()` **函数解析一个参数（必要时先转换为字符串）并返回一个浮点数。

**4、parseInt(*string*, *radix*)  ** 解析一个字符串并返回指定基数的十进制整数， `radix` 是2-36之间的整数，表示被解析字符串的基数。

下面的例子都返回**3.14**

parseFloat(3.14);
    parseFloat('3.14');
    parseFloat('  3.14  ');
    parseFloat('314e-2');
    parseFloat('0.0314E+2');
    parseFloat('3.14some non-digit characters');
    parseFloat({ toString: function() { return "3.14" } });

考虑使用 [`Number(value)`][Number] 进行更严谨的解析，只要参数带有无效字符就会被转换为 [`NaN`][NaN] 。

[IEEE 754 64]: https://en.wikipedia.org/wiki/Floating-point_arithmetic
[BigInt]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/BigInt
[NaN]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/NaN
[20200901113607258.png]: /images/20221123/7a7600425c6845689613ef1585d70a5a.png
[20200901140151638.png]: /images/20221123/f6c4ca2c3dda4f58a05b7684cf865826.png
[20200901140058800.png]: /images/20221123/3186765115bc47f8ae57928211f102e2.png
[Math]: https://blog.csdn.net/zyz00000000/article/details/107610841
[Infinity]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Infinity
[Number]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number
[isNaN]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/isNaN
[isFinite]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/isFinite
[parseFloat]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/parseFloat
[Number.POSITIVE_INFINITY]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY