recursal/MDN huggingface dataset:
Date.prototype.getDate()
========================

根据本地时间，返回一个指定的日期对象为一个月中的哪一日（从 1--31）。

尝试一下
----

语法
--


```js
getDate()
```

参数
--

无

描述
--

`getDate()` 返回一个 1 到 31 的整数值。

示例
--

### 示例：使用 `getDate()` 方法

下面第二条语句将值 25 赋给 day 变量，该值基于日期对象 `Xmax95`的值。


```js
var Xmas95 = new Date("December 25, 1995 23:15:00");
var day = Xmas95.getDate();

alert(day); // 25
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getdate |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Date.prototype.getUTCDate()`
* `Date.prototype.getUTCDay()`
* `Date.prototype.setDate()`
Date.prototype.getTimezoneOffset()
==================================

**`getTimezoneOffset()`** 方法返回协调世界时（UTC）相对于当前时区的时间差值，单位为分钟。

尝试一下
----

语法
--


```js
getTimezoneOffset()
```

### 参数

无

### 返回值

时区偏差（time-zone offset）表示协调世界时（UTC）与本地时区之间的差值，单位为分钟。需要注意的是如果本地时区后于协调世界时，则该差值为正值，如果先于协调世界时则为负值。例如你所在时区为 UTC+10（澳大利亚东部标准时间），将会返回 -600。对于同一个时区，夏令时（Daylight Saving Time）将会改变这个值。

示例
--

### 示例：使用 `getTimezoneOffset` 方法


```js
var x = new Date();
var currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60;
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.gettimezoneoffset |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Date.prototype.getUTCSeconds()
==============================

**`getUTCSeconds()`** 方法以世界时为标准，返回一个指定的日期对象的秒数。

尝试一下
----

语法
--
```

dateObj.getUTCSeconds()
```

### 参数

无。

### 返回值

`getUTCSeconds()` 返回一个 0 到 59 的整数。

示例
--

### 示例：使用 `getUTCSeconds()` 方法

下例将当前时间的秒数部分赋值给变量 `seconds`。


```js
var today = new Date();
var seconds = today.getUTCSeconds();
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getutcseconds |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Date.prototype.getSeconds()`
* `Date.prototype.setUTCSeconds()`
Date.prototype.getMonth()
=========================

**`getMonth()`** 方法根据本地时间，返回一个指定的日期对象的月份，为基于 0 的值（0 表示一年中的第一月）。

尝试一下
----

语法
--


```js
getMonth()
```

### 参数

无

### 返回值

`getMonth`返回一个 0 到 11 的整数值：0 代表一月份，1 代表二月份，2 代表三月份，依次类推。

示例
--

### 使用 `getMonth()`

下面第二条语句，基于 `Date` 对象 Xmas95 的值，把 11 赋值给变量 `month`。


```js
var Xmas95 = new Date("December 25, 1995 23:15:30");
var month = Xmas95.getMonth();

console.log(month); // 11
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getmonth |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Date.prototype.getUTCMonth()`
* `Date.prototype.setMonth()`
Date.prototype.getUTCDay()
==========================

**`getUTCDay()`** 方法以世界时为标准，返回一个指定的日期对象为一星期中的第几天，其中 0 代表星期天。

尝试一下
----

语法
--
```

dateObj.getUTCDay()
```

### 参数

无。

### 返回值

`getUTCDay()` 方法返回一个对应一星期中第几天的整数：0 代表星期天，1 代表星期一，2 代表星期二，依次类推。

示例
--

### 示例：使用 `getUTCDay()` 方法

下面的例子是把当前日期的星期部分赋值给变量 `weekday`。


```js
var today = new Date();
var weekday = today.getUTCDay();
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getutcday |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Date.prototype.getUTCDate()`
* `Date.prototype.getDay()`
* `Date.prototype.setUTCDate()`
Date.prototype.setSeconds()
===========================

**`setSeconds()`** 方法根据本地时间设置一个日期对象的秒数。

尝试一下
----

语法
--
```

dateObj.setSeconds(secondsValue[, msValue])
```

### JavaScript 1.3 之前版本
```

dateObj.setSeconds(secondsValue)
```

### 参数

`secondsValue`

一个 0 到 59 的整数。

`msValue`

一个 0 到 999 的数字，表示微秒数。

描述
--

如果没有指定 `msValue` 参数，就会使用 `getMilliseconds()` 方法的返回值。

如果一个参数超出了合理范围， `setSeconds` 方法会相应地更新日期对象的时间信息。例如，为 `secondsValue` 指定 100，则日期对象的分钟数会相应地加 1，秒数将会使用 40。

示例
--

### 示例：使用`setSeconds` 方法


```js
var theBigDay = new Date();
theBigDay.setSeconds(30);
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.setseconds |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Date.prototype.getSeconds()`
* `Date.prototype.setUTCSeconds()`
Date.prototype.getUTCHours()
============================

**`getUTCHours()`** 方法以世界时为标准，返回一个指定的日期对象的小时数。

尝试一下
----

语法
--
```

dateObj.getUTCHours()
```

### 参数

无。

### 返回值

`getUTCHours()` 返回一个 0 到 23 的整数。

示例
--

### 示例：使用 `getUTCHours()` 方法

下例将当前时间的小时部分赋值给变量 `hours`。


```js
var today = new Date();
var hours = today.getUTCHours();
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getutchours |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Date.prototype.getHours()`
* `Date.prototype.setUTCHours()`
Date.prototype.toDateString()
=============================

**`toDateString()`** 方法以美式英语和人类易读的形式返回一个日期对象日期部分的字符串。

尝试一下
----

语法
--
```

dateObj.toDateString()
```

描述
--

`Date` 对象实例引用一个具体的时间点。调用 `toString` 方法会以美式英语和人类易读的形式返回日期对象的格式化字符串。在 SpiderMonkey 里，该字符串由日期部分（年月日）和其后的时间部分（时分秒及时区）组成。有时需要获取日期部分的字符串，这可以由 `toDateString` 方法完成。

The `toDateString` method is especially useful because compliant engines implementing ECMA-262 (en-US) may differ in the string obtained from `toString` for `Date` objects, as the format is implementation-dependent and simple string slicing approaches may not produce consistent results across multiple engines.

示例
--

### 示例：`toDateString` 方法的简单使用


```js
var d = new Date(1993, 6, 28, 14, 39, 7);

println(d.toString()); // prints Wed Jul 28 1993 14:39:07 GMT-0600 (PDT)
println(d.toDateString()); // prints Wed Jul 28 1993
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.todatestring |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Date.prototype.toLocaleDateString()`
* `Date.prototype.toTimeString()`
* `Date.prototype.toString()`
Date.prototype.toJSON()
=======================

**`toJSON()`** 方法返回 `Date` 对象的字符串形式。

尝试一下
----

语法
--


```js
toJSON()
```

描述
--

`Date` 实例引用一个具体的时间点。调用 `toJSON()` 返回一个 JSON 格式字符串（使用 `toISOString()`），表示该日期对象的值。默认情况下，这个方法常用于 JSON 序列化 `Date` 对象。

示例
--

### 使用 toJSON()


```js
const jsonDate = new Date(0).toJSON(); // '1970-01-01T00:00:00.000Z'
const backToDate = new Date(jsonDate);

console.log(jsonDate); // 1970-01-01T00:00:00.000Z
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.tojson |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Date.prototype.toLocaleDateString()`
* `Date.prototype.toTimeString()`
* `Date.prototype.toUTCString()`
Number.prototype.toString()
===========================

`Number` 值的 **`toString()`** 方法返回表示该数字值的字符串。

尝试一下
----

语法
--


```js
toString()
toString(radix)
```

### 参数

`radix` 可选

一个整数，范围在 `2` 到 `36` 之间，用于指定表示数字值的基数。默认为 10。

### 返回值

一个表示指定数字值的字符串。

### 异常

`RangeError`

如果 `radix` 小于 2 或大于 36，则抛出该异常。

描述
--

`Number` 对象的重写了 `Object` 的 `toString` 方法；它不会继承 `Object.prototype.toString()`。对于 `Number` 值，`toString` 方法返回数字值指定基数的字符串表示。

对于 10 以上的基数，字母表示大于 9 的数字。例如，对于十六进制数（基数为 16），`a` 到 `f` 用于表示大于 9 的数字。

如果指定的值为负数，则符号会被保留。即使基数为 2，也是如此；返回的字符串是带有 `-` 符号的正数二进制表示，而**不是**数字值的补码表示。

`0` 和 `-0` 都以 `"0"` 作为其字符串表示。`Infinity` 返回 `"Infinity"`，而 `NaN` 返回 `"NaN"`。

如果该数字不是一个整数，则使用小数点 `.` 来分隔小数部分。如果基数为 10，并且数字的大小（忽略符号）大于或等于 1021 或小于 10-6，则使用科学计数法。在这种情况下，返回的字符串总是显式地指定了指数的符号。


```js
console.log((10 \*\* 21.5).toString()); // "3.1622776601683794e+21"
console.log((10 \*\* 21.5).toString(8)); // "526665530627250154000000"
```


`toString` 方法要求 `this` 值是 `Number` 原始值或包装对象。对于其他 `this` 值，不会尝试将它们转换为数字值，而是抛出 `TypeError`。

因为 `Number` 没有 `[@@toPrimitive]()` 方法，当一个 `Number` *对象*在一个期望字符串的上下文中使用时（比如在模板字符串中），JavaScript 会自动调用 `toString()` 方法。然而，`Number` *原始值*不会使用 `toString()` 方法来进行字符串强制转换——相反，它们会直接使用与 `toString()` 初始实现的相同算法进行转换。


```js
Number.prototype.toString = () => "重写了";
console.log(`${1}`); // "1"
console.log(`${new Number(1)}`); // "重写了"
```

示例
--

### 使用 toString()


```js
const count = 10;
console.log(count.toString()); // "10"

console.log((17).toString()); // "17"
console.log((17.2).toString()); // "17.2"

const x = 6;
console.log(x.toString(2)); // "110"
console.log((254).toString(16)); // "fe"
console.log((-10).toString(2)); // "-1010"
console.log((-0xff).toString(2)); // "-11111111"
```

### 转换数字字符串的基数

如果你有一个非十进制的数字的字符串，可以使用 `parseInt()` 和 `toString()` 将其转换为不同的基数。


```js
const hex = "CAFEBABE";
const bin = parseInt(hex, 16).toString(2); // "11001010111111101011101010111110"
```


注意精度损失：如果原始数字字符串太大（比如大于 `Number.MAX_SAFE_INTEGER` ），则应使用 `BigInt` 来替代。然而，`BigInt` 的构造函数仅支持表示数字字面量的字符串（即以 `0b`、`0o` 或 `0x` 开头的字符串）。如果原始基数不是二进制、八进制、十进制或十六进制，则可能需要手工编写基数转换器，或者使用库。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.tostring |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Number.prototype.toFixed()`
* `Number.prototype.toExponential()`
* `Number.prototype.toPrecision()`
Number.EPSILON
==============

**`Number.EPSILON`** 静态数据属性表示 1 与大于 1 的最小浮点数之间的差值。

尝试一下
----

值
-

2-52，或大约 `2.2204460492503130808472633361816E-16`。

| `Number.EPSILON` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

`Number.EPSILON` 是数字中 1 和可表示的比 1 大的最小数字之间的差值，因为双精度浮点格式只有 52 位来表示尾数，并且最低位的有效值为 2-52。

请注意，浮点数的绝对精度随着数字变大而降低，因为指数增长而尾数的精度保持不变。`Number.MIN_VALUE` 是可表示的最小正数，远小于 `Number.EPSILON`。

由于 `EPSILON` 是 `Number` 的静态属性，因此你应该始终将其用作 `Number.EPSILON`，而不是作为数字值的属性。

示例
--

### 相等测试

任何占用位数有限的数字编码系统，无论你选择的是什么基数（例如十进制或二进制），都*必定*无法精确表示所有数字，因为你试图使用有限的内存来表示数轴上无限数量的点。例如，十进制系统无法准确表示 1/3，而二进制系统无法准确表示 `0.1`。因此，例如，`0.1 + 0.2` 并不完全等于 `0.3`：


```js
console.log(0.1 + 0.2); // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3); // false
```


因此，通常建议**不要使用 `===` 比较浮点数**。相反，我们可以认为两个数在彼此之间是*足够接近*的时候它们是相等的。如果算术运算的数量级在 `1` 附近，那么 `Number.EPSILON` 常数通常是一个合理的误差阈值，因为实质上，`EPSILON` 指定了数字“1”的精确度。


```js
function equal(x, y) {
  return Math.abs(x - y) < Number.EPSILON;
}

const x = 0.2;
const y = 0.3;
const z = 0.1;
console.log(equal(x + z, y)); // true
```


然而，对于任何具有更大数量级的算术运算，`Number.EPSILON` 是不适用的。如果你的数据数量级在 103 的范围，那么小数部分的精确度将远远小于`Number.EPSILON`：


```js
function equal(x, y) {
  return Math.abs(x - y) < Number.EPSILON;
}

const x = 1000.1;
const y = 1000.2;
const z = 2000.3;
console.log(x + y); // 2000.3000000000002；误差为 10^-13 而不是 10^-16
console.log(equal(x + y, z)); // false
```


在这种情况下，需要更大的容差。由于进行比较的数字的数量级大约为 `2000`，使用类似于 `2000 * Number.EPSILON` 的乘积可以为此情况提供足够的容差。


```js
function equal(x, y, tolerance = Number.EPSILON) {
  return Math.abs(x - y) < tolerance;
}

const x = 1000.1;
const y = 1000.2;
const z = 2000.3;
console.log(equal(x + y, z, 2000 \* Number.EPSILON)); // true
```


除了数量级之外，考虑输入的*精度*也非常重要。例如，如果数字是从表单输入收集的，并且输入值只能以 `0.1` 的步长调整（即 `<input type="number" step="0.1">` (en-US)），通常可以允许更大的容差，例如 `0.01`，因为数据的精度只有 `0.1`。

**备注：** 重点是：不要简单地将 `Number.EPSILON` 作为相等性测试的阈值。使用适合要比较的数字的数量级和精度的阈值。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.epsilon |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Number.EPSILON` 的 polyfill
* `Number`
Number.parseInt()
=================

**`Number.parseInt()`** 静态方法解析一个字符串参数并返回一个指定基数的整数。

尝试一下
----

语法
--


```js
Number.parseInt(string)
Number.parseInt(string, radix)
```

### 参数

`string`

要被解析的值，会被强制转化为字符串。字符串开头的空白符将会被忽略。

`radix` 可选

`2` 到 `36` 之间的整数，表示 `string` 的*基数*（数学记数系统中的基）。

如果 `radix` 为 `undefined` 或 `0`，则 `radix` 将被默认设置为 `10`，除非该数字以码元对 `0x` 或 `0X` 开头，在这种情况下，`radix` 将被默认设置为 `16`。

### 返回值

从给定的 `string` 中解析出的一个整数。

如果 `radix` 小于 `2` 或大于 `36`，或第一个非空白字符不能转换为数字，则返回 `NaN`。

示例
--

### Number.parseInt 与 parseInt 对比

这个方法和全局的 `parseInt()` 函数具有相同的功能：


```js
Number.parseInt === parseInt; // true
```


其目的是对全局变量进行模块化，另见 `parseInt()` 获取更多详情和示例。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.parseint |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Number.parseInt` 的 polyfill
* `Number`
* `parseInt()`
Number.isNaN()
==============

**`Number.isNaN()`** 静态方法判断传入的值是否为 `NaN`，如果输入不是数字类型，则返回 `false`。它是全局 `isNaN()` 函数更健壮的版本。

尝试一下
----

语法
--


```js
Number.isNaN(value)
```

### 参数

`value`

要测试是否为 `NaN` 的值。

### 返回值

如果给定值是一个值为 `NaN` 的数字，则返回布尔值 `true`，否则返回 `false`。

描述
--

函数 `Number.isNaN()` 提供了一种方便的方法来检查值是否与 `NaN` 相等。请注意，你不能使用 `==` 或 `===` 运算符来测试值与 `NaN` 的相等性，因为与 JavaScript 中的其他值的比较不同，这些运算符在一个操作数为 `NaN` 时始终返回 `false`，即使另一个操作数也是 `NaN`。

由于在所有可能的 JavaScript 值中，`x !== x` 只有对于 `NaN` 才为真，因此 `Number.isNaN(x)` 也可以替换为 `x !== x`，尽管后者可读性较差。

与全局的 `isNaN()` 函数相反，`Number.isNaN()` 方法不会将参数强制转换为数字。这样可以安全地传入通常会转换为 `NaN` 但实际上与 `NaN` 不同的值。这也意味着只有等于 `NaN` 的 Number 类型的值才会返回 `true`。

示例
--

### 使用 isNaN()


```js
Number.isNaN(NaN); // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0); // true
Number.isNaN(37); // false
```

### Number.isNaN() 和全局 isNaN() 之间的区别

`Number.isNaN()` 不会尝试将参数转换为数字，因此非数字总是返回 `false`。以下都返回 `false`：


```js
Number.isNaN("NaN");
Number.isNaN(undefined);
Number.isNaN({});
Number.isNaN("blabla");
Number.isNaN(true);
Number.isNaN(null);
Number.isNaN("37");
Number.isNaN("37.37");
Number.isNaN("");
Number.isNaN(" ");
```


全局 `isNaN()` 函数会将参数强制转换为数字：


```js
isNaN("NaN"); // true
isNaN(undefined); // true
isNaN({}); // true
isNaN("blabla"); // true
isNaN(true); // false，强制转换为 1
isNaN(null); // false，强制转换为 0
isNaN("37"); // false，强制转换为 37
isNaN("37.37"); // false，强制转换为 37.37
isNaN(""); // false，强制转换为 0
isNaN(" "); // false，强制转换为 0
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isnan |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Number.isNaN` 的 polyfill
* `Number`
* `isNaN()`
Number.isInteger()
==================

**`Number.isInteger()`** 静态方法判断传入值是否为整数。

尝试一下
----

语法
--


```js
Number.isInteger(value)
```

### 参数

`value`

要测试是否为整数的值。

### 返回值

如果给定值是整数，则返回布尔值 `true`。否则为 `false`。

描述
--

如果目标值是一个整数，返回 `true`，否则返回 `false`。如果该值是 `NaN` 或者 `Infinity`，返回 `false`。对于可以表示为整数的浮点数，该方法也将返回 `true`。如果该值不是一个数字，该方法将始终返回 `false`。

请注意，一些数字字面量看起来像是非整数，但实际上却表示整数。这是由于 ECMAScript 浮点数编码（IEEE-754）的精度限制。例如，`5.0000000000000001` 只与 `5` 相差 `1e-16`，这个差值太小了而无法表示。（作为参考，`Number.EPSILON` 存储 1 与大于 1 的下一个可表示的浮点数之间的距离，大约为 `2.22e-16`。）因此，`5.0000000000000001` 将使用与 `5` 相同的编码表示，从而使得 `Number.isInteger(5.0000000000000001)` 返回 `true`。

在类似的意义上，接近 `Number.MAX_SAFE_INTEGER` 大小的数值会因精度损失而使得 `Number.isInteger` 在传入值实际上不是整数的情况下返回 `true`。（实际阈值根据需要表示小数所需的位数而变化——例如，`Number.isInteger(4500000000000000.1)` 为 `true`，但 `Number.isInteger(4500000000000000.5)` 为 `false`。）

示例
--

### 使用 isInteger


```js
Number.isInteger(0); // true
Number.isInteger(1); // true
Number.isInteger(-100000); // true
Number.isInteger(99999999999999999999999); // true

Number.isInteger(0.1); // false
Number.isInteger(Math.PI); // false

Number.isInteger(NaN); // 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

Number.isInteger(5.0); // true
Number.isInteger(5.000000000000001); // false
Number.isInteger(5.0000000000000001); // true，因为精度损失
Number.isInteger(4500000000000000.1); // true，因为精度损失
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isinteger |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Number.isInteger` 的 polyfill
* `Number`
Number.prototype.toExponential()
================================

`Number` 值的 **`toExponential()`** 方法返回一个以指数表示法表示该数字的字符串。

尝试一下
----

语法
--


```js
toExponential()
toExponential(fractionDigits)
```

### 参数

`fractionDigits` 可选

可选。一个整数，用来指定小数点后有几位数字。默认设置为完整表示该数字所需要的数字。

### 返回值

一个以指数表示法表示给定 `Number` 对象的的字符串，其小数点前为一位数字，小数点后舍入到 `fractionDigits` 位。

### 异常

`RangeError`

如果 `fractionDigits` 不是介于 `0` 和 `100` 之间（包含两端）的整数，则抛出该错误。

`TypeError`

如果在非 `Number` 对象上调用该方法，则抛出该错误。

描述
--

如果省略了 `fractionDigits` 参数，则小数点后的位数默认为精确表示该值的所需的位数。

如果你为一个没有指数也没有小数点的数字字面量使用 `toExponential()` 方法。请在方法调用之前的点之前留出空格，以防止该点被解释为小数点。

如果一个数字的位数比 `fractionDigits` 参数指定的位数更多，则该数字将被舍入为最接近的数字，请参阅 `toFixed()` 方法的描述中关于舍入的讨论，这也适用于 `toExponential()`。

示例
--

### 使用 toExponential


```js
const numObj = 77.1234;

console.log(numObj.toExponential()); // 7.71234e+1
console.log(numObj.toExponential(4)); // 7.7123e+1
console.log(numObj.toExponential(2)); // 7.71e+1
console.log((77.1234).toExponential()); // 7.71234e+1
console.log((77).toExponential()); // 7.7e+1
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.toexponential |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Number.prototype.toExponential` 的 polyfill，并对此方法进行了修复
* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()`
* `Number.prototype.toString()`
Number.parseFloat()
===================

**`Number.parseFloat()`** 静态方法解析参数并返回浮点数。如果无法从参数中解析出一个数字，则返回 `NaN`。

尝试一下
----

语法
--


```js
Number.parseFloat(string)
```

### 参数

`string`

要解析的值，会被强制转换为字符串。该参数开头的空白会被忽略。

### 返回值

由给定 `string` 解析得到的浮点数。

如果第一个非空白字符不能被转换为数字，则返回 `NaN`。

示例
--

### Number.parseFloat 与 parseFloat 对比

此方法与全局函数 `parseFloat()` 具有相同的功能：


```js
Number.parseFloat === parseFloat; // true
```


其目的是全局的模块化。

有关更多详细信息和示例，请参见 `parseFloat()`。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.parsefloat |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Number.parseFloat` 的 polyfill
* `Number`
* `parseFloat()`
Number.MAX\_VALUE
=================

**`Number.MAX_VALUE`** 静态数据属性表示在 JavaScript 中可表示的最大数值。

尝试一下
----

值
-

21024 - 1，或大约 `1.7976931348623157E+308`。

| `Number.MAX_VALUE` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

大于 `MAX_VALUE` 的值表示为 `Infinity` 并将丢失其实际值。

由于 `MAX_VALUE` 是 `Number` 对象的静态属性，你应该始终将其用作 `Number.MAX_VALUE`，而不是作为一个数字值的属性。

示例
--

### 使用 MAX\_VALUE

下面的代码对两个数值进行乘法运算。如果结果小于或等于 `MAX_VALUE`，则调用函数 `func1`；否则，调用函数 `func2`。


```js
if (num1 \* num2 <= Number.MAX\_VALUE) {
  func1();
} else {
  func2();
}
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.max\_value |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Number.MIN_VALUE`
* `Number`
Number.MAX\_SAFE\_INTEGER
=========================

**`Number.MAX_SAFE_INTEGER`** 静态数据属性表示在 JavaScript 中最大的安全整数（253 – 1）。

对于更大的整数，请考虑使用 `BigInt`。

尝试一下
----

值
-

`9007199254740991`（9,007,199,254,740,991，或者约 9 千万亿）。

| `Number.MAX_SAFE_INTEGER` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

双精度浮点格式只有 52 位用于表示尾数，因此它只能安全地表示介于 -(253 – 1) 和 253 – 1 之间的整数。本文中，“安全”指的是能够精确表示整数并正确比较它们。例如，`Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2` 的结果将为真，这在数学上是不正确的。有关更多信息，请参阅 `Number.isSafeInteger()`。

由于 `MAX_SAFE_INTEGER` 是 `Number` 的静态属性，你应该始终将其使用为 `Number.MAX_SAFE_INTEGER`，而不是一个数字值的属性。

示例
--

### MAX\_SAFE\_INTEGER 的返回值


```js
Number.MAX\_SAFE\_INTEGER; // 9007199254740991
```

### MAX\_SAFE\_INTEGER 和 EPSILON 之间的关系

`Number.EPSILON` 是 2-52，而 `MAX_SAFE_INTEGER` 是 253 – 1，它们都源自尾数的宽度，即 53 位（最高位始终为 1）。将它们相乘会得到一个非常接近但不等于 2 的值。


```js
Number.MAX\_SAFE\_INTEGER \* Number.EPSILON; // 1.9999999999999998
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.max\_safe\_integer |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Number.MAX_SAFE_INTEGER` 的 polyfill
* `Number.MIN_SAFE_INTEGER`
* `Number.isSafeInteger()`
* `BigInt`
Number.NaN
==========

**`Number.NaN`** 静态数据属性表示非数字值，等同于 `NaN`。有关 `NaN` 的行为的更多信息，请参阅全局属性的描述。

尝试一下
----

值
-

数字值 `NaN`。

| `Number.NaN` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

由于 `NaN` 是 `Number` 的静态属性，你应该始终将其用作 `Number.NaN`，而不是作为一个数字值的属性。

示例
--

### 检查值是否为数字


```js
function sanitize(x) {
  if (isNaN(x)) {
    return Number.NaN;
  }
  return x;
}
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.nan |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `NaN`
* `Number.isNaN()`
Number.POSITIVE\_INFINITY
=========================

**`Number.POSITIVE_INFINITY`** 静态数据属性表示正无穷大值。

尝试一下
----

值
-

与全局属性 `Infinity` 的值相同。

| `Number.POSITIVE_INFINITY` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

`Number.POSITIVE_INFINITY` 的表现同数学上的无穷大略有不同：

* 任何正值，包括 `POSITIVE_INFINITY`，乘以 `POSITIVE_INFINITY` 等于 `POSITIVE_INFINITY`。
* 任何负值，包括 `NEGATIVE_INFINITY`，除以 `POSITIVE_INFINITY` 等于 `NEGATIVE_INFINITY`。
* 任何正数除以 `POSITIVE_INFINITY` 都是正零（正如 IEEE 754 中所定义的）。
* 任何负数除以 `POSITIVE_INFINITY` 都是负零（正如 IEEE 754 中所定义的）。
* 零乘以 `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`。
* `Number.POSITIVE_INFINITY > x` 对于任何不是 `POSITIVE_INFINITY` 的数字 *x* 都为真。

你可以使用 `Number.POSITIVE_INFINITY` 属性来表示成功时返回有限数值的错误条件。不过，`NaN` 更适合于这种情况。

由于 `POSITIVE_INFINITY` 是 `Number` 的静态属性，你应该始终将其用作 `Number.POSITIVE_INFINITY`，而不是作为一个数字值的属性。

示例
--

### 使用 POSITIVE\_INFINITY

在下面的例子中，变量 `bigNumber` 被赋值为比最大值更大的数值。当 `if` 语句执行时，`bigNumber` 的值为 `Infinity`，所以在继续之前，`bigNumber` 被设置为一个更易于管理的值。


```js
let bigNumber = Number.MAX\_VALUE \* 2;

if (bigNumber === Number.POSITIVE\_INFINITY) {
  bigNumber = returnFinite();
}
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.positive\_infinity |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Number.NEGATIVE_INFINITY`
* `Number.isFinite()`
* `Infinity`
* `isFinite()`
Number.isSafeInteger()
======================

**`Number.isSafeInteger()`** 静态方法判断提供的值是否是一个*安全整数*。

尝试一下
----

语法
--


```js
Number.isSafeInteger(testValue)
```

### 参数

`testValue`

要测试是否为安全整数的值。

### 返回值

如果给定的值是一个安全整数，则返回布尔值 `true`。否则返回 `false`。

描述
--

安全整数由 -(253 - 1) 到 253 - 1 的所有整数组成，包含（±9,007,199,254,740,991）。安全整数是符合以下条件的整数：

* 可以精确地表示为 IEEE-754 双精度数，并且
* 其 IEEE-754 表示形式不能是舍入任何其他整数以适应 IEEE-754 表示形式的结果。

例如，253 - 1 是一个安全整数：它可以精确地表示，并且在任何 IEEE-754 舍入模式下都没有其他整数舍入结果为该整数。相比之下，253 *不是*一个安全整数：它可以在 IEEE-754 中精确地表示，但整数 253 + 1 不能直接在 IEEE-754 中表示，而是采用就近舍入和向零舍入时，会舍入到 253。

处理大约 9 千万亿左右的值时，需要使用任意精度算术库来实现完全精确性。有关浮点数表示的更多信息，请参阅程序员需要了解的浮点数算术知识。

对于更大的整数，请考虑使用 `BigInt` 类型。

示例
--

### 使用 isSafeInteger()


```js
Number.isSafeInteger(3); // true
Number.isSafeInteger(2 \*\* 53); // false
Number.isSafeInteger(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
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.issafeinteger |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Number.isSafeInteger` 的 polyfill
* `Number`
* `Number.MIN_SAFE_INTEGER`
* `Number.MAX_SAFE_INTEGER`
* `BigInt`