第四章 JavaScript的数值

数字是 JavaScript 中的一种数据类型。它用于在程序中表示整数和浮点数。可以使用运算符对数值进行加法和乘法运算。在这一章中我么将解释如何在 JavaScript 中使用数字。

目录

4-1 如何写数字文字
4-2 数字对象
4-3 将数字转换为指定基数格式的字符串 (toString)
4-4 将数字转换为指数格式的字符串 (toExponential)
4-5 将数字转换为定点格式的字符串 (toFixed)
4-6 指定数字的有效位数并转换为字符串（toPrecision）
4-7 将数值转换为与指定语言环境对应的格式的字符串 (toLocaleString)
4-8 将字符串转换为整数 (Number.parseInt)
4-9 将字符串转换为浮点数 (Number.parseFloat)
4-10 检查一个值是否为 NaN 并且是数字类型 (Number.isNaN)
4-11 检查一个值是否有限且为数字类型 (Number.isFinite)
4-12 检查值是否为整数（Number.isInteger、Number.isSafeInteger）

4-1 如何写数字文字

要在程序中使用数字类型值，请按原样编写数字文字。数字文字大致分为整数文字和浮点文字。本节介绍如何在 JavaScript 中编写数字文字。

JavaScript 中的数字

JavaScript 中的所有数字都被视为 64 位浮点数。虽然其他一些编程语言将整数和浮点数作为单独的数据类型进行管理，但在 JavaScript 中，所有数字都被视为浮点数。

但是，在程序中描述数值时，整数可以描述为整数值，浮点数可以描述为浮点值。

整数文字

整数文字用于描述程序中的整数值。整数除了常用的十进制数外，还可以写成十六进制数、八进制数和二进制数。

如果它是十进制数，请按原样写入值。

let num = 208;

整数文字用于描述程序中的整数值。整数除了常用的十进制数外，还可以写成十六进制数、八进制数和二进制数。

如果它是十进制数，请按原样写入值。

let num = 0xD0;  // 十六进制的208

对于八进制数，将 0o 添加到数字的开头。0o 可以是 0O，但是小写的 0o 是首选，因为字母相似。

let num = 0o320;  //八进制的208 

※ 8 進数を表すリテラルは ECMAScript 2015 (ES6) から導入されています。

2 進数の場合は数値の先頭に 0b をつけて記述します。 0b は 0OB でも構いません。

let num = 0b11010000;  // 二进制208

※表示二进制数的文字是从 ECMAScript 2015 (ES6) 引入的。

在内部，使用哪种形式来编写整数文字没有区别。当打印到控制台时，它们被打印为十进制值。

console.log(208);
>>208

console.log(0xD0);
>> 208

console.log(0o320);
>> 208

console.log(0b11010000);
>> 208

作为表示八进制数的字面量，之前使用了如下格式，数字前加了0。

let num = 0320;  // 320是八进制的数字。

这种格式今天仍然可以使用，但是由于 ECMAScript 2015 (ES6) 引入了八进制数字以 0o 开头的格式，因此以后请避免使用前导 0 的格式。

浮点值字面量

浮点值字面量用于描述程序中的浮点值。浮点数可以按原样写，例如 15.742，也可以写成指数形式，例如 7.5e-3。

let num1 = 4.832;
let num2 = 3.6e5;  // 3.6 × 105
let num3 = 4.2e-6; // 4.2 × 10-6

指数 e 可以是大写字母 E。

在内部，使用哪种形式编写浮点文字没有区别。当输出到控制台时，它被输出为十进制格式的值。

console.log(4.82);
>> 4.862

console.log(3.6e5);
>> 360000

console.log(4.2e-6);
>> 0.0000042

4-2 数字对象

Number 对象是数字的包装类。您不仅可以从 Number 对象的实例中调用方法和访问 Number 对象的属性，还可以从数字中调用方法和访问属性。在这里，我将解释 JavaScript 的 Number 对象。

数字对象构造函数

Number 对象是数字的包装对象。当您对数字调用 Number 对象方法时，该数字会自动转换为 Number 对象并调用该方法。

通常不需要直接创建 Number 对象，而是使用 Number 对象的构造函数来创建。格式如下。

new Number(value)

参数指定 Number 对象的值。指定数值以外的值时，转换为数值后设定为数值。该值被设置为由 Number 对象包装的原始值。

看看下面的示例。

let obj1 = new Number(10);
console.log(obj1);
>> Number {10}

let obj2 = new Number('10');
console.log(obj2);
>> Number {10}

let obj3 = new Number('Hello');
console.log(obj3);
>> Number?{NaN}

例如，如果您指定了一个非数值，即使您指定了相同的字符串，是否将其视为数值取决于该字符串的值。

获取 Number 对象的原始值

要获取 Number 对象的原始值，请使用 Number 对象提供的实例方法的 valueof 方法。格式如下。

numberObj.valueOf()

返回指定 Number 对象所拥有的原始值。

看看下面的示例。

let obj = new Number(10);
console.log(obj.valueOf());
>> 10

这样就能够获得 Number 对象的原始值。

Number 对象的静态属性

Number 对象提供常用的静态属性。以下是其中一些。

属性	说明
Number.MAX_SAFE_INTEGER	最大安全整数 (2 53 – 1)
Number.MIN_SAFE_INTEGER	最小安全整数值 (-(2 53 – 1))
Number.MAX_VALUE	最大可表示正数
Number.MIN_VALUE	最小可表示正数
Number.NaN	表示“不是数字”的值
Number.POSITIVE_INFINITY	无穷大
Number.NEGATIVE_INFINITY	负无穷大

安全整数是一个棘手的词，但是一个值可以完全表示为 IEEE-754 双精度数，并且不能匹配另一个表示为 IEEE-754 双精度数的值。（当我能更清楚地解释它时，我会重写它）。实际值为：

console.log(Number.MAX_SAFE_INTEGER);
>> 9007199254740991

console.log(Number.MIN_SAFE_INTEGER);
>> -9007199254740991

可以表示的最大正数就是可以显示的最大值，上面显示为Infinity（ Infinity 是表示无穷大的全局属性）。最小的可表示正数是最接近 0 的正值。实际值为：

console.log(Number.MAX_VALUE);
>> 1.7976931348623157e+308

console.log(Number.MAX_VALUE * 2);
>> Infinity

console.log(Number.MIN_VALUE);
>> 5e-324

Number.NaN 用于表示非数字值。

console.log(Number('abc'));
>> NaN

Number.POSITIVE_INFINITY 表示无穷大，Number.NEGATIVE_INFINITY 表示负无穷大。

console.log(Number.POSITIVE_INFINITY);
>> Infinity

console.log(Number.NEGATIVE_INFINITY);
>> -Infinity

4-3 将数字转换为指定基数格式的字符串 (toString)

Number 对象的实例方法 toString 允许您获取表示指定基数（二进制为 2，十六进制为 16）的数字的字符串。这里我们将解释如何使用 Number 对象的 toString 方法。

转换为指定基数格式的字符串（toString）

Number 对象的 toString 方法返回表示指定基数格式的目标数字的字符串。格式如下。

number.toString([基数])

指定以 2 为底数以获取表示二进制数字的字符串，指定以 16 为底数以获取以十六进制表示数字的字符串。可能的值是 2 到 36。Radix 是可选的，默认为 10。

看看下面的示例。

let num = 78;
console.log(num.toString());
>> 78
console.log(num.toString(2));
>> 1001110
console.log(num.toString(16));
>>  4e

接下来，当对非整数值调用 toString 方法时：

let num = 7.5;
console.log(num.toString());
>> 7.5
console.log(num.toString(2));
>> 111.1
console.log(num.toString(16));
>> 7.8

如果您指定的值超出基数范围，则会引发 RangeError 错误。

console.log((78).toString(40));
>> Uncaught RangeError: toString() radix argument must be between 2 and 36

直接对整数调用 toString 方法时，要么将数字括在括号中，要么在数字后添加一个空格。

console.log(48.toString(2));
>> Uncaught SyntaxError: Invalid or unexpected token

console.log((48).toString(2)); // 将数字括在括号中
>> 110000

console.log(48 .toString(2)); // 在数字后加一个空格
>> 110000

4-4 将数字转换为指数格式的字符串 (toExponential)

Number 对象的实例方法 toExponential 允许您获取表示指数格式数字的字符串（例如，1.52e10）。这里我们将解释如何使用 Number 对象的 toExponential 方法。

转换为指数格式的字符串 (toExponential)

Number 对象的 toExponential 方法以指数格式返回目标数字的字符串表示形式。格式如下。

number.toExponential([小数点后的位数])

返回表示指数格式数字的字符串。小数点前的数字为 1，小数点后的数字为参数中指定的数字。如果省略参数，则使用显示原始数字所需的位数。

不能以自变量指定的位数显示的部分四舍五入到最接近的值。（类似于舍入但不完全）。

看看下面的示例。

let num = 34.5642;
console.log(num.toExponential());
>> 3.45642e+1
console.log(num.toExponential(2));
>> 3.46e+1
console.log(num.toExponential(4));
>> 3.4564e+1

在小数点后指定比显示数字所需更多的数字不会导致用零填充。

let num = 728.52;
console.log(num.toExponential());
>> 7.2852e+2
console.log(num.toExponential(1));
>> 7.3e+2
console.log(num.toExponential(5));
>> 7.28520e+2

直接对不带小数点的数字（如整数）执行toExponential方法时，将数字括在括号中或在数字后加空格。

console.log(48.toExponential(2));
>> Uncaught SyntaxError: Invalid or unexpected token

console.log((48).toExponential(2)); // 将数字括在括号中
>> 4.80e+1

console.log(48 .toExponential(2)); // 在数字后加一个空格
>> 4.80e+1

4-5 将数字转换为定点格式的字符串 (toFixed)

Number 对象的实例方法 toFixed 允许您以定点格式（如 123.4567 ）获取数字的字符串表示形式。这里我们将解释如何使用 Number 对象的 toFixed 方法。

转换为定点格式的字符串 (toFixed)

Number 对象的 toFixed 方法以定点格式返回目标数字的字符串表示形式。格式如下。

number.toFixed([小数点后的位数])

返回表示定点格式数字的字符串。小数点前的数字保持原来的数字，小数点后的数字成为参数中指定的数字。如果省略参数，则默认值为 0。

不能以自变量指定的位数显示的部分四舍五入到最接近的值。（类似于舍入但不完全）。此外，如果参数中指定的位数大于表示数字所需的位数，则会用零填充。

看看下面的示例。

let num = 34.5732;
console.log(num.toFixed());
>> 35
console.log(num.toFixed(1));
>> 34.6
console.log(num.toFixed(3));
>> 34.573

num = 1.8e-2;
console.log(num.toFixed(1));
>> 0.0
console.log(num.toFixed(3));
>> 0.018

如果您在小数点后指定的位数多于显示数字所需的位数，则会用 0 填充。

let num = 735.52;
console.log(num.toFixed(5));
>> 735.52000

直接对不带小数点的数字（如整数）执行toFixed方法时，将数字括在括号中或在数字后加空格。

console.log(48.toFixed(2));
>> Uncaught SyntaxError: Invalid or unexpected token

console.log((48).toFixed(2)); // 将数字括在括号中
>> 48.00

console.log(48 .toFixed(2)); //在数字后加一个空格
>> 48.00

4-6 指定数字的有效位数并转换为字符串（toPrecision）

number 对象实例方法 toPrecision 可以获取指定有效位数后转换为字符串的值。这里我们将解释如何使用 Number 对象的 toPrecision 方法。

指定有效位数后转换为字符串（toPrecision）

Number 对象的 toPrecision 方法指定感兴趣的有效数字位数，然后在将数字转换为字符串后返回该值。格式如下。

number.toPrecision([有效数字位数])

将有效位数更改为参数中指定的值，然后返回转换为字符串的值。如果省略参数，则返回转换为字符串的值而不更改数字的精度。

不能以自变量指定的有效位数显示的部分四舍五入到最接近的值。（类似于舍入但不完全）。此外，如果参数中指定的位数大于表示数字所需的位数，则会用零填充。

看看下面的示例。

let num = 34.6845;
console.log(num.toPrecision());
>> 34.6845
console.log(num.toPrecision(3));
>> 34.7
console.log(num.toPrecision(5));
>> 34.684
console.log(num.toPrecision(8));
>> 34.684500

在某些情况下，它可能会在通过设置精度转换为指数形式后作为字符串返回。

let num = 5678.9

console.log(num.toPrecision());
>> 5678.9
console.log(num.toPrecision(2));
>> 5.7e+3
console.log(num.toPrecision(3));
>> 5.68e+3
console.log(num.toPrecision(4));
>> 5679
console.log(num.toPrecision(6));
>> 5678.90

直接对不包含小数点的数字（例如整数）执行 toPrecision 方法时，将数字括在括号中或在数字后添加空格。

console.log(48.toPrecision(3));
>> Uncaught SyntaxError: Invalid or unexpected token

console.log((48).toPrecision(2)); //将数字括在括号中
>> 48

console.log(48 .toPrecision(2)); // 在数字后加一个空格
>> 48

4-7 将数值转换为与指定语言环境对应的格式的字符串 (toLocaleString)

Number 对象的实例方法 toLocaleString 可以根据指定的语言环境和选项获取格式转换为字符串的值。根据国家/地区的不同，数值是以逗号 (,) 还是点 (.) 分隔会因国家/地区而异，但如果使用此方法将区域指定为区域设置，则目标数值将根据到那个地方。我会把它给你。本节介绍如何使用 Number 对象的 toLocaleString 方法。

根据区域设置转换为字符串（toLocaleString）

Number 对象的 toLocaleString 方法返回根据指定区域设置转换为字符串的目标数字的值。格式如下。

number.toLocaleString([语言环境 [, 选项]])

将数值转换为与参数中指定的语言环境匹配的格式后，它返回转换为字符串的值。如果省略该参数，它将被视为已指定默认语言环境。（我不知道第二个参数，选项的细节）。

看看下面的示例。

let num = 8242.56;

console.log(num.toLocaleString());
>> 8,242.56
console.log(num.toLocaleString('zh-CN'));
>> 8,242.56
console.log(num.toLocaleString('de-DE'));
>> 8.242,56
console.log(num.toLocaleString('ru-RU'));
>> 8?242,56

根据指定的语言环境，数字的表达方式不同。在汉语（汉语），逗号用于分隔数字，句点用于分隔小数点，但在德国（德语）则相反。另外，在俄罗斯（俄语）中，数字分隔符是一个空格。（它似乎因国家和语言而异，而不是因国家而异）。

直接对不带小数点的数字（如整数）执行toLocaleString方法时，将数字括在括号中或在数字后加空格。

console.log(1000.toLocaleString('zh-CN'));
>> Uncaught SyntaxError: Invalid or unexpected token

console.log((1000).toLocaleString('zh-CN')); //将数字括在括号中
>> 1,000

console.log(1000 .toLocaleString('zh-CN')); // 在数字后加一个空格
>> 1,000

4-8 将字符串转换为整数 (Number.parseInt)

Number 对象的静态方法 Number.parseInt 返回转换为整数的字符串值。如果目标值不是字符串，则将其转换为字符串，然后再转换为整数。本节介绍如何使用 Number 对象的 Number.parseInt 方法。

将字符串转换为整数 (parseInt)

Number 对象的 Number.parseInt 方法返回转换为整数的字符串值。格式如下。

Number.parseInt(字符串 [, 基数])

将第一个参数中指定的字符串转换为整数。如果参数不是字符串，则将其转换为字符串，然后再转换为整数。可选的第二个参数允许您指定整数基数（十进制数为 10）。指定 2 到 36 之间的数字。

字符串到整数的转换如下：(1) 从字符串中删除前导空格。(2) 开头有’+’或’-‘的，按符号处理。(3) 将字符串直到非数字的字符转换为整数。除了数字之外，被视为数字的字符是在第二个参数中指定大于或等于 10 的数字作为基数时使用的字母（指定十六进制数字时为 A 到 F）。

如果第一个字符无法转换为数字，则返回 NaN。

看看下面的示例。

Number.parseInt('42', 10);
>> 42

Number.parseInt('  -84cm', 10);
>> -84

Number.parseInt('3FDCKA', 16);
>> 16348  //十六进制的 0x3FDC

Number.parseInt('Month12', 10);
>> NaN

即使字符串是数字，比如以2为底，如果开头写了0和1以外的数字，也会是NaN。

Number.parseInt('10010', 2);
>> 18

Number.parseInt('4010', 2);
>> NaN

如果没有指定基数，如果字符串以’0x’或’0X’开头，则假设基数为16，否则假设基数为10。

Number.parseInt('0x42');
>> 66

Number.parseInt('42');
>> 42

4-9 将字符串转换为浮点数 (Number.parseFloat)

Number 对象静态方法 Number.parseFloat 返回转换为浮点数的字符串值。如果目标值不是字符串，则将其转换为字符串，然后再转换为浮点数。这里我们将解释如何使用 Number 对象的 Number.parseFloat 方法。

将字符串转换为浮点数 (parseFloat)

Number 对象的 Number.parseFloat 方法返回转换为浮点数的字符串值。格式如下。

Number.parseFloat(字符串 [, 基数])

将参数中指定的字符串转换为浮点数。如果参数不是字符串，则将其转换为字符串，然后再转换为浮点数。

字符串到浮点数的转换如下：(1) 从字符串中删除前导空格。(2) 开头有’+’或’-‘的，按符号处理。(3) 将字符串直到不是数字的字符转换为浮点数。除了数字之外，被认为是数字的字符是点 (.) 和代表指数的 e 或 E。但是，第二次的点（.）不被视为数字。

如果第一个字符无法转换为数字，则返回 NaN。

看看下面的示例。

Number.parseFloat("42.25");
>> 42.25

Number.parseFloat('  -1.75per');
>> -1.75

Number.parseFloat('3.11e4');
>> 31100

Number.parseFloat('Since1901');
>> NaN

与 Number.parseInt 函数不同，Number.paseFloat 函数不会将以 0x 或 0X 开头的字符识别为十六进制字符。在这种情况下，考虑数字 0 和非数字“x”。

Number.parseFloat('0x44F2');
>> 0

Number.parseFloat('3A4B');
>> 3

4-10 检查一个值是否为 NaN 并且是数字类型 (Number.isNaN)

如果目标值为 NaN（非数字）且值为数字类型，则 Number 对象的静态方法 Number.isNaN 返回 true 或 false。本节介绍如何使用 Number 对象的 Number.isNaN 方法。

检查值是否为NaN和数值类型（isNaN）

如果目标值为 NaN 且数据类型为数字，则 Number 对象的 Number.isNaN 方法返回 true 或 false。格式如下。

Number.isNaN(值)

检查参数中指定的值是否为 NaN 且为数值类型。对所有非数字值返回 false。

NaN 是全局对象的属性之一，表示 Not A Number。Number 对象提供的 Number.NAN 也是如此。

NaN是一个特殊的值，即使你用==或===判断它是否等于NaN本身，它也是假的，所以你不能用判断判断它是否是NaN。这就是我们使用 Number.isNaN 方法的原因。

console.log(NaN == NaN);
>> false

console.log(NaN === NaN);
>> false

Number.isNaN(NaN);
>> true

Number.isNaN(0 / 0);
>> true

以下值转换为数值类型为 NaN ，但 Number 对象的 Number.isNaN 方法不会将它们转换为数值类型：所有非数字值都是假的。

Number.isNaN('Hello');  // 如果转换成数字就是false
>> false

Number.isNaN(undefined);  // 如果转换成数字就是false
>> false

Number.isNaN({a:'10'});  // 如果转换成数字就是false
>> false

isNaN函数和Number.isNaN方法的区别（isNaN）

全局函数的 isNaN 函数和 Number 对象的 Number.isNaN 方法都用于检查目标值是否为 NaN isNaN ，如果参数不是数字类型， Number.isNaN 方法返回 false 。

看看下面的示例。

isNaN(NaN);
>> true
Number.isNaN(NaN);
>> true

isNaN(0 / 0);
>> true
Number.isNaN(0 / 0);
>> true

isNaN('Hello');
>> true
Number.isNaN('Hello');
>> false

isNaN(undefined);
>> true
Number.isNaN(undefined);
>> false

isNaN({a:'10'});
>> true
Number.isNaN({a:'10'});
>> false

任何为 NaN 或结果为 NaN 的表达式都为真，但全局函数的 isNaN 方法对于其他值可能为真。使用 Number.isNaN 方法来确定它是否是一个严格的数字 NaN。

4-11 检查一个值是否有限且为数字类型 (Number.isFinite)

如果目标值是有限的并且该值是数字类型，则 Number 对象的静态方法 Number.isFinite 返回 true 或 false。本节介绍如何使用 Number 对象的 Number.isFinite 方法。

检查一个值是否是有限的和数字的（isFinite）

如果目标值是有限的且数据类型是数字，则 Number 对象的 Number.isFinite 方法返回 true 或 false。格式如下。

Number.isFinite(值)

检查参数中指定的值是否为有限值。如果值为 NaN、正无穷大 (Infinity)、负无穷大 (-Infinity)，则返回 false，否则返回 true。对所有非数字值返回 false。

看看下面的示例。如果值为 NaN 、正无穷大 ( Infinity ) 或负无穷大 ( -Infinity )，则为 false。

Number.isFinite(Infinity);
>> false

Number.isFinite(-Infinity);
>> false

Number.isFinite(NaN);
>> false

一个不是无限的数字是一个有限的数字。

Number.isFinite(442);
>> true

Number.isFinite(0);
>> true

Number.isFinite(-1.225e-3);
>> true

所有非数字值都是假的。

Number.isFinite('78');
>> false

Number.isFinite(true);
>> false

Number.isFinite(undefined);
>> false

Number.isFinite([10, 20]);
>> false

isFinite 函数和 Number.isFinite 方法之间的区别

全局函数的isFinite函数和Number对象的Number.isFinite方法都是用来判断目标值是否有限，不同的是Number.isFinite方法在参数不是数值类型时返回false ，而 Number.isFinite 方法确定参数是否有限。

看看下面的示例。

isFinite(128);
>> true
Number.isFinite(128);
>> true

isFinite(Infinity);
>> false
Number.isFinite(Infinity);
>> false

isFinite('78');
>> true
Number.isFinite('78');
>> false

isFinite('');
>> true
Number.isFinite('');
>> false

isFinite(true);
>> true
Number.isFinite(true);
>> false

isFinite(null);
>> true
Number.isFinite(null);
>> false

isFinite([10]);
>> true
Number.isFinite([10]);
>> false

任何有限数都是 true ，任何表示无限值的 Infinity 都是 false ，但是全局函数的 isFinite 方法对于任何其他值都可以是 true 。使用 Number.isFinite 方法来确定一个严格的数值是否是有限的。

4-12 检查值是否为整数（Number.isInteger、Number.isSafeInteger）

如果目标值是整数，则 Number 对象的静态方法 Number.isInteger 返回 true 或 false。Number.isSafeInteger 还会检查目标值是否为安全整数并返回 true 或 false。本节介绍如何使用 Number 对象的 Number.isInteger 和 Number.isSafeInteger 方法。

检查是否为整数（isInteger）

如果目标值是整数，则 Number 对象的 Number.isInteger 方法返回 true 或 false。格式如下。

Number.isInteger(值)

检查参数中指定的值是否为整数。如果值为整数，则返回 true，否则返回 false。对所有非数字值返回 false。

看看下面的示例。

Number.isInteger(428);
>> true

Number.isInteger(16.5);
>> true

Number.isInteger(16.0);
>> true

Number.isInteger(NaN);
>> false

Number.isInteger(Infinity);
>> false

整数为 true，浮点数为 false，NaN 和 Infinity 为 false。

所有非数字值都是假的。

Number.isInteger('78');
>> false

Number.isInteger(true);
>> false

Number.isInteger(undefined);
>> false

Number.isInteger([10]);
>> false

检查整数是否安全（isSafeInteger）

如果目标值是安全整数，则 Number 对象的 Number.isSafeInteger 方法返回 true 或 false。格式如下。

Number.isSafeInteger(值)

检查参数中指定的值是否是安全整数。如果该值是安全整数，则返回 true，否则返回 false。对所有非数字值返回 false。

安全整数是一个棘手的词，但是一个值可以完全表示为 IEEE-754 双精度数，并且不能匹配另一个表示为 IEEE-754 双精度数的值。具体来说，大于或等于 -(2 ⁵³ – 1)且小于或等于2 ^{53 – 1的整数值（大于或等于-9007199254740991且小于或等于9007199254740991的整数值）。}

看看下面的示例。

Number.isSafeInteger(87462);
>> true

Number.isSafeInteger(-665212234);
>> false

Number.isSafeInteger(Math.pow(2, 53) - 1);
>> true

Number.isSafeInteger(Math.pow(2, 53));
>> false

如果整数在安全整数范围内，则返回 true；如果超出安全整数范围，则返回 false。

对于 NaN 和 Infinity 为 false，对于所有非数字值均为 false。

Number.isSafeInteger(NaN);
>> false

Number.isSafeInteger(Infinity);
>> false

Number.isSafeInteger('1800');
>> false

Number.isSafeInteger(undefined);
>> false