页面模式偏好

21 数字和日期

21.1 Number 对象

21.1.1 Number 构造函数

Number 构造函数：

  • 是 %Number%。
  • 是全局对象的 "Number" 属性的初始值。
  • 作为构造函数调用时，创建并初始化新的 Number 对象。
  • 作为函数而不是构造函数调用时执行类型转换。
  • 可以用作类定义的 extends 子句的值。希望继承指定 Number 行为的子类构造函数必须包含对 Number 构造函数的 super 调用，以创建并初始化具有 [[NumberData]] 内部槽的子类实例。

21.1.1.1 Number ( value )

调用时，此函数执行以下步骤：

  1. 如果存在 value，则
    1. 令 primitive 为 ? ToNumeric(value)。
    2. 如果 primitive 是 BigInt，则令 n 为 𝔽(ℝ(primitive))。
    3. 否则，令 n 为 primitive。
  2. 否则，
    1. 令 n 为 +0𝔽。
  3. 如果 NewTarget 是 undefined，则返回 n。
  4. 令 obj 为 ? OrdinaryCreateFromConstructor(NewTarget, "%Number.prototype%", « [[NumberData]] »)。
  5. 将 obj.[[NumberData]] 设置为 n。
  6. 返回 obj。

21.1.2 Number 构造函数的属性

Number 构造函数：

21.1.2.1 Number.EPSILON

Number.EPSILON 的值是 1 与可表示为 Number 值且大于 1 的最小值之间差值的 Number 值，其约为 2.2204460492503130808472633361816 × 10-16。

此属性具有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.1.2.2 Number.isFinite ( number )

此函数被调用时执行以下步骤：

  1. 如果 number 是有限 Number，返回 true。
  2. 返回 false。

21.1.2.3 Number.isInteger ( number )

此函数被调用时执行以下步骤：

  1. 如果 number 是整数 Number，返回 true。
  2. 返回 false。

21.1.2.4 Number.isNaN ( number )

此函数被调用时执行以下步骤：

  1. 如果 number 不是 Number，返回 false。
  2. 如果 number 是 NaN，返回 true。
  3. 返回 false。
 注

此函数与全局 isNaN 函数（19.2.3）的不同之处在于，它在确定其实参是否为 NaN 之前，不会将其实参转换为 Number。

21.1.2.5 Number.isSafeInteger ( number )

注

当且仅当整数 n 的 Number 值不是任何其他整数的 Number 值时，整数 n 才是“安全整数”。

此函数被调用时执行以下步骤：

  1. 如果 number 是整数 Number，那么
    1. 如果 abs(ℝ(number)) ≤ 253 - 1，返回 true。
  2. 返回 false。

21.1.2.6 Number.MAX_SAFE_INTEGER

注

由于 IEEE 754-2019 的精度限制所必需的舍入行为，每个大于 Number.MAX_SAFE_INTEGER 的整数的 Number 值都至少与另一个整数共享。因此，这类绝对值很大的整数不是安全的，不能保证能够精确表示为 Number 值，甚至不能保证彼此可区分。例如，9007199254740992 和 9007199254740993 的求值结果都是 Number 值 9007199254740992𝔽。

Number.MAX_SAFE_INTEGER 的值是 9007199254740991𝔽（𝔽(253 - 1)）。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.1.2.7 Number.MAX_VALUE

Number.MAX_VALUE 的值是最大的正有限 Number，约为 1.7976931348623157 × 10308。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.1.2.8 Number.MIN_SAFE_INTEGER

注

由于 IEEE 754-2019 的精度限制所必需的舍入行为，每个小于 Number.MIN_SAFE_INTEGER 的整数的 Number 值都至少与另一个整数共享。因此，这类绝对值很大的整数不是安全的，不能保证能够精确表示为 Number 值，甚至不能保证彼此可区分。例如，-9007199254740992 和 -9007199254740993 的求值结果都是 Number 值 -9007199254740992𝔽。

Number.MIN_SAFE_INTEGER 的值是 -9007199254740991𝔽（𝔽(-(253 - 1))）。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.1.2.9 Number.MIN_VALUE

Number.MIN_VALUE 的值是 Number 类型中最小的正值，约为 5 × 10-324。

在 IEEE 754-2019 双精度二进制表示中，可能的最小值是非规格化数。如果某个实现不支持非规格化值，则 Number.MIN_VALUE 的值必须是该实现实际能够表示的最小非零正值。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.1.2.10 Number.NaN

Number.NaN 的值是 NaN。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.1.2.11 Number.NEGATIVE_INFINITY

Number.NEGATIVE_INFINITY 的值是 -∞𝔽。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.1.2.12 Number.parseFloat ( string )

"parseFloat" 属性的初始值是 %parseFloat%。

21.1.2.13 Number.parseInt ( string, radix )

"parseInt" 属性的初始值是 %parseInt%。

21.1.2.14 Number.POSITIVE_INFINITY

Number.POSITIVE_INFINITY 的值是 +∞𝔽。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.1.2.15 Number.prototype

Number.prototype 的初始值是 Number 原型对象。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.1.3 Number 原型对象的属性

Number 原型对象：

  • 是 %Number.prototype%。
  • 是普通对象。
  • 其自身是 Number 对象；它具有值为 +0𝔽 的 [[NumberData]] 内部槽。
  • 具有值为 %Object.prototype% 的 [[Prototype]] 内部槽。

除非另有明确说明，否则下面定义的 Number 原型对象的方法不是泛型方法，并且传递给它们的 this 值必须是 Number 值，或者是具有已初始化为 Number 值的 [[NumberData]] 内部槽的对象。

在方法规范中，短语“此 Number 值”是指以方法调用的 this 值作为实参调用抽象操作 ThisNumberValue 所返回的结果。

21.1.3.1 Number.prototype.constructor

Number.prototype.constructor 的初始值是 %Number%。

21.1.3.2 Number.prototype.toExponential ( fractionDigits )

此方法返回一个 String，其中包含以十进制指数记数法表示的此 Number 值，有效数的小数点前有一位数字，小数点后有 fractionDigits 位数字。如果 fractionDigits 是 undefined，则它包含唯一指定该 Number 所需的尽可能多的有效数数字（与 ToString 中一样，只是在这种情况下 Number 总是以指数记数法输出）。

它被调用时执行以下步骤：

  1. 令 number 为 ? ThisNumberValue(this value)。
  2. 令 fractionCount 为 ? ToIntegerOrInfinity(fractionDigits)。
  3. 断言：如果 fractionDigits 是 undefined，那么 fractionCount 是 0。
  4. 如果 number 不是有限 Number，返回 Number::toString(number, 10)。
  5. 如果 fractionCount 不是整数，抛出 RangeError 异常。
  6. 如果 fractionCount < 0 或 fractionCount > 100，抛出 RangeError 异常。
  7. 将 number 设置为 ℝ(number)。
  8. 令 sign 为空 String。
  9. 如果 number < 0，那么
    1. 将 sign 设置为 "-"。
    2. 将 number 设置为 -number。
  10. 如果 number = 0，那么
    1. 令 significand 为由 fractionCount + 1 个码元 0x0030 (DIGIT ZERO) 组成的 String 值。
    2. 令 exponent 为 0。
  11. 否则，
    1. 如果 fractionDigits 不是 undefined，那么
      1. 令 exponent 和 intSignificand 为满足 10fractionCount ≤ intSignificand < 10fractionCount + 1 且使 intSignificand × 10exponent - fractionCount - number 尽可能接近零的整数。如果有两组这样的 exponent 和 intSignificand，选择使 intSignificand × 10exponent - fractionCount 较大的那组 exponent 和 intSignificand。
    2. 否则，
      1. 令 exponent、intSignificand 和 ff 为满足 ff ≥ 0、10ff ≤ intSignificand < 10ff + 1、𝔽(intSignificand × 10exponent - ff) 是 𝔽(number)，且 ff 尽可能小的整数。请注意，intSignificand 的十进制表示有 ff + 1 位数字，intSignificand 不能被 10 整除，并且根据这些条件，intSignificand 的最低有效位数字不一定唯一确定。
      2. 将 fractionCount 设置为 ff。
    3. 令 significand 为由 intSignificand 的十进制表示的数字（按顺序且无前导零）组成的 String 值。
  12. 如果 fractionCount ≠ 0，那么
    1. 令 intPart 为 significand 的第一个码元。
    2. 令 fractionalPart 为 significand 的其余 fractionCount 个码元。
    3. 将 significand 设置为 intPart、"." 和 fractionalPart 的字符串连接。
  13. 如果 exponent = 0，那么
    1. 令 exponentSign 为 "+"。
    2. 令 exponentDigits 为 "0"。
  14. 否则，
    1. 如果 exponent > 0，那么
      1. 令 exponentSign 为 "+"。
    2. 否则，
      1. 断言：exponent < 0。
      2. 令 exponentSign 为 "-"。
      3. 将 exponent 设置为 -exponent。
    3. 令 exponentDigits 为由 exponent 的十进制表示的数字（按顺序且无前导零）组成的 String 值。
  15. 将 significand 设置为 significand、"e"、exponentSign 和 exponentDigits 的字符串连接。
  16. 返回 sign 和 significand 的字符串连接。
 注

对于提供比上述规则所要求的转换更精确的实现，建议使用步骤 11.b.i 的以下替代版本作为指导：

  1. 令 exponent、intSignificand 和 ff 为满足 ff ≥ 0、10ff ≤ intSignificand < 10ff + 1、𝔽(intSignificand × 10exponent - ff) 是 𝔽(number)，且 ff 尽可能小的整数。如果 intSignificand 有多个可能值，则选择使 𝔽(intSignificand × 10exponent - ff) 最接近 𝔽(number) 的 intSignificand。如果有两个这样的 intSignificand 可能值，则选择其中的偶数。

21.1.3.3 Number.prototype.toFixed ( fractionDigits )

注 1

此方法返回一个 String，其中包含以十进制定点记数法表示的此 Number 值，小数点后有 fractionDigits 位数字。如果 fractionDigits 是 undefined，则假定为 0。

它被调用时执行以下步骤：

  1. 令 number 为 ? ThisNumberValue(this value)。
  2. 令 fractionCount 为 ? ToIntegerOrInfinity(fractionDigits)。
  3. 断言：如果 fractionDigits 是 undefined，那么 fractionCount 是 0。
  4. 如果 fractionCount 不是整数，抛出 RangeError 异常。
  5. 如果 fractionCount < 0 或 fractionCount > 100，抛出 RangeError 异常。
  6. 如果 number 不是有限 Number，返回 Number::toString(number, 10)。
  7. 将 number 设置为 ℝ(number)。
  8. 令 sign 为空 String。
  9. 如果 number < 0，那么
    1. 将 sign 设置为 "-"。
    2. 将 number 设置为 -number。
  10. 如果 number ≥ 1021，那么
    1. 令 digitString 为 ! ToString(𝔽(number))。
  11. 否则，
    1. 令 intValue 为使 intValue / 10fractionCount - number 尽可能接近零的整数。如果有两个这样的 intValue，选择较大的 intValue。
    2. 如果 intValue = 0，令 digitString 为 "0"；否则令 digitString 为由 intValue 的十进制表示的数字（按顺序且无前导零）组成的 String 值。
    3. 如果 fractionCount ≠ 0，那么
      1. 令 digitCount 为 digitString 的长度。
      2. 如果 digitCount ≤ fractionCount，那么
        1. 令 zeroPad 为由 fractionCount + 1 - digitCount 个码元 0x0030 (DIGIT ZERO) 组成的 String 值。
        2. 将 digitString 设置为 zeroPad 和 digitString 的字符串连接。
        3. 将 digitCount 设置为 fractionCount + 1。
      3. 令 intPart 为 digitString 的前 digitCount - fractionCount 个码元。
      4. 令 fractionalPart 为 digitString 的其余 fractionCount 个码元。
      5. 将 digitString 设置为 intPart、"." 和 fractionalPart 的字符串连接。
  12. 返回 sign 和 digitString 的字符串连接。
 注 2

对于某些值，toFixed 的输出可能比 toString 更精确，因为 toString 只打印足以将该数与相邻 Number 值区分开的有效数字。例如，

(1000000000000000128).toString() 返回 "1000000000000000100"，而
(1000000000000000128).toFixed(0) 返回 "1000000000000000128"。

21.1.3.4 Number.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )

包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 中的规定实现此方法。否则，使用此方法的以下规范：

此方法产生一个 String 值，表示根据宿主环境当前区域设置的约定格式化的此 Number 值。此方法是实现定义的，允许但不鼓励它返回与 toString 相同的结果。

此方法可选参数的含义在 ECMA-402 中定义；不包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。

21.1.3.5 Number.prototype.toPrecision ( precision )

此方法返回一个 String，其中包含以十进制指数记数法表示的此 Number 值，有效数的小数点前有一位数字，小数点后有 precision - 1 位数字；或者以十进制定点记数法表示，具有 precision 位有效数字。如果 precision 是 undefined，则改为调用 ToString。

它被调用时执行以下步骤：

  1. 令 number 为 ? ThisNumberValue(this value)。
  2. 如果 precision 是 undefined，返回 ! ToString(number)。
  3. 令 precisionCount 为 ? ToIntegerOrInfinity(precision)。
  4. 如果 number 不是有限 Number，返回 Number::toString(number, 10)。
  5. 如果 precisionCount 不是整数，抛出 RangeError 异常。
  6. 如果 precisionCount < 1 或 precisionCount > 100，抛出 RangeError 异常。
  7. 将 number 设置为 ℝ(number)。
  8. 令 sign 为空 String。
  9. 如果 number < 0，那么
    1. 将 sign 设置为码元 0x002D (HYPHEN-MINUS)。
    2. 将 number 设置为 -number。
  10. 如果 number = 0，那么
    1. 令 significand 为由 precisionCount 个码元 0x0030 (DIGIT ZERO) 组成的 String 值。
    2. 令 exponent 为 0。
  11. 否则，
    1. 令 exponent 和 intSignificand 为满足 10precisionCount - 1 ≤ intSignificand < 10precisionCount 且使 intSignificand × 10exponent - precisionCount + 1 - number 尽可能接近零的整数。如果有两组这样的 exponent 和 intSignificand，选择使 intSignificand × 10exponent - precisionCount + 1 较大的那组 exponent 和 intSignificand。
    2. 令 significand 为由 intSignificand 的十进制表示的数字（按顺序且无前导零）组成的 String 值。
    3. 如果 exponent < -6 或 exponent ≥ precisionCount，那么
      1. 断言：exponent ≠ 0。
      2. 如果 precisionCount ≠ 1，那么
        1. 令 intPart 为 significand 的第一个码元。
        2. 令 fractionalPart 为 significand 的其余 precisionCount - 1 个码元。
        3. 将 significand 设置为 intPart、"." 和 fractionalPart 的字符串连接。
      3. 如果 exponent > 0，那么
        1. 令 exponentSign 为码元 0x002B (PLUS SIGN)。
      4. 否则，
        1. 断言：exponent < 0。
        2. 令 exponentSign 为码元 0x002D (HYPHEN-MINUS)。
        3. 将 exponent 设置为 -exponent。
      5. 令 exponentDigits 为由 exponent 的十进制表示的数字（按顺序且无前导零）组成的 String 值。
      6. 返回 sign、significand、码元 0x0065 (LATIN SMALL LETTER E)、exponentSign 和 exponentDigits 的字符串连接。
  12. 如果 exponent = precisionCount - 1，返回 sign 和 significand 的字符串连接。
  13. 如果 exponent ≥ 0，那么
    1. 将 significand 设置为 significand 的前 exponent + 1 个码元、码元 0x002E (FULL STOP) 和其余 precisionCount - (exponent + 1) 个码元的字符串连接。
  14. 否则，
    1. 将 significand 设置为码元 0x0030 (DIGIT ZERO)、码元 0x002E (FULL STOP)、-(exponent + 1) 个码元 0x0030 (DIGIT ZERO) 和 String significand 的字符串连接。
  15. 返回 sign 和 significand 的字符串连接。

21.1.3.6 Number.prototype.toString ( [ radix ] )

注

可选的 radix 应当是从 2𝔽 到 36𝔽 的闭区间内的整数 Number 值。如果 radix 是 undefined，则使用 10𝔽 作为 radix 的值。

此方法被调用时执行以下步骤：

  1. 令 x 为 ? ThisNumberValue(this value)。
  2. 如果 radix 是 undefined，令 radixMV 为 10。
  3. 否则，令 radixMV 为 ? SnapToInteger(radix, truncate, 2, 36)。
  4. 返回 Number::toString(x, radixMV)。

此方法不是泛型方法；如果其 this 值不是 Number 或 Number 对象，它会抛出 TypeError 异常。因此，不能将它转移到其他种类的对象上作为方法使用。

此方法的 "length" 属性是 1𝔽。

21.1.3.7 Number.prototype.valueOf ( )

  1. 返回 ? ThisNumberValue(this value)。

21.1.3.7.1 ThisNumberValue ( arg )

抽象操作 ThisNumberValue，接收参数 arg (一个 ECMAScript 语言值，)；返回值：包含 Number 的正常完成或抛出完成。 调用时执行以下步骤：

  1. 如果 arg 是 Number，返回 arg。
  2. 如果 arg 是 Object 且 arg 具有 [[NumberData]] 内部槽，那么
    1. 令 number 为 arg.[[NumberData]]。
    2. 断言：number 是 Number。
    3. 返回 number。
  3. 抛出 TypeError 异常。

21.1.4 Number 实例的属性

Number 实例是从 Number 原型对象继承属性的普通对象。Number 实例还具有 [[NumberData]] 内部槽。[[NumberData]] 内部槽是此 Number 对象所表示的 Number 值。

21.2 BigInt 对象

21.2.1 BigInt 构造函数

BigInt 构造函数：

  • 是 %BigInt%。
  • 是全局对象的 "BigInt" 属性的初始值。
  • 作为函数而不是构造函数调用时执行类型转换。
  • 不旨在与 new 运算符一起使用或被子类化。它可以用作类定义的 extends 子句的值，但对 BigInt 构造函数的 super 调用将导致异常。

21.2.1.1 BigInt ( value )

此函数被调用时执行以下步骤：

  1. 如果 NewTarget 不是 undefined，抛出 TypeError 异常。
  2. 令 primitive 为 ? ToPrimitive(value, number)。
  3. 如果 primitive 是 Number，返回 ? NumberToBigInt(primitive)。
  4. 返回 ? ToBigInt(primitive)。

21.2.1.1.1 NumberToBigInt ( number )

抽象操作 NumberToBigInt，接收参数 number (一个 Number，)；返回值：包含 BigInt 的正常完成或抛出完成。 调用时执行以下步骤：

  1. 如果 number 不是整数 Number，抛出 RangeError 异常。
  2. 返回 ℤ(ℝ(number))。

21.2.2 BigInt 构造函数的属性

BigInt 构造函数：

21.2.2.1 BigInt.asIntN ( bits, bigint )

此函数被调用时执行以下步骤：

  1. 将 bits 设置为 ? ToIndex(bits)。
  2. 将 bigint 设置为 ? ToBigInt(bigint)。
  3. 令 remainder 为 ℝ(bigint) modulo 2bits。
  4. 如果 remainder ≥ 2bits - 1，返回 ℤ(remainder - 2bits)。
  5. 返回 ℤ(remainder)。

21.2.2.2 BigInt.asUintN ( bits, bigint )

此函数被调用时执行以下步骤：

  1. 将 bits 设置为 ? ToIndex(bits)。
  2. 将 bigint 设置为 ? ToBigInt(bigint)。
  3. 返回 ℤ(ℝ(bigint) modulo 2bits)。

21.2.2.3 BigInt.prototype

BigInt.prototype 的初始值是 BigInt 原型对象。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.2.3 BigInt 原型对象的属性

BigInt 原型对象：

  • 是 %BigInt.prototype%。
  • 是普通对象。
  • 不是 BigInt 对象；它没有 [[BigIntData]] 内部槽。
  • 具有值为 %Object.prototype% 的 [[Prototype]] 内部槽。

在方法规范中，短语“此 BigInt 值”是指以方法调用的 this 值作为实参调用抽象操作 ThisBigIntValue 所返回的结果。

21.2.3.1 BigInt.prototype.constructor

BigInt.prototype.constructor 的初始值是 %BigInt%。

21.2.3.2 BigInt.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )

包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 中的规定实现此方法。否则，使用此方法的以下规范：

此方法产生一个 String 值，表示根据宿主环境当前区域设置的约定格式化的此 BigInt 值。此方法是实现定义的，允许但不鼓励它返回与 toString 相同的结果。

此方法可选参数的含义在 ECMA-402 中定义；不包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。

21.2.3.3 BigInt.prototype.toString ( [ radix ] )

注

可选的 radix 应当是从 2𝔽 到 36𝔽 的闭区间内的整数 Number 值。如果 radix 是 undefined，则使用 10𝔽 作为 radix 的值。

此方法被调用时执行以下步骤：

  1. 令 x 为 ? ThisBigIntValue(this value)。
  2. 如果 radix 是 undefined，令 radixMV 为 10。
  3. 否则，令 radixMV 为 ? SnapToInteger(radix, truncate, 2, 36)。
  4. 返回 BigInt::toString(x, radixMV)。

此方法不是泛型方法；如果其 this 值不是 BigInt 或 BigInt 对象，它会抛出 TypeError 异常。因此，不能将它转移到其他种类的对象上作为方法使用。

21.2.3.4 BigInt.prototype.valueOf ( )

  1. 返回 ? ThisBigIntValue(this value)。

21.2.3.4.1 ThisBigIntValue ( arg )

抽象操作 ThisBigIntValue，接收参数 arg (一个 ECMAScript 语言值，)；返回值：包含 BigInt 的正常完成或抛出完成。 调用时执行以下步骤：

  1. 如果 arg 是 BigInt，返回 arg。
  2. 如果 arg 是 Object 且 arg 具有 [[BigIntData]] 内部槽，那么
    1. 断言：arg.[[BigIntData]] 是 BigInt。
    2. 返回 arg.[[BigIntData]]。
  3. 抛出 TypeError 异常。

21.2.3.5 BigInt.prototype [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是 String 值 "BigInt"。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

21.2.4 BigInt 实例的属性

BigInt 实例是从 BigInt 原型对象继承属性的普通对象。BigInt 实例还具有 [[BigIntData]] 内部槽。[[BigIntData]] 内部槽是此 BigInt 对象所表示的 BigInt 值。

21.3 Math 对象

Math 对象：

注

在本规范中，短语“x 的 Number 值”具有在 6.1.6.1 中定义的技术含义。

21.3.1 Math 对象的值属性

21.3.1.1 Math.E

自然对数底数 e 的 Number 值，约为 2.7182818284590452354。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.3.1.2 Math.LN10

10 的自然对数的 Number 值，约为 2.302585092994046。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.3.1.3 Math.LN2

2 的自然对数的 Number 值，约为 0.6931471805599453。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.3.1.4 Math.LOG10E

自然对数底数 e 的以 10 为底的对数的 Number 值；此值约为 0.4342944819032518。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

注

Math.LOG10E 的值约为 Math.LN10 的值的倒数。

21.3.1.5 Math.LOG2E

自然对数底数 e 的以 2 为底的对数的 Number 值；此值约为 1.4426950408889634。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

注

Math.LOG2E 的值约为 Math.LN2 的值的倒数。

21.3.1.6 Math.PI

π（圆的周长与其直径之比）的 Number 值，约为 3.1415926535897932。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.3.1.7 Math.SQRT1_2

½ 的平方根的 Number 值，约为 0.7071067811865476。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

注

Math.SQRT1_2 的值约为 Math.SQRT2 的值的倒数。

21.3.1.8 Math.SQRT2

2 的平方根的 Number 值，约为 1.4142135623730951。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.3.1.9 Math [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是 String 值 "Math"。

此属性具有属性特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

21.3.2 Math 对象的函数属性

注

这里没有精确定义函数 acos、acosh、asin、asinh、atan、atanh、atan2、cbrt、cos、cosh、exp、expm1、hypot、log、log1p、log2、log10、pow、random、sin、sinh、tan 和 tanh 的行为，只要求它们针对表示所关注边界情况的某些实参值产生特定结果。对于其他实参值，这些函数旨在计算熟悉的数学函数结果的近似值，但允许在近似算法的选择上有一定余地。总体意图是，实现者应当能够在给定硬件平台上为 ECMAScript 使用该平台上 C 程序员可用的同一数学库。

虽然算法的选择留给实现，但建议（本标准并未规定）实现使用 Sun Microsystems 的可自由分发数学库 fdlibm 中包含的 IEEE 754-2019 算术近似算法（http://www.netlib.org/fdlibm）。

21.3.2.1 Math.abs ( x )

此函数返回 x 的绝对值；结果与 x 大小相同，但符号为正。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN，返回 NaN。
  3. 如果 n 是 -0𝔽，返回 +0𝔽。
  4. 如果 n 是 -∞𝔽，返回 +∞𝔽。
  5. 如果 n < -0𝔽，返回 -n。
  6. 返回 n。

21.3.2.2 Math.acos ( x )

此函数返回 x 的反余弦。结果以弧度表示，并位于从 +0𝔽 到 𝔽(π) 的闭区间内。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN、n > 1𝔽 或 n < -1𝔽，返回 NaN。
  3. 如果 n 是 1𝔽，返回 +0𝔽。
  4. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的反余弦。

21.3.2.3 Math.acosh ( x )

此函数返回 x 的反双曲余弦。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN 或 +∞𝔽，返回 n。
  3. 如果 n 是 1𝔽，返回 +0𝔽。
  4. 如果 n < 1𝔽，返回 NaN。
  5. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的反双曲余弦。

21.3.2.4 Math.asin ( x )

此函数返回 x 的反正弦。结果以弧度表示，并位于从 𝔽(-π / 2) 到 𝔽(π / 2) 的闭区间内。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN、+0𝔽 或 -0𝔽 之一，返回 n。
  3. 如果 n > 1𝔽 或 n < -1𝔽，返回 NaN。
  4. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的反正弦。

21.3.2.5 Math.asinh ( x )

此函数返回 x 的反双曲正弦。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 不是有限 Number，或 n 是 +0𝔽 或 -0𝔽，返回 n。
  3. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的反双曲正弦。

21.3.2.6 Math.atan ( x )

此函数返回 x 的反正切。结果以弧度表示，并位于从 𝔽(-π / 2) 到 𝔽(π / 2) 的闭区间内。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN、+0𝔽 或 -0𝔽 之一，返回 n。
  3. 如果 n 是 +∞𝔽，返回一个由实现近似得到的 Number 值，该值表示 π / 2。
  4. 如果 n 是 -∞𝔽，返回一个由实现近似得到的 Number 值，该值表示 -π / 2。
  5. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的反正切。

21.3.2.7 Math.atanh ( x )

此函数返回 x 的反双曲正切。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN、+0𝔽 或 -0𝔽 之一，返回 n。
  3. 如果 n > 1𝔽 或 n < -1𝔽，返回 NaN。
  4. 如果 n 是 1𝔽，返回 +∞𝔽。
  5. 如果 n 是 -1𝔽，返回 -∞𝔽。
  6. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的反双曲正切。

21.3.2.8 Math.atan2 ( y, x )

此函数返回实参 y 和 x 的商 y / x 的反正切，其中使用 y 和 x 的符号来确定结果所在的象限。请注意，对于双实参反正切函数，将名为 y 的实参置于第一位而将名为 x 的实参置于第二位是有意且符合传统的。结果以弧度表示，并位于从 -π 到 +π 的闭区间内。

它被调用时执行以下步骤：

  1. 令 ny 为 ? ToNumber(y)。
  2. 令 nx 为 ? ToNumber(x)。
  3. 如果 ny 是 NaN 或 nx 是 NaN，返回 NaN。
  4. 如果 ny 是 +∞𝔽，那么
    1. 如果 nx 是 +∞𝔽，返回一个由实现近似得到的 Number 值，该值表示 π / 4。
    2. 如果 nx 是 -∞𝔽，返回一个由实现近似得到的 Number 值，该值表示 3π / 4。
    3. 返回一个由实现近似得到的 Number 值，该值表示 π / 2。
  5. 如果 ny 是 -∞𝔽，那么
    1. 如果 nx 是 +∞𝔽，返回一个由实现近似得到的 Number 值，该值表示 -π / 4。
    2. 如果 nx 是 -∞𝔽，返回一个由实现近似得到的 Number 值，该值表示 -3π / 4。
    3. 返回一个由实现近似得到的 Number 值，该值表示 -π / 2。
  6. 如果 ny 是 +0𝔽，那么
    1. 如果 nx > +0𝔽 或 nx 是 +0𝔽，返回 +0𝔽。
    2. 返回一个由实现近似得到的 Number 值，该值表示 π。
  7. 如果 ny 是 -0𝔽，那么
    1. 如果 nx > +0𝔽 或 nx 是 +0𝔽，返回 -0𝔽。
    2. 返回一个由实现近似得到的 Number 值，该值表示 -π。
  8. 断言：ny 是有限 Number，且既不是 +0𝔽 也不是 -0𝔽。
  9. 如果 ny > +0𝔽，那么
    1. 如果 nx 是 +∞𝔽，返回 +0𝔽。
    2. 如果 nx 是 -∞𝔽，返回一个由实现近似得到的 Number 值，该值表示 π。
    3. 如果 nx 是 +0𝔽 或 -0𝔽，返回一个由实现近似得到的 Number 值，该值表示 π / 2。
  10. 如果 ny < -0𝔽，那么
    1. 如果 nx 是 +∞𝔽，返回 -0𝔽。
    2. 如果 nx 是 -∞𝔽，返回一个由实现近似得到的 Number 值，该值表示 -π。
    3. 如果 nx 是 +0𝔽 或 -0𝔽，返回一个由实现近似得到的 Number 值，该值表示 -π / 2。
  11. 断言：nx 是有限 Number，且既不是 +0𝔽 也不是 -0𝔽。
  12. 令 result 为 abs(ℝ(ny) / ℝ(nx)) 的反正切。
  13. 如果 nx < -0𝔽，那么
    1. 如果 ny > +0𝔽，将 result 设置为 π - result。
    2. 否则，将 result 设置为 -π + result。
  14. 否则，
    1. 如果 ny < -0𝔽，将 result 设置为 -result。
  15. 返回一个由实现近似得到的 Number 值，该值表示 result。

21.3.2.9 Math.cbrt ( x )

此函数返回 x 的立方根。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 不是有限 Number，或 n 是 +0𝔽 或 -0𝔽，返回 n。
  3. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的立方根。

21.3.2.10 Math.ceil ( x )

此函数返回不小于 x 的最小（最接近 -∞ 的）整数 Number 值。如果 x 已经是整数 Number，则结果为 x。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 不是有限 Number，或 n 是 +0𝔽 或 -0𝔽，返回 n。
  3. 如果 n < -0𝔽 且 n > -1𝔽，返回 -0𝔽。
  4. 如果 n 是整数 Number，返回 n。
  5. 返回不小于 n 的最小（最接近 -∞ 的）整数 Number 值。
 注

Math.ceil(x) 的值与 -Math.floor(-x) 的值相同。

21.3.2.11 Math.clz32 ( x )

此函数被调用时执行以下步骤：

  1. 令 n 为 ? ToUint32(x)。
  2. 令 p 为 n 的无符号 32 位二进制表示中的前导零位数。
  3. 返回 𝔽(p)。
 注

如果 n 是 +0𝔽 或 -0𝔽，此方法返回 32𝔽。如果 n 的 32 位二进制编码的最高有效位是 1，此方法返回 +0𝔽。

21.3.2.12 Math.cos ( x )

此函数返回 x 的余弦。实参以弧度表示。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 不是有限 Number，返回 NaN。
  3. 如果 n 是 +0𝔽 或 -0𝔽，返回 1𝔽。
  4. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的余弦。

21.3.2.13 Math.cosh ( x )

此函数返回 x 的双曲余弦。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN，返回 NaN。
  3. 如果 n 是 +∞𝔽 或 -∞𝔽，返回 +∞𝔽。
  4. 如果 n 是 +0𝔽 或 -0𝔽，返回 1𝔽。
  5. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的双曲余弦。
 注

Math.cosh(x) 的值与 (Math.exp(x) + Math.exp(-x)) / 2 的值相同。

21.3.2.14 Math.exp ( x )

此函数返回 x 的指数函数（e 的 x 次幂，其中 e 是自然对数的底数）。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN 或 +∞𝔽，返回 n。
  3. 如果 n 是 +0𝔽 或 -0𝔽，返回 1𝔽。
  4. 如果 n 是 -∞𝔽，返回 +0𝔽。
  5. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的指数函数。

21.3.2.15 Math.expm1 ( x )

此函数返回从 x 的指数函数（e 的 x 次幂，其中 e 是自然对数的底数）中减去 1 的结果。即使 x 的值接近 0，结果也以保持精确的方式计算。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN、+0𝔽、-0𝔽 或 +∞𝔽 之一，返回 n。
  3. 如果 n 是 -∞𝔽，返回 -1𝔽。
  4. 令 exp 为 ℝ(n) 的指数函数。
  5. 返回一个由实现近似得到的 Number 值，该值表示 exp - 1。

21.3.2.16 Math.floor ( x )

此函数返回不大于 x 的最大（最接近 +∞ 的）整数 Number 值。如果 x 已经是整数 Number，则结果为 x。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 不是有限 Number，或 n 是 +0𝔽 或 -0𝔽，返回 n。
  3. 如果 n < 1𝔽 且 n > +0𝔽，返回 +0𝔽。
  4. 如果 n 是整数 Number，返回 n。
  5. 返回不大于 n 的最大（最接近 +∞ 的）整数 Number 值。
 注

Math.floor(x) 的值与 -Math.ceil(-x) 的值相同。

21.3.2.17 Math.fround ( x )

此函数被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN，返回 NaN。
  3. 如果 n 是 +0𝔽、-0𝔽、+∞𝔽 或 -∞𝔽 之一，返回 n。
  4. 令 n32 为使用 roundTiesToEven 模式将 n 转换为 IEEE 754-2019 binary32 格式的结果。
  5. 令 n64 为将 n32 转换为 IEEE 754-2019 binary64 格式的结果。
  6. 返回与 n64 对应的 ECMAScript Number 值。

21.3.2.18 Math.f16round ( x )

此函数被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN，返回 NaN。
  3. 如果 n 是 +0𝔽、-0𝔽、+∞𝔽 或 -∞𝔽 之一，返回 n。
  4. 令 n16 为使用 roundTiesToEven 模式将 n 转换为 IEEE 754-2019 binary16 格式的结果。
  5. 令 n64 为将 n16 转换为 IEEE 754-2019 binary64 格式的结果。
  6. 返回与 n64 对应的 ECMAScript Number 值。
 注

由于可能发生双重舍入，此操作与先转换为 binary32 再转换为 binary16 并不相同：例如，考虑数 k = 1.00048828125000022204𝔽，对于它，Math.f16round(k) 是 1.0009765625𝔽，但 Math.f16round(Math.fround(k)) 是 1𝔽。

并非所有平台都提供从 binary64 转换为 binary16 的原生支持。有各种库可以提供此功能，包括采用 MIT 许可证的 half 库。另一种方法是，首先在 roundTiesToEven 下从 binary64 转换为 binary32，然后检查结果是否可能导致错误的双重舍入。可以通过调整 binary32 值的尾数来显式处理这些情况，使其成为在 roundTiesToOdd 下执行初始转换时会产生的值。随后在 roundTiesToEven 下将调整后的值转换为 binary16，即可产生正确的值。

21.3.2.19 Math.hypot ( ...args )

给定零个或多个实参，此函数返回其实参平方和的平方根。

它被调用时执行以下步骤：

  1. 令 coerced 为一个新的空 List。
  2. 对 args 的每个元素 arg，执行
    1. 令 n 为 ? ToNumber(arg)。
    2. 将 n 追加到 coerced。
  3. 对 coerced 的每个元素 number，执行
    1. 如果 number 是 +∞𝔽 或 -∞𝔽，返回 +∞𝔽。
  4. 令 onlyZero 为 true。
  5. 对 coerced 的每个元素 number，执行
    1. 如果 number 是 NaN，返回 NaN。
    2. 如果 number 既不是 +0𝔽 也不是 -0𝔽，将 onlyZero 设置为 false。
  6. 如果 onlyZero 是 true，返回 +0𝔽。
  7. 返回一个由实现近似得到的 Number 值，该值表示 coerced 中各元素的数学值的平方和的平方根。

此函数的 "length" 属性是 2𝔽。

注

当使用两个或更多实参调用此函数时，实现应当注意避免朴素实现中容易发生的上溢和下溢所导致的精度损失。

21.3.2.20 Math.imul ( x, y )

此函数被调用时执行以下步骤：

  1. 令 a 为 ℝ(? ToUint32(x))。
  2. 令 b 为 ℝ(? ToUint32(y))。
  3. 令 product 为 (a × b) modulo 232。
  4. 如果 product ≥ 231，返回 𝔽(product - 232)。
  5. 返回 𝔽(product)。

21.3.2.21 Math.log ( x )

此函数返回 x 的自然对数。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN 或 +∞𝔽，返回 n。
  3. 如果 n 是 1𝔽，返回 +0𝔽。
  4. 如果 n 是 +0𝔽 或 -0𝔽，返回 -∞𝔽。
  5. 如果 n < -0𝔽，返回 NaN。
  6. 返回一个由实现近似得到的 Number 值，该值表示 ln(ℝ(n))。

21.3.2.22 Math.log1p ( x )

此函数返回 1 + x 的自然对数。即使 x 的值接近零，结果也以保持精确的方式计算。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN、+0𝔽、-0𝔽 或 +∞𝔽 之一，返回 n。
  3. 如果 n 是 -1𝔽，返回 -∞𝔽。
  4. 如果 n < -1𝔽，返回 NaN。
  5. 返回一个由实现近似得到的 Number 值，该值表示 ln(1 + ℝ(n))。

21.3.2.23 Math.log10 ( x )

此函数返回 x 的以 10 为底的对数。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN 或 +∞𝔽，返回 n。
  3. 如果 n 是 1𝔽，返回 +0𝔽。
  4. 如果 n 是 +0𝔽 或 -0𝔽，返回 -∞𝔽。
  5. 如果 n < -0𝔽，返回 NaN。
  6. 返回一个由实现近似得到的 Number 值，该值表示 log10(ℝ(n))。

21.3.2.24 Math.log2 ( x )

此函数返回 x 的以 2 为底的对数。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN 或 +∞𝔽，返回 n。
  3. 如果 n 是 1𝔽，返回 +0𝔽。
  4. 如果 n 是 +0𝔽 或 -0𝔽，返回 -∞𝔽。
  5. 如果 n < -0𝔽，返回 NaN。
  6. 返回一个由实现近似得到的 Number 值，该值表示 log2(ℝ(n))。

21.3.2.25 Math.max ( ...args )

给定零个或多个实参，此函数对每个实参调用 ToNumber，并返回所得值中的最大值。

它被调用时执行以下步骤：

  1. 令 coerced 为一个新的空 List。
  2. 对 args 的每个元素 arg，执行
    1. 令 n 为 ? ToNumber(arg)。
    2. 将 n 追加到 coerced。
  3. 令 highest 为 -∞𝔽。
  4. 对 coerced 的每个元素 number，执行
    1. 如果 number 是 NaN，返回 NaN。
    2. 如果 number 是 +0𝔽 且 highest 是 -0𝔽，将 highest 设置为 +0𝔽。
    3. 如果 number > highest，将 highest 设置为 number。
  5. 返回 highest。
 注

用于确定最大值的值比较使用 IsLessThan 算法完成，但 +0𝔽 被视为大于 -0𝔽。

此函数的 "length" 属性是 2𝔽。

21.3.2.26 Math.min ( ...args )

给定零个或多个实参，此函数对每个实参调用 ToNumber，并返回所得值中的最小值。

它被调用时执行以下步骤：

  1. 令 coerced 为一个新的空 List。
  2. 对 args 的每个元素 arg，执行
    1. 令 n 为 ? ToNumber(arg)。
    2. 将 n 追加到 coerced。
  3. 令 lowest 为 +∞𝔽。
  4. 对 coerced 的每个元素 number，执行
    1. 如果 number 是 NaN，返回 NaN。
    2. 如果 number 是 -0𝔽 且 lowest 是 +0𝔽，将 lowest 设置为 -0𝔽。
    3. 如果 number < lowest，将 lowest 设置为 number。
  5. 返回 lowest。
 注

用于确定最小值的值比较使用 IsLessThan 算法完成，但 +0𝔽 被视为大于 -0𝔽。

此函数的 "length" 属性是 2𝔽。

21.3.2.27 Math.pow ( base, exponent )

此函数被调用时执行以下步骤：

  1. 将 base 设置为 ? ToNumber(base)。
  2. 将 exponent 设置为 ? ToNumber(exponent)。
  3. 返回 Number::exponentiate(base, exponent)。

21.3.2.28 Math.random ( )

此函数返回一个正号 Number 值，该值大于或等于 +0𝔽 但严格小于 1𝔽，使用实现定义的算法或策略，以在该范围内近似均匀分布的方式随机或伪随机地选取。

为不同 realm 创建的每个 Math.random 函数，必须从连续调用中产生不同的值序列。

21.3.2.29 Math.round ( x )

此函数返回最接近 x 且为整数的 Number 值。如果两个整数 Number 与 x 同样接近，则结果为更接近 +∞ 的 Number 值。如果 x 已经是整数，则结果为 x。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 不是有限 Number 或 n 是整数 Number，返回 n。
  3. 如果 n < 0.5𝔽 且 n > +0𝔽，返回 +0𝔽。
  4. 如果 n < -0𝔽 且 n ≥ -0.5𝔽，返回 -0𝔽。
  5. 返回最接近 n 的整数 Number；如果出现平局，则优先选择更接近 +∞ 的 Number。
 注 1

Math.round(3.5) 返回 4，但 Math.round(-3.5) 返回 -3。

 注 2

Math.round(x) 的值并不总是与 Math.floor(x + 0.5) 的值相同。当 x 是 -0𝔽，或 x 小于 -0𝔽 但大于或等于 -0.5𝔽 时，Math.round(x) 返回 -0𝔽，而 Math.floor(x + 0.5) 返回 +0𝔽。由于计算 x + 0.5 时发生的内部舍入，Math.round(x) 也可能与 Math.floor(x + 0.5) 的值不同。

21.3.2.30 Math.sign ( x )

此函数返回 x 的符号，指示 x 是正数、负数还是零。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN、+0𝔽 或 -0𝔽 之一，返回 n。
  3. 如果 n < -0𝔽，返回 -1𝔽。
  4. 返回 1𝔽。

21.3.2.31 Math.sin ( x )

此函数返回 x 的正弦。实参以弧度表示。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN、+0𝔽 或 -0𝔽 之一，返回 n。
  3. 如果 n 是 +∞𝔽 或 -∞𝔽，返回 NaN。
  4. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的正弦。

21.3.2.32 Math.sinh ( x )

此函数返回 x 的双曲正弦。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 不是有限 Number，或 n 是 +0𝔽 或 -0𝔽，返回 n。
  3. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的双曲正弦。
 注

Math.sinh(x) 的值与 (Math.exp(x) - Math.exp(-x)) / 2 的值相同。

21.3.2.33 Math.sqrt ( x )

此函数返回 x 的平方根。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN、+0𝔽、-0𝔽 或 +∞𝔽 之一，返回 n。
  3. 如果 n < -0𝔽，返回 NaN。
  4. 返回 𝔽(ℝ(n) 的平方根)。

21.3.2.34 Math.sumPrecise ( items )

给定一个 Number 的可迭代对象，此函数对可迭代对象中的每个值求和并返回它们的和。如果任何值不是 Number，则抛出 TypeError 异常。

它被调用时执行以下步骤：

  1. 执行 ? RequireObjectCoercible(items)。
  2. 令 iteratorRecord 为 ? GetIterator(items, sync)。
  3. 令 state 为 minus-zero。
  4. 令 sum 为 0。
  5. 令 count 为 0。
  6. 令 next 为 not-started。
  7. 重复，只要 next 不是 done，
    1. 将 next 设置为 ? IteratorStepValue(iteratorRecord)。
    2. 如果 next 不是 done，那么
      1. 如果 count ≥ 253 - 1，那么
        1. NOTE：在实践中预计不会到达此步骤，包含此步骤仅是为了使实现可以依赖输入“具有合理大小”而不违反本规范。
        2. 令 error 为 ThrowCompletion(一个新创建的 RangeError 对象)。
        3. 返回 ? IteratorClose(iteratorRecord, error)。
      2. 如果 next 不是 Number，那么
        1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
        2. 返回 ? IteratorClose(iteratorRecord, error)。
      3. 令 n 为 next。
      4. 如果 state 不是 not-a-number，那么
        1. 如果 n 是 NaN，那么
          1. 将 state 设置为 not-a-number。
        2. 否则，如果 n 是 +∞𝔽，那么
          1. 如果 state 是 minus-infinity，将 state 设置为 not-a-number。
          2. 否则，将 state 设置为 plus-infinity。
        3. 否则，如果 n 是 -∞𝔽，那么
          1. 如果 state 是 plus-infinity，将 state 设置为 not-a-number。
          2. 否则，将 state 设置为 minus-infinity。
        4. 否则，如果 n 不是 -0𝔽 且 state 是 minus-zero 或 finite，那么
          1. 将 state 设置为 finite。
          2. 将 sum 设置为 sum + ℝ(n)。
      5. 将 count 设置为 count + 1。
  8. 如果 state 是 not-a-number，返回 NaN。
  9. 如果 state 是 plus-infinity，返回 +∞𝔽。
  10. 如果 state 是 minus-infinity，返回 -∞𝔽。
  11. 如果 state 是 minus-zero，返回 -0𝔽。
  12. 返回 𝔽(sum)。
 注

可以通过多种算法在不使用任意精度算术的情况下计算 sum 的值。其中一种是 Jonathan Richard Shewchuk 在 Adaptive Precision Floating-Point Arithmetic and Fast Robust Geometric Predicates 中给出的“Grow-Expansion”算法。更新的一种算法在“使用小型和大型超级累加器进行快速精确求和”中给出，其代码可在 https://gitlab.com/radfordneal/xsum 获取。

21.3.2.35 Math.tan ( x )

此函数返回 x 的正切。实参以弧度表示。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN、+0𝔽 或 -0𝔽 之一，返回 n。
  3. 如果 n 是 +∞𝔽 或 -∞𝔽，返回 NaN。
  4. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的正切。

21.3.2.36 Math.tanh ( x )

此函数返回 x 的双曲正切。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 是 NaN、+0𝔽 或 -0𝔽 之一，返回 n。
  3. 如果 n 是 +∞𝔽，返回 1𝔽。
  4. 如果 n 是 -∞𝔽，返回 -1𝔽。
  5. 返回一个由实现近似得到的 Number 值，该值表示 ℝ(n) 的双曲正切。
 注

Math.tanh(x) 的值与 (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x)) 的值相同。

21.3.2.37 Math.trunc ( x )

此函数返回数 x 的整数部分，移除所有小数位。如果 x 已经是整数，则结果为 x。

它被调用时执行以下步骤：

  1. 令 n 为 ? ToNumber(x)。
  2. 如果 n 不是有限 Number，或 n 是 +0𝔽 或 -0𝔽，返回 n。
  3. 如果 n < 1𝔽 且 n > +0𝔽，返回 +0𝔽。
  4. 如果 n < -0𝔽 且 n > -1𝔽，返回 -0𝔽。
  5. 返回沿 +0𝔽 方向最接近 n 的整数 Number。

21.4 Date 对象

21.4.1 Date 对象概述和抽象操作定义

以下抽象操作对时间值（定义于 21.4.1.1）进行操作。注意，在任何情况下，如果这些函数的任一参数是 NaN，则结果都会是 NaN。

21.4.1.1 时间值和时间范围

ECMAScript 中的时间测量类似于 POSIX 中的时间测量，尤其是都以外推格里高利历为基础进行定义，以 1970 年 1 月 1 日 UTC 零时为纪元，并将每一天精确计为 86,400 秒（每秒为 1000 毫秒）。

ECMAScript 时间值是一个 Number，它要么是表示精确到毫秒的某个时刻的整数 Number（称为有限时间值），要么是表示没有特定时刻的 NaN。作为 MillisecondsPerDay 整数倍的有限时间值（即对于某个整数 d，其值为 MillisecondsPerDay × d）表示这样一个时刻：从纪元起经过 d 个完整 UTC 日后（当 d 为负数时则在纪元之前）的 UTC 日开始时刻。其他每个有限时间值 tv 都相对于其之前满足这种倍数关系的最大有限时间值 s 来定义，并表示与 s 位于同一 UTC 日内、但比它晚 (tv - s) 毫秒的时刻。

时间值不考虑 UTC 闰秒——没有表示正闰秒期间时刻的时间值，而被负闰秒从 UTC 时间线中移除的时刻仍有相应时间值。不过，时间值的定义仍会与 UTC 分段对齐，只有在闰秒边界处存在不连续，并且在闰秒之外差值为零。

Number 可以精确表示从 -9,007,199,254,740,992 到 9,007,199,254,740,992 的所有整数（21.1.2.8 和 21.1.2.6）。时间值支持稍小的范围，即 -8,640,000,000,000,000 到 8,640,000,000,000,000 毫秒。这使得相对于 1970 年 1 月 1 日 UTC 零时，支持的时间值范围恰好为 -100,000,000 天到 100,000,000 天。

1970 年 1 月 1 日 UTC 零时这一精确时刻由时间值 +0𝔽 表示。

注

在外推格里高利历中，闰年恰好是能被 4 整除，并且要么能被 400 整除、要么不能被 100 整除的年份。

外推格里高利历的 400 年周期包含 97 个闰年。这得到平均每年 365.2425 天，即 31,556,952,000 毫秒。因此，Number 能够以毫秒精度精确表示的最大范围，相对于 1970 年约为 -285,426 年到 285,426 年。本节规定的时间值支持的较小范围，相对于 1970 年约为 -273,790 年到 273,790 年。

21.4.1.2 时间相关常量

以下各节中的算法会引用这些常量。

HoursPerDay = 24
MinutesPerHour = 60
SecondsPerMinute = 60
MillisecondsPerSecond = 1000
MillisecondsPerMinute = 60000 = MillisecondsPerSecond × SecondsPerMinute
MillisecondsPerHour = 3600000 = MillisecondsPerMinute × MinutesPerHour
MillisecondsPerDay = 86400000 = MillisecondsPerHour × HoursPerDay
NanosecondsPerDay = 106 × MillisecondsPerDay = 8.64 × 1013
NanosecondsPerSecond = 106 × MillisecondsPerSecond = 109
NanosecondsPerMillisecond = 106
NanosecondsPerMicrosecond = 103
MaxEpochNanoseconds = 108 × NanosecondsPerDay = 8.64 × 1021
MinEpochNanoseconds = -MaxEpochNanoseconds = -8.64 × 1021

21.4.1.3 Day ( tv )

抽象操作 Day，接收参数 tv (a finite time value)；返回值：整数。 它返回 tv 所在日期的日编号。 调用时执行以下步骤：

  1. 返回 floor(ℝ(tv) / MillisecondsPerDay)。

21.4.1.4 TimeWithinDay ( tv )

抽象操作 TimeWithinDay，接收参数 tv (a finite time value)；返回值：an integer in the interval from 0 (inclusive) to MillisecondsPerDay (exclusive)。 它返回自 tv 所在日期开始以来经过的毫秒数。 调用时执行以下步骤：

  1. 返回 ℝ(tv) modulo MillisecondsPerDay。

21.4.1.5 DayFromYear ( y )

抽象操作 DayFromYear，接收参数 y (整数)；返回值：整数。 它返回年份 y 第一天的日编号。 调用时执行以下步骤：

  1. 注：在以下步骤中，numberYears1、numberYears4、numberYears100 和 numberYears400 分别表示在纪元与年份 y 开始之间出现的可被 1、4、100 和 400 整除的年份数量。如果 y 位于纪元之前，则该数量为负。
  2. 令 numberYears1 为 (y - 1970)。
  3. 令 numberYears4 为 floor((y - 1969) / 4)。
  4. 令 numberYears100 为 floor((y - 1901) / 100)。
  5. 令 numberYears400 为 floor((y - 1601) / 400)。
  6. 返回 365 × numberYears1 + numberYears4 - numberYears100 + numberYears400。

21.4.1.6 TimeFromYear ( y )

抽象操作 TimeFromYear，接收参数 y (整数)；返回值：a time value。 它返回年份 y 开始时的时间值。 调用时执行以下步骤：

  1. 返回 𝔽(MillisecondsPerDay × DayFromYear(y))。

21.4.1.7 YearFromTime ( tv )

抽象操作 YearFromTime，接收参数 tv (a finite time value)；返回值：整数。 它返回 tv 所在的年份。 调用时执行以下步骤：

  1. 返回满足 TimeFromYear(y) ≤ tv 的最大整数 y（最接近 +∞）。

21.4.1.8 DayWithinYear ( tv )

抽象操作 DayWithinYear，接收参数 tv (a finite time value)；返回值：an integer in the inclusive interval from 0 to 365。 调用时执行以下步骤：

  1. 返回 Day(tv) - DayFromYear(YearFromTime(tv))。

21.4.1.9 InLeapYear ( tv )

抽象操作 InLeapYear，接收参数 tv (a finite time value)；返回值：(0 或 1)。 如果 tv 位于闰年中，则返回 1，否则返回 0。 调用时执行以下步骤：

  1. 令 y 为 YearFromTime(tv)。
  2. 如果 (y modulo 400) = 0，则返回 1。
  3. 如果 (y modulo 100) = 0，则返回 0。
  4. 如果 (y modulo 4) = 0，则返回 1。
  5. 返回 0。

21.4.1.10 MonthFromTime ( tv )

抽象操作 MonthFromTime，接收参数 tv (a finite time value)；返回值：an integer in the inclusive interval from 0 to 11。 它返回一个整数，用于标识 tv 所在的月份。月份值 0 表示一月；1 表示二月；2 表示三月；3 表示四月；4 表示五月；5 表示六月；6 表示七月；7 表示八月；8 表示九月；9 表示十月；10 表示十一月；11 表示十二月。注意，MonthFromTime(+0𝔽) = 0，对应 1970 年 1 月 1 日星期四。 调用时执行以下步骤：

  1. 令 inLeapYear 为 InLeapYear(tv)。
  2. 令 dayWithinYear 为 DayWithinYear(tv)。
  3. 如果 dayWithinYear < 31，则返回 0。
  4. 如果 dayWithinYear < 59 + inLeapYear，则返回 1。
  5. 如果 dayWithinYear < 90 + inLeapYear，则返回 2。
  6. 如果 dayWithinYear < 120 + inLeapYear，则返回 3。
  7. 如果 dayWithinYear < 151 + inLeapYear，则返回 4。
  8. 如果 dayWithinYear < 181 + inLeapYear，则返回 5。
  9. 如果 dayWithinYear < 212 + inLeapYear，则返回 6。
  10. 如果 dayWithinYear < 243 + inLeapYear，则返回 7。
  11. 如果 dayWithinYear < 273 + inLeapYear，则返回 8。
  12. 如果 dayWithinYear < 304 + inLeapYear，则返回 9。
  13. 如果 dayWithinYear < 334 + inLeapYear，则返回 10。
  14. 断言：dayWithinYear < 365 + inLeapYear。
  15. 返回 11。

21.4.1.11 DateFromTime ( tv )

抽象操作 DateFromTime，接收参数 tv (a finite time value)；返回值：an integer in the inclusive interval from 1 to 31。 它返回 tv 所在月份中的日期。 调用时执行以下步骤：

  1. 令 inLeapYear 为 InLeapYear(tv)。
  2. 令 dayWithinYear 为 DayWithinYear(tv)。
  3. 令 month 为 MonthFromTime(tv)。
  4. 如果 month = 0，则返回 dayWithinYear + 1。
  5. 如果 month = 1，则返回 dayWithinYear - 30。
  6. 如果 month = 2，则返回 dayWithinYear - 58 - inLeapYear。
  7. 如果 month = 3，则返回 dayWithinYear - 89 - inLeapYear。
  8. 如果 month = 4，则返回 dayWithinYear - 119 - inLeapYear。
  9. 如果 month = 5，则返回 dayWithinYear - 150 - inLeapYear。
  10. 如果 month = 6，则返回 dayWithinYear - 180 - inLeapYear。
  11. 如果 month = 7，则返回 dayWithinYear - 211 - inLeapYear。
  12. 如果 month = 8，则返回 dayWithinYear - 242 - inLeapYear。
  13. 如果 month = 9，则返回 dayWithinYear - 272 - inLeapYear。
  14. 如果 month = 10，则返回 dayWithinYear - 303 - inLeapYear。
  15. 断言：month = 11。
  16. 返回 dayWithinYear - 333 - inLeapYear。

21.4.1.12 WeekDay ( tv )

抽象操作 WeekDay，接收参数 tv (a finite time value)；返回值：an integer in the inclusive interval from 0 to 6。 它返回一个整数，用于标识 tv 所在的是一周中的哪一天。星期值 0 表示星期日；1 表示星期一；2 表示星期二；3 表示星期三；4 表示星期四；5 表示星期五；6 表示星期六。注意，WeekDay(+0𝔽) = 4，对应 1970 年 1 月 1 日星期四。 调用时执行以下步骤：

  1. 返回 (Day(tv) + 4) modulo 7。

21.4.1.13 HourFromTime ( tv )

抽象操作 HourFromTime，接收参数 tv (a finite time value)；返回值：an integer in the inclusive interval from 0 to 23。 它返回 tv 所在一天中的小时。 调用时执行以下步骤：

  1. 返回 floor(ℝ(tv) / MillisecondsPerHour) modulo HoursPerDay。

21.4.1.14 MinuteFromTime ( tv )

抽象操作 MinuteFromTime，接收参数 tv (a finite time value)；返回值：an integer in the inclusive interval from 0 to 59。 它返回 tv 所在小时中的分钟。 调用时执行以下步骤：

  1. 返回 floor(ℝ(tv) / MillisecondsPerMinute) modulo MinutesPerHour。

21.4.1.15 SecondFromTime ( tv )

抽象操作 SecondFromTime，接收参数 tv (a finite time value)；返回值：an integer in the inclusive interval from 0 to 59。 它返回 tv 所在分钟中的秒。 调用时执行以下步骤：

  1. 返回 floor(ℝ(tv) / MillisecondsPerSecond) modulo SecondsPerMinute。

21.4.1.16 MillisecondFromTime ( tv )

抽象操作 MillisecondFromTime，接收参数 tv (a finite time value)；返回值：an integer in the inclusive interval from 0 to 999。 它返回 tv 所在秒中的毫秒。 调用时执行以下步骤：

  1. 返回 ℝ(tv) modulo MillisecondsPerSecond。

21.4.1.17 纪元纳秒和范围

纪元纳秒计数是表示具有纳秒精度时间瞬间的整数。它支持与时间值相同的范围，但以纳秒表示，从 MinEpochNanoseconds 到 MaxEpochNanoseconds。不存在与时间值 NaN 等价的纳秒表示；没有用于表示无特定时间瞬间的表示。

1970 年 1 月 1 日 UTC 零时这一精确时刻由值 0 表示。最大值是 MaxEpochNanoseconds，最小值是 MinEpochNanoseconds。

21.4.1.18 GetUTCEpochNanoseconds ( year, month, day, hour, minute, second, millisecond, microsecond, nanosecond )

抽象操作 GetUTCEpochNanoseconds，接收参数 year (整数)、month (an integer in the inclusive interval from 1 to 12)、day (an integer in the inclusive interval from 1 to 31)、hour (an integer in the inclusive interval from 0 to 23)、minute (an integer in the inclusive interval from 0 to 59)、second (an integer in the inclusive interval from 0 to 59)、millisecond (an integer in the inclusive interval from 0 to 999)、microsecond (an integer in the inclusive interval from 0 to 999) 和 nanosecond (an integer in the inclusive interval from 0 to 999)；返回值：an epoch nanoseconds count。 返回值是与给定 UTC 中的 ISO 8601 日历日期和墙上时钟时间相对应的纪元纳秒计数。 调用时执行以下步骤：

  1. 令 date 为 MakeDay(𝔽(year), 𝔽(month - 1), 𝔽(day))。
  2. 令 time 为 MakeTime(𝔽(hour), 𝔽(minute), 𝔽(second), 𝔽(millisecond))。
  3. 令 epochMilliseconds 为 MakeDate(date, time)。
  4. 断言：epochMilliseconds 是整数 Number。
  5. 返回 ℝ(epochMilliseconds) × NanosecondsPerMillisecond + microsecond × NanosecondsPerMicrosecond + nanosecond。

21.4.1.19 时区标识符

ECMAScript 中的时区由时区标识符表示，它们是完全由从 0x0000 到 0x007F 闭区间中的码元组成的 String。 ECMAScript 实现支持的时区可以是可用命名时区，由 AvailableNamedTimeZoneIdentifiers 返回的 Time Zone Identifier Record 的 [[Identifier]] 字段表示；也可以是偏移时区，由使 IsTimeZoneOffsetString 返回 true 的 String 表示。

主时区标识符是可用命名时区的首选标识符。 非主时区标识符是可用命名时区的标识符，但不是主时区标识符。 可用命名时区标识符要么是主时区标识符，要么是非主时区标识符。 每个可用命名时区标识符都恰好与一个可用命名时区关联。 每个可用命名时区都恰好与一个主时区标识符以及零个或多个非主时区标识符关联。

ECMAScript 实现必须支持标识符为 "UTC" 的可用命名时区，该标识符必须是 UTC 时区的主时区标识符。 此外，实现可以支持任意数量的其他可用命名时区。

遵循 ECMA-402 国际化 API 规范中所述时区要求的实现称为时区感知实现。 时区感知实现必须支持与 IANA 时区数据库中的“Zone”和“Link”名称对应的可用命名时区，并且只能支持这些名称。 在时区感知实现中，除 ECMA-402 中规定的 AvailableNamedTimeZoneIdentifiers 明确覆盖的情况外，主时区标识符和非主时区标识符分别是 IANA 时区数据库中的“Zone”名称和“Link”名称。 不支持完整 IANA 时区数据库的实现仍建议使用 IANA 时区数据库名称作为表示时区的标识符。

21.4.1.20 GetNamedTimeZoneEpochNanoseconds ( timeZoneIdentifier, year, month, day, hour, minute, second, millisecond, microsecond, nanosecond )

实现定义的抽象操作 GetNamedTimeZoneEpochNanoseconds，接收参数 timeZoneIdentifier (String)、year (整数)、month (an integer in the inclusive interval from 1 to 12)、day (an integer in the inclusive interval from 1 to 31)、hour (an integer in the inclusive interval from 0 to 23)、minute (an integer in the inclusive interval from 0 to 59)、second (an integer in the inclusive interval from 0 to 59)、millisecond (an integer in the inclusive interval from 0 to 999)、microsecond (an integer in the inclusive interval from 0 to 999) 和 nanosecond (an integer in the inclusive interval from 0 to 999)；返回值：列表 (元素：epoch nanoseconds counts)。 返回 List 中的每个值都表示一个纪元纳秒计数，该计数与由 timeZoneIdentifier 标识的命名时区中的给定 ISO 8601 日历日期和墙上时钟时间相对应。

当输入表示因负向时区转换而出现多次的本地时间时（例如夏令时结束，或因时区规则变更而减小时区偏移），返回的 List 将包含多个元素，并按数值升序排序。 当输入表示因正向时区转换而被跳过的本地时间时（例如夏令时开始，或因时区规则变更而增大时区偏移），返回的 List 将为空。 否则，返回的 List 将包含一个元素。

用于不包含任何时区本地政治规则的 ECMAScript 实现的 GetNamedTimeZoneEpochNanoseconds 默认实现，在调用时执行以下步骤：

  1. 断言：timeZoneIdentifier 是 "UTC"。
  2. 令 epochNanoseconds 为 GetUTCEpochNanoseconds(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond)。
  3. 返回 « epochNanoseconds »。
 注

要求时区感知实现（并建议所有其他实现）使用 IANA 时区数据库中的时区信息。

America/New_York 中 2017 年 11 月 5 日凌晨 1:30 会重复两次，因此 GetNamedTimeZoneEpochNanoseconds("America/New_York", 2017, 11, 5, 1, 30, 0, 0, 0, 0) 将返回长度为 2 的 List，其中第一个元素表示 UTC 05:30（对应 UTC 偏移 -04:00 的美国东部夏令时间 01:30），第二个元素表示 UTC 06:30（对应 UTC 偏移 -05:00 的美国东部标准时间 01:30）。

America/New_York 中 2017 年 3 月 12 日凌晨 2:30 不存在，因此 GetNamedTimeZoneEpochNanoseconds("America/New_York", 2017, 3, 12, 2, 30, 0, 0, 0, 0) 将返回空 List。

21.4.1.21 GetNamedTimeZoneOffsetNanoseconds ( timeZoneIdentifier, epochNanoseconds )

实现定义的抽象操作 GetNamedTimeZoneOffsetNanoseconds，接收参数 timeZoneIdentifier (String) 和 epochNanoseconds (an epoch nanoseconds count)；返回值：整数。

返回的整数表示由 timeZoneIdentifier 标识的命名时区，在与纪元纳秒计数 epochNanoseconds 对应的时刻相对于 UTC 的偏移，以纳秒为单位。

用于不包含任何时区本地政治规则的 ECMAScript 实现的 GetNamedTimeZoneOffsetNanoseconds 默认实现，在调用时执行以下步骤：

  1. 断言：timeZoneIdentifier 是 "UTC"。
  2. 返回 0。
 注

时区偏移值可以为正或为负。

21.4.1.22 Time Zone Identifier Record

Time Zone Identifier Record 是用于描述可用命名时区标识符及其对应主时区标识符的 Record。

Time Zone Identifier Record 具有 表 60 中列出的字段。

表 60: Time Zone Identifier Record 字段
字段名称 值 含义
[[Identifier]] a String 实现支持的可用命名时区标识符。
[[PrimaryIdentifier]] a String [[Identifier]] 解析到的主时区标识符。
注

如果 [[Identifier]] 是主时区标识符，则 [[Identifier]] 就是 [[PrimaryIdentifier]]。

21.4.1.23 AvailableNamedTimeZoneIdentifiers ( )

实现定义的抽象操作 AvailableNamedTimeZoneIdentifiers，接收无参数；返回值：列表 (元素：Time Zone Identifier 记录)。 其结果描述此实现中的所有可用命名时区标识符，以及与每个可用命名时区标识符对应的主时区标识符。 该 List 按每个 Time Zone Identifier Record 的 [[Identifier]] 字段排序。

时区感知实现（包括所有实现 ECMA-402 国际化 API 的实现）必须按照 ECMA-402 的规定实现 AvailableNamedTimeZoneIdentifiers 抽象操作。 否则，AvailableNamedTimeZoneIdentifiers 在调用时执行以下步骤：

  1. 如果实现不包含任何时区的本地政治规则，则
    1. 返回 « Time Zone Identifier Record { [[Identifier]]: "UTC", [[PrimaryIdentifier]]: "UTC" } »。
  2. 令 identifiers 为唯一可用命名时区标识符的 List，按字典序码元顺序排序。
  3. 令 result 为新的空 List。
  4. 对 identifiers 的每个元素 identifier，执行
    1. 令 primary 为 identifier。
    2. 如果 identifier 是此实现中的非主时区标识符且 identifier 不是 "UTC"，则
      1. 将 primary 设置为与 identifier 关联的主时区标识符。
      2. 注：实现可能需要迭代解析 identifier，以获得主时区标识符。
    3. 令 record 为 Time Zone Identifier Record { [[Identifier]]: identifier, [[PrimaryIdentifier]]: primary }。
    4. 将 record 追加到 result。
  5. 断言：result 包含一个 Time Zone Identifier Record record，使得 record.[[Identifier]] 是 "UTC" 且 record.[[PrimaryIdentifier]] 是 "UTC"。
  6. 返回 result。

21.4.1.24 SystemTimeZoneIdentifier ( )

实现定义的抽象操作 SystemTimeZoneIdentifier，接收无参数；返回值：String。 它返回表示宿主环境当前时区的 String，该 String 要么表示一个使 IsTimeZoneOffsetString 返回 true 的 UTC 偏移，要么是主时区标识符。 调用时执行以下步骤：

  1. 如果实现仅支持 UTC 时区，则返回 "UTC"。
  2. 令 systemTimeZoneString 为表示宿主环境当前时区的 String，它要么是主时区标识符，要么是偏移时区标识符。
  3. 返回 systemTimeZoneString。
 注

为确保实现通常在 Date 对象方法中提供的功能级别，如果存在与宿主环境时区设置对应的 IANA 时区名称，建议 SystemTimeZoneIdentifier 返回该名称。 如果该时区存在标准时间和夏令时的本地政治规则，则 GetNamedTimeZoneEpochNanoseconds 和 GetNamedTimeZoneOffsetNanoseconds 必须反映这些规则。

例如，如果宿主环境是在用户选择美国东部时间作为时区的系统上运行的浏览器，则 SystemTimeZoneIdentifier 返回 "America/New_York"。

21.4.1.25 LocalTime ( tv )

抽象操作 LocalTime，接收参数 tv (a finite time value)；返回值：整数 Number。 它将 tv 从 UTC 转换为本地时间。 应按照本节规定的方式，使用在 tv 时有效的标准时间和夏令时本地政治规则来确定结果。 调用时执行以下步骤：

  1. 令 systemTimeZoneIdentifier 为 SystemTimeZoneIdentifier()。
  2. 如果 IsTimeZoneOffsetString(systemTimeZoneIdentifier) 是 true，则
    1. 令 offsetNanoseconds 为 ParseTimeZoneOffsetString(systemTimeZoneIdentifier)。
  3. 否则，
    1. 令 offsetNanoseconds 为 GetNamedTimeZoneOffsetNanoseconds(systemTimeZoneIdentifier, ℝ(tv) × NanosecondsPerMillisecond)。
  4. 令 offsetMilliseconds 为 truncate(offsetNanoseconds / NanosecondsPerMillisecond)。
  5. 返回 tv + 𝔽(offsetMilliseconds)。
 注 1

如果实现中没有本地时间 tv 的政治规则，则结果为 tv，因为 SystemTimeZoneIdentifier 返回 "UTC"，GetNamedTimeZoneOffsetNanoseconds 返回 0。

 注 2

要求时区感知实现（并建议所有其他实现）使用 IANA 时区数据库 https://www.iana.org/time-zones/ 中的时区信息。

 注 3

在负向时区转换中存在重复时间时（例如夏令时结束或时区调整减小时），两个不同的输入时间值 tvUTC 会被转换为同一个本地时间 tlocal。

LocalTime(UTC(tvlocal)) 不一定始终等于 tvlocal。相应地，UTC(LocalTime(tvUTC)) 也不一定始终等于 tvUTC。

21.4.1.26 UTC ( t )

抽象操作 UTC，接收参数 t (Number)；返回值：a time value。 它将 t 从本地时间转换为 UTC 时间值。 应按照本节规定的方式，使用在 t 时有效的标准时间和夏令时本地政治规则来确定结果。 调用时执行以下步骤：

  1. 如果 t 不是有限 Number，返回 NaN。
  2. 令 systemTimeZoneIdentifier 为 SystemTimeZoneIdentifier()。
  3. 如果 IsTimeZoneOffsetString(systemTimeZoneIdentifier) 是 true，则
    1. 令 offsetNanoseconds 为 ParseTimeZoneOffsetString(systemTimeZoneIdentifier)。
  4. 否则，
    1. 令 possibleInstants 为 GetNamedTimeZoneEpochNanoseconds(systemTimeZoneIdentifier, YearFromTime(t), MonthFromTime(t) + 1, DateFromTime(t), HourFromTime(t), MinuteFromTime(t), SecondFromTime(t), MillisecondFromTime(t), 0, 0)。
    2. 注：以下步骤确保，当 t 表示在负向时区转换时重复多次的本地时间（例如夏令时结束，或因时区规则变更而减小时区偏移），或者表示在正向时区转换时被跳过的本地时间（例如夏令时开始，或因时区规则变更而增大时区偏移）时，使用转换之前的时区偏移来解释 t。
    3. 如果 possibleInstants 非空，则
      1. 令 disambiguatedInstant 为 possibleInstants[0]。
    4. 否则，
      1. 注：t 表示在正向时区转换时被跳过的本地时间（例如因夏令时开始或时区规则变更增大 UTC 偏移）。
      2. 令 possibleInstantsBefore 为 GetNamedTimeZoneEpochNanoseconds(systemTimeZoneIdentifier, YearFromTime(tBefore), MonthFromTime(tBefore) + 1, DateFromTime(tBefore), HourFromTime(tBefore), MinuteFromTime(tBefore), SecondFromTime(tBefore), MillisecondFromTime(tBefore), 0, 0)，其中 tBefore 是满足 possibleInstantsBefore 非空的最大整数 Number < t（即 tBefore 表示转换之前的最后一个本地时间）。
      3. 令 disambiguatedInstant 为 possibleInstantsBefore 的最后一个元素。
    5. 令 offsetNanoseconds 为 GetNamedTimeZoneOffsetNanoseconds(systemTimeZoneIdentifier, disambiguatedInstant)。
  5. 令 offsetMilliseconds 为 truncate(offsetNanoseconds / NanosecondsPerMillisecond)。
  6. 返回 t - 𝔽(offsetMilliseconds)。

输入 t 名义上是时间值，但可以是任意 Number 值。 算法不得将 t 限制在时间值范围内，从而无论本地 UTC 偏移如何，都能支持与时间值范围边界对应的输入。 例如，最大时间值为 8.64 × 1015，对应 "+275760-09-13T00:00:00Z"。 在该时刻本地时区偏移比 UTC 快 1 小时的环境中，它由较大的输入 8.64 × 1015 + 3.6 × 106 表示，对应 "+275760-09-13T01:00:00+01:00"。

如果实现中没有本地时间 t 的政治规则，则结果为 t，因为 SystemTimeZoneIdentifier 返回 "UTC"，GetNamedTimeZoneOffsetNanoseconds 返回 0。

注 1

要求时区感知实现（并建议所有其他实现）使用 IANA 时区数据库中的时区信息。

America/New_York 中 2017 年 11 月 5 日凌晨 1:30 会重复两次（时钟向后调整），但必须将其解释为 UTC-04 的凌晨 1:30，而不是 UTC-05 的凌晨 1:30。 在 UTC(TimeClip(MakeDate(MakeDay(2017, 10, 5), MakeTime(1, 30, 0, 0)))) 中，offsetMilliseconds 的值是 -4 × MillisecondsPerHour。

America/New_York 中 2017 年 3 月 12 日凌晨 2:30 不存在，但必须将其解释为 UTC-05 的凌晨 2:30（等价于 UTC-04 的凌晨 3:30）。 在 UTC(TimeClip(MakeDate(MakeDay(2017, 2, 12), MakeTime(2, 30, 0, 0)))) 中，offsetMilliseconds 的值是 -5 × MillisecondsPerHour。

注 2

UTC(LocalTime(tUTC)) 不一定始终等于 tUTC。相应地，LocalTime(UTC(tlocal)) 也不一定始终等于 tlocal。

21.4.1.27 MakeTime ( hour, minute, second, millisecond )

抽象操作 MakeTime，接收参数 hour (Number)、minute (Number)、second (Number) 和 millisecond (Number)；返回值：Number。 它计算毫秒数。 调用时执行以下步骤：

  1. 如果 hour 不是有限 Number，minute 不是有限 Number，second 不是有限 Number，或 millisecond 不是有限 Number，返回 NaN。
  2. 令 hourMV 为 ! ToIntegerOrInfinity(hour)。
  3. 令 minuteMV 为 ! ToIntegerOrInfinity(minute)。
  4. 令 secondMV 为 ! ToIntegerOrInfinity(second)。
  5. 令 millisecondMV 为 ! ToIntegerOrInfinity(millisecond)。
  6. 返回 ((𝔽(hourMV) × 𝔽(MillisecondsPerHour) + 𝔽(minuteMV) × 𝔽(MillisecondsPerMinute)) + 𝔽(secondMV) × 𝔽(MillisecondsPerSecond)) + 𝔽(millisecondMV)。
 注

MakeTime 中的算术是浮点算术，它不满足结合律，因此必须按正确顺序执行运算。

21.4.1.28 MakeDay ( year, month, day )

抽象操作 MakeDay，接收参数 year (Number)、month (Number) 和 day (Number)；返回值：(a finite Number 或 NaN)。 它计算天数。 调用时执行以下步骤：

  1. 如果 year 不是有限 Number，month 不是有限 Number，或 day 不是有限 Number，返回 NaN。
  2. 令 yearMV 为 ! ToIntegerOrInfinity(year)。
  3. 令 monthMV 为 ! ToIntegerOrInfinity(month)。
  4. 令 dayMV 为 ! ToIntegerOrInfinity(day)。
  5. 令 balancedYear 为 𝔽(yearMV) + 𝔽(floor(monthMV / 12))。
  6. 如果 balancedYear 不是有限 Number，返回 NaN。
  7. 令 balancedMonthMV 为 monthMV modulo 12。
  8. 找到一个有限时间值 tv，使得 YearFromTime(tv) = ℝ(balancedYear)、MonthFromTime(tv) = balancedMonthMV 且 DateFromTime(tv) = 1；但如果无法做到这一点（因为某个实参超出范围），返回 NaN。
  9. 返回 𝔽(Day(tv)) + 𝔽(dayMV) - 1𝔽。

21.4.1.29 MakeDate ( day, time )

抽象操作 MakeDate，接收参数 day (Number) 和 time (Number)；返回值：(a finite Number 或 NaN)。 它计算毫秒数。 调用时执行以下步骤：

  1. 如果 day 不是有限 Number 或 time 不是有限 Number，返回 NaN。
  2. 令 tv 为 day × 𝔽(MillisecondsPerDay) + time。
  3. 如果 tv 不是有限 Number，返回 NaN。
  4. 返回 tv。

21.4.1.30 MakeFullYear ( year )

抽象操作 MakeFullYear，接收参数 year (Number)；返回值：(整数 Number 或 NaN)。 它返回与 year 整数部分关联的完整年份，并将从 0 到 99 的闭区间内的任何值解释为自 1900 年开始以来经过的年数。为了与外推格里高利历对齐，“完整年份”定义为自年份 0（公元前 1 年）开始以来完整年份的带符号计数。 调用时执行以下步骤：

  1. 如果 year 是 NaN、+∞𝔽 或 -∞𝔽 之一，则返回 NaN。
  2. 令 truncated 为 ! ToIntegerOrInfinity(year)。
  3. 如果 truncated 位于从 0 到 99 的闭区间内，则返回 1900𝔽 + 𝔽(truncated)。
  4. 返回 𝔽(truncated)。

21.4.1.31 TimeClip ( time )

抽象操作 TimeClip，接收参数 time (Number)；返回值：a time value。 它计算毫秒数。 调用时执行以下步骤：

  1. 如果 time 不是有限 Number，返回 NaN。
  2. 如果 abs(ℝ(time)) > 8.64 × 1015，返回 NaN。
  3. 返回 𝔽(! ToIntegerOrInfinity(time))。

21.4.1.32 日期时间字符串格式

ECMAScript 定义了一种日期时间字符串交换格式，它改编自 ISO 8601 日历日期扩展格式。其格式如下：YYYY-MM-DDTHH:mm:ss.sssZ

其中各元素如下：

YYYY 是外推格里高利历中的年份，表示为从 0000 到 9999 的四位十进制数字，或者表示为扩展年份，即 "+" 或 "-" 后跟六位十进制数字。
- "-"（连字符）在字符串中字面出现两次。
MM 是一年中的月份，以两位十进制数字表示，从 01（一月）到 12（十二月）。
DD 是一个月中的日期，以从 01 到 31 的两位十进制数字表示。
T "T" 在字符串中字面出现，用于表示时间元素的开始。
HH 是自午夜以来已经完整经过的小时数，以从 00 到 24 的两位十进制数字表示。
: ":"（冒号）在字符串中字面出现两次。
mm 是自该小时开始以来已经完整经过的分钟数，以从 00 到 59 的两位十进制数字表示。
ss 是自该分钟开始以来已经完整经过的秒数，以从 00 到 59 的两位十进制数字表示。
. "."（点）在字符串中字面出现。
sss 是自该秒开始以来已经完整经过的毫秒数，以三位十进制数字表示。
Z 是 UTC 偏移表示，规定为 "Z"（表示无偏移的 UTC），或者为 "+" 或 "-" 后跟时间表达式 HH:mm（时区偏移字符串格式的子集），分别用于表示本地时间领先或落后于 UTC

此格式包括仅日期形式：

YYYY
YYYY-MM
YYYY-MM-DD

它还包括“日期时间”形式，由上述某一种仅日期形式紧接以下某一种时间形式组成，并可在末尾附加可选的 UTC 偏移表示：

THH:mm
THH:mm:ss
THH:mm:ss.sss

包含越界或不符合要求元素的字符串不是此格式的有效实例。

注 1

由于每一天都以午夜开始并以午夜结束，因此可以使用 00:00 和 24:00 两种表示法来区分可与同一个日期关联的两个午夜。这意味着以下两种表示法指向完全相同的时间点：1995-02-04T24:00 和 1995-02-05T00:00。

 注 2

此格式不支持 RFC 9557 中定义的带时区名称注解，仅支持时区偏移的数字表示。

21.4.1.32.1 扩展年份

为了覆盖相对于 1970 年 1 月 1 日向前或向后约 273,790 年的完整时间值范围（21.4.1.1），需要表示 0 年之前或 9999 年之后的年份。ISO 8601 允许扩展年份表示，但仅限信息交换双方共同约定的情况下。在简化的 ECMAScript 格式中，此类扩展年份表示应具有 6 位数字，并且始终以 + 或 - 符号作为前缀。年份 0 被视为正数，必须以 + 符号作为前缀。将年份 0 表示为 -000000 是无效的。与日期时间字符串格式匹配、但其扩展年份所表示的时间瞬间超出时间值范围的字符串，会被 Date.parse 视为不可识别，并使该函数返回 NaN，而不会回退到实现特定的行为或启发式处理。

注

具有扩展年份的日期时间值示例：

-271821-04-20T00:00:00Z 公元前 271822 年
-000001-01-01T00:00:00Z 公元前 2 年
+000000-01-01T00:00:00Z 公元前 1 年
+000001-01-01T00:00:00Z 公元 1 年
+001970-01-01T00:00:00Z 公元 1970 年
+002009-12-15T00:00:00Z 公元 2009 年
+275760-09-13T00:00:00Z 公元 275760 年

21.4.1.33 时区偏移字符串格式

ECMAScript 定义了一种派生自 ISO 8601 的 UTC 偏移字符串交换格式。 该格式由以下文法描述。

语法

UTCOffset ::: ASCIISign Hour ASCIISign Hour HourSubcomponents[+Extended] ASCIISign Hour HourSubcomponents[~Extended] ASCIISign ::: one of + - Hour ::: 0 DecimalDigit 1 DecimalDigit 20 21 22 23 HourSubcomponents[Extended] ::: TimeSeparator[?Extended] MinuteSecond TimeSeparator[?Extended] MinuteSecond TimeSeparator[?Extended] MinuteSecond TemporalDecimalFractionopt TimeSeparator[Extended] ::: [+Extended] : [~Extended] [empty] MinuteSecond ::: 0 DecimalDigit 1 DecimalDigit 2 DecimalDigit 3 DecimalDigit 4 DecimalDigit 5 DecimalDigit TemporalDecimalFraction ::: TemporalDecimalSeparator DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator ::: one of . ,

21.4.1.33.1 IsTimeZoneOffsetString ( offsetString )

抽象操作 IsTimeZoneOffsetString，接收参数 offsetString (String)；返回值：Boolean。 返回值表示 offsetString 是否符合 UTCOffset 给出的文法。 调用时执行以下步骤：

  1. 令 parseResult 为 ParseText(offsetString, UTCOffset)。
  2. 如果 parseResult 是错误的 List，则返回 false。
  3. 返回 true。

21.4.1.33.2 ParseTimeZoneOffsetString ( offsetString )

抽象操作 ParseTimeZoneOffsetString，接收参数 offsetString (String)；返回值：整数。 返回值是与 String offsetString 对应的 UTC 偏移，以纳秒数表示。 调用时执行以下步骤：

  1. 令 parseResult 为 ParseText(offsetString, UTCOffset)。
  2. 断言：parseResult 不是错误的 List。
  3. 断言：parseResult 包含 ASCIISign Parse Node。
  4. 令 parsedSign 为 parseResult 中包含的 ASCIISign Parse Node 所匹配的源文本。
  5. 如果 parsedSign 是单个码点 U+002D (HYPHEN-MINUS)，则
    1. 令 sign 为 -1。
  6. 否则，
    1. 令 sign 为 1。
  7. 注：下面对 StringToNumber 的应用不会丢失精度，因为每个解析值都保证是足够短的十进制数字字符串。
  8. 断言：parseResult 包含 Hour Parse Node。
  9. 令 parsedHours 为 parseResult 中包含的 Hour Parse Node 所匹配的源文本。
  10. 令 hours 为 ℝ(StringToNumber(CodePointsToString(parsedHours)))。
  11. 如果 parseResult 不包含 MinuteSecond Parse Node，则
    1. 令 minutes 为 0。
  12. 否则，
    1. 令 parsedMinutes 为 parseResult 中包含的第一个 MinuteSecond Parse Node 所匹配的源文本。
    2. 令 minutes 为 ℝ(StringToNumber(CodePointsToString(parsedMinutes)))。
  13. 如果 parseResult 不包含两个 MinuteSecond Parse Node，则
    1. 令 seconds 为 0。
  14. 否则，
    1. 令 parsedSeconds 为 parseResult 中包含的第二个 MinuteSecond Parse Node 所匹配的源文本。
    2. 令 seconds 为 ℝ(StringToNumber(CodePointsToString(parsedSeconds)))。
  15. 如果 parseResult 不包含 TemporalDecimalFraction Parse Node，则
    1. 令 nanoseconds 为 0。
  16. 否则，
    1. 令 parsedFraction 为 parseResult 中包含的 TemporalDecimalFraction Parse Node 所匹配的源文本。
    2. 令 fraction 为 CodePointsToString(parsedFraction) 和 "000000000" 的字符串连接。
    3. 令 nanosecondsString 为 fraction 从 1 到 10 的子字符串。
    4. 令 nanoseconds 为 ℝ(StringToNumber(nanosecondsString))。
  17. 返回 sign × (((hours × MinutesPerHour + minutes) × SecondsPerMinute + seconds) × NanosecondsPerSecond + nanoseconds)。

21.4.2 Date 构造函数

Date 构造函数：

  • 是 %Date%。
  • 是全局对象的 "Date" 属性的初始值。
  • 作为构造函数调用时，创建并初始化新的 Date。
  • 作为函数而不是构造函数调用时，返回表示当前时间（UTC）的 String。
  • 是一个其行为根据参数数量和类型而不同的函数。
  • 可以用作类定义的 extends 子句的值。希望继承指定 Date 行为的子类构造函数必须包含对 Date 构造函数的 super 调用，以创建并初始化具有 [[DateValue]] 内部槽的子类实例。

21.4.2.1 Date ( ...values )

调用时，此函数执行以下步骤：

  1. 如果 NewTarget 是 undefined，则
    1. 令 now 为标识当前时间的时间值（UTC）。
    2. 返回 ToDateString(now)。
  2. 令 numberOfArgs 为 values 中的元素数量。
  3. 如果 numberOfArgs = 0，则
    1. 令 dv 为标识当前时间的时间值（UTC）。
  4. 否则如果 numberOfArgs = 1，则
    1. 令 value 为 values[0]。
    2. 如果 value 是 Object 且 value 具有 [[DateValue]] 内部槽，则
      1. 令 tv 为 value.[[DateValue]]。
    3. 否则，
      1. 令 primitive 为 ? ToPrimitive(value)。
      2. 如果 primitive 是 String，则
        1. 断言：由于 primitive 是 String，下一步绝不会返回突然完成。
        2. 令 tv 为将 primitive 解析为日期的结果，解析方式与 parse 方法（21.4.3.2）完全相同。
      3. 否则，
        1. 令 tv 为 ? ToNumber(primitive)。
    4. 令 dv 为 TimeClip(tv)。
  5. 否则，
    1. 断言：numberOfArgs ≥ 2。
    2. 令 yearNumber 为 ? ToNumber(values[0])。
    3. 令 monthNumber 为 ? ToNumber(values[1])。
    4. 如果 numberOfArgs > 2，则令 dayNumber 为 ? ToNumber(values[2])；否则令 dayNumber 为 1𝔽。
    5. 如果 numberOfArgs > 3，则令 hourNumber 为 ? ToNumber(values[3])；否则令 hourNumber 为 +0𝔽。
    6. 如果 numberOfArgs > 4，则令 minuteNumber 为 ? ToNumber(values[4])；否则令 minuteNumber 为 +0𝔽。
    7. 如果 numberOfArgs > 5，则令 secondNumber 为 ? ToNumber(values[5])；否则令 secondNumber 为 +0𝔽。
    8. 如果 numberOfArgs > 6，则令 millisecondNumber 为 ? ToNumber(values[6])；否则令 millisecondNumber 为 +0𝔽。
    9. 将 yearNumber 设置为 MakeFullYear(yearNumber)。
    10. 令 finalDate 为 MakeDate(MakeDay(yearNumber, monthNumber, dayNumber), MakeTime(hourNumber, minuteNumber, secondNumber, millisecondNumber))。
    11. 令 dv 为 TimeClip(UTC(finalDate))。
  6. 令 obj 为 ? OrdinaryCreateFromConstructor(NewTarget, "%Date.prototype%", « [[DateValue]] »)。
  7. 将 obj.[[DateValue]] 设置为 dv。
  8. 返回 obj。

21.4.3 Date 构造函数的属性

Date 构造函数：

  • 具有 [[Prototype]] 内部槽，其值是 %Function.prototype%。
  • 具有 "length" 属性，其值是 7𝔽。
  • 具有以下属性：

21.4.3.1 Date.now ( )

此函数返回表示其调用发生时 UTC 日期和时间的时间值。

21.4.3.2 Date.parse ( string )

此函数对其参数应用 ToString 运算符。如果 ToString 导致突然完成，则立即返回该 Completion Record。否则，此函数将所得 String 解释为日期和时间；它返回一个 Number，即与该日期和时间对应的 UTC 时间值。根据 String 的内容，可以将该 String 解释为本地时间、UTC 时间或其他时区中的时间。此函数首先尝试按照日期时间字符串格式（21.4.1.32）中描述的格式（包括扩展年份）解析 String。如果 String 不符合该格式，则函数可以回退到任何实现特定的启发式处理或实现特定的日期格式。无法识别的 String 或包含越界格式元素值的 String 应使此函数返回 NaN。

如果 String 符合日期时间字符串格式，则使用替代值代替缺失的格式元素。当 MM 或 DD 元素缺失时，使用 "01"。当 HH、mm 或 ss 元素缺失时，使用 "00"。当 sss 元素缺失时，使用 "000"。当 UTC 偏移表示缺失时，仅日期形式被解释为 UTC 时间，而日期时间形式被解释为本地时间。

如果 x 是在特定 ECMAScript 实现中其毫秒部分为零的任意 Date，并且引用的所有属性都具有其初始值，则以下所有表达式在该实现中都应产生相同的数值：

x.valueOf()
Date.parse(x.toString())
Date.parse(x.toUTCString())
Date.parse(x.toISOString())

不过，表达式

Date.parse(x.toLocaleString())

不要求产生与前述三个表达式相同的 Number 值；一般而言，当为此函数提供任何不符合日期时间字符串格式（21.4.1.32）、并且无法由该实现中的 toString 或 toUTCString 方法产生的 String 值时，其产生的值由实现定义。

21.4.3.3 Date.prototype

Date.prototype 的初始值是 Date 原型对象。

此属性具有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

21.4.3.4 Date.UTC ( year [ , month [ , day [ , hour [ , minute [ , second [ , millisecond ] ] ] ] ] ] )

调用时，此函数执行以下步骤：

  1. 令 yearNumber 为 ? ToNumber(year)。
  2. 如果存在 month，则令 monthNumber 为 ? ToNumber(month)；否则令 monthNumber 为 +0𝔽。
  3. 如果存在 day，则令 dayNumber 为 ? ToNumber(day)；否则令 dayNumber 为 1𝔽。
  4. 如果存在 hour，则令 hourNumber 为 ? ToNumber(hour)；否则令 hourNumber 为 +0𝔽。
  5. 如果存在 minute，则令 minuteNumber 为 ? ToNumber(minute)；否则令 minuteNumber 为 +0𝔽。
  6. 如果存在 second，则令 secondNumber 为 ? ToNumber(second)；否则令 secondNumber 为 +0𝔽。
  7. 如果存在 millisecond，则令 millisecondNumber 为 ? ToNumber(millisecond)；否则令 millisecondNumber 为 +0𝔽。
  8. 将 yearNumber 设置为 MakeFullYear(yearNumber)。
  9. 返回 TimeClip(MakeDate(MakeDay(yearNumber, monthNumber, dayNumber), MakeTime(hourNumber, minuteNumber, secondNumber, millisecondNumber)))。

此函数的 "length" 属性是 7𝔽。

注

此函数与 Date 构造函数有两点不同：它返回 Number 形式的时间值，而不是创建 Date；并且它将参数解释为 UTC 时间，而不是本地时间。

21.4.4 Date 原型对象的属性

Date 原型对象：

  • 是 %Date.prototype%。
  • 自身是普通对象。
  • 不是 Date 实例，并且没有 [[DateValue]] 内部槽。
  • 具有 [[Prototype]] 内部槽，其值是 %Object.prototype%。

除非另有明确规定，下面定义的 Date 原型对象的方法不是通用方法，传递给它们的 this value 必须是具有已初始化为时间值的 [[DateValue]] 内部槽的对象。

21.4.4.1 Date.prototype.constructor

Date.prototype.constructor 的初始值是 %Date%。

21.4.4.2 Date.prototype.getDate ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(DateFromTime(LocalTime(tv)))。

21.4.4.3 Date.prototype.getDay ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(WeekDay(LocalTime(tv)))。

21.4.4.4 Date.prototype.getFullYear ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(YearFromTime(LocalTime(tv)))。

21.4.4.5 Date.prototype.getHours ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(HourFromTime(LocalTime(tv)))。

21.4.4.6 Date.prototype.getMilliseconds ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(MillisecondFromTime(LocalTime(tv)))。

21.4.4.7 Date.prototype.getMinutes ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(MinuteFromTime(LocalTime(tv)))。

21.4.4.8 Date.prototype.getMonth ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(MonthFromTime(LocalTime(tv)))。

21.4.4.9 Date.prototype.getSeconds ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(SecondFromTime(LocalTime(tv)))。

21.4.4.10 Date.prototype.getTime ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 返回 dateObj.[[DateValue]]。

21.4.4.11 Date.prototype.getTimezoneOffset ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 (tv - LocalTime(tv)) / 𝔽(MillisecondsPerMinute)。

21.4.4.12 Date.prototype.getUTCDate ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(DateFromTime(tv))。

21.4.4.13 Date.prototype.getUTCDay ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(WeekDay(tv))。

21.4.4.14 Date.prototype.getUTCFullYear ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(YearFromTime(tv))。

21.4.4.15 Date.prototype.getUTCHours ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(HourFromTime(tv))。

21.4.4.16 Date.prototype.getUTCMilliseconds ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(MillisecondFromTime(tv))。

21.4.4.17 Date.prototype.getUTCMinutes ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(MinuteFromTime(tv))。

21.4.4.18 Date.prototype.getUTCMonth ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(MonthFromTime(tv))。

21.4.4.19 Date.prototype.getUTCSeconds ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 NaN。
  5. 返回 𝔽(SecondFromTime(tv))。

21.4.4.20 Date.prototype.setDate ( day )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 dayNumber 为 ? ToNumber(day)。
  5. 如果 tv 是 NaN，则返回 NaN。
  6. 将 tv 设置为 LocalTime(tv)。
  7. 令 newDate 为 MakeDate(MakeDay(𝔽(YearFromTime(tv)), 𝔽(MonthFromTime(tv)), dayNumber), 𝔽(TimeWithinDay(tv)))。
  8. 令 u 为 TimeClip(UTC(newDate))。
  9. 将 dateObj.[[DateValue]] 设置为 u。
  10. 返回 u。

21.4.4.21 Date.prototype.setFullYear ( year [ , month [ , day ] ] )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 yearNumber 为 ? ToNumber(year)。
  5. 如果 tv 是 NaN，则将 tv 设置为 +0𝔽；否则将 tv 设置为 LocalTime(tv)。
  6. 如果存在 month，则令 monthNumber 为 ? ToNumber(month)；否则令 monthNumber 为 𝔽(MonthFromTime(tv))。
  7. 如果存在 day，则令 dayNumber 为 ? ToNumber(day)；否则令 dayNumber 为 𝔽(DateFromTime(tv))。
  8. 令 newDate 为 MakeDate(MakeDay(yearNumber, monthNumber, dayNumber), 𝔽(TimeWithinDay(tv)))。
  9. 令 u 为 TimeClip(UTC(newDate))。
  10. 将 dateObj.[[DateValue]] 设置为 u。
  11. 返回 u。

此方法的 "length" 属性是 3𝔽。

注

如果不存在 month，则此方法的行为如同 month 存在且值为 getMonth()。如果不存在 day，则其行为如同 day 存在且值为 getDate()。

21.4.4.22 Date.prototype.setHours ( hour [ , minute [ , second [ , millisecond ] ] ] )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 hourNumber 为 ? ToNumber(hour)。
  5. 如果存在 minute，则令 minuteNumber 为 ? ToNumber(minute)。
  6. 如果存在 second，则令 secondNumber 为 ? ToNumber(second)。
  7. 如果存在 millisecond，则令 millisecondNumber 为 ? ToNumber(millisecond)。
  8. 如果 tv 是 NaN，则返回 NaN。
  9. 将 tv 设置为 LocalTime(tv)。
  10. 如果不存在 minute，则令 minuteNumber 为 𝔽(MinuteFromTime(tv))。
  11. 如果不存在 second，则令 secondNumber 为 𝔽(SecondFromTime(tv))。
  12. 如果不存在 millisecond，则令 millisecondNumber 为 𝔽(MillisecondFromTime(tv))。
  13. 令 date 为 MakeDate(𝔽(Day(tv)), MakeTime(hourNumber, minuteNumber, secondNumber, millisecondNumber))。
  14. 令 u 为 TimeClip(UTC(date))。
  15. 将 dateObj.[[DateValue]] 设置为 u。
  16. 返回 u。

此方法的 "length" 属性是 4𝔽。

注

如果不存在 minute，则此方法的行为如同 minute 存在且值为 getMinutes()。如果不存在 second，则其行为如同 second 存在且值为 getSeconds()。如果不存在 millisecond，则其行为如同 millisecond 存在且值为 getMilliseconds()。

21.4.4.23 Date.prototype.setMilliseconds ( millisecond )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 millisecondNumber 为 ? ToNumber(millisecond)。
  5. 如果 tv 是 NaN，则返回 NaN。
  6. 将 tv 设置为 LocalTime(tv)。
  7. 令 time 为 MakeTime(𝔽(HourFromTime(tv)), 𝔽(MinuteFromTime(tv)), 𝔽(SecondFromTime(tv)), millisecondNumber)。
  8. 令 u 为 TimeClip(UTC(MakeDate(𝔽(Day(tv)), time)))。
  9. 将 dateObj.[[DateValue]] 设置为 u。
  10. 返回 u。

21.4.4.24 Date.prototype.setMinutes ( minute [ , second [ , millisecond ] ] )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 minuteNumber 为 ? ToNumber(minute)。
  5. 如果存在 second，则令 secondNumber 为 ? ToNumber(second)。
  6. 如果存在 millisecond，则令 millisecondNumber 为 ? ToNumber(millisecond)。
  7. 如果 tv 是 NaN，则返回 NaN。
  8. 将 tv 设置为 LocalTime(tv)。
  9. 如果不存在 second，则令 secondNumber 为 𝔽(SecondFromTime(tv))。
  10. 如果不存在 millisecond，则令 millisecondNumber 为 𝔽(MillisecondFromTime(tv))。
  11. 令 date 为 MakeDate(𝔽(Day(tv)), MakeTime(𝔽(HourFromTime(tv)), minuteNumber, secondNumber, millisecondNumber))。
  12. 令 u 为 TimeClip(UTC(date))。
  13. 将 dateObj.[[DateValue]] 设置为 u。
  14. 返回 u。

此方法的 "length" 属性是 3𝔽。

注

如果不存在 second，则此方法的行为如同 second 存在且值为 getSeconds()。如果不存在 millisecond，则其行为如同 millisecond 存在且值为 getMilliseconds()。

21.4.4.25 Date.prototype.setMonth ( month [ , day ] )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 monthNumber 为 ? ToNumber(month)。
  5. 如果存在 day，则令 dayNumber 为 ? ToNumber(day)。
  6. 如果 tv 是 NaN，则返回 NaN。
  7. 将 tv 设置为 LocalTime(tv)。
  8. 如果不存在 day，则令 dayNumber 为 𝔽(DateFromTime(tv))。
  9. 令 newDate 为 MakeDate(MakeDay(𝔽(YearFromTime(tv)), monthNumber, dayNumber), 𝔽(TimeWithinDay(tv)))。
  10. 令 u 为 TimeClip(UTC(newDate))。
  11. 将 dateObj.[[DateValue]] 设置为 u。
  12. 返回 u。

此方法的 "length" 属性是 2𝔽。

注

如果不存在 day，则此方法的行为如同 day 存在且值为 getDate()。

21.4.4.26 Date.prototype.setSeconds ( second [ , millisecond ] )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 secondNumber 为 ? ToNumber(second)。
  5. 如果存在 millisecond，则令 millisecondNumber 为 ? ToNumber(millisecond)。
  6. 如果 tv 是 NaN，则返回 NaN。
  7. 将 tv 设置为 LocalTime(tv)。
  8. 如果不存在 millisecond，则令 millisecondNumber 为 𝔽(MillisecondFromTime(tv))。
  9. 令 date 为 MakeDate(𝔽(Day(tv)), MakeTime(𝔽(HourFromTime(tv)), 𝔽(MinuteFromTime(tv)), secondNumber, millisecondNumber))。
  10. 令 u 为 TimeClip(UTC(date))。
  11. 将 dateObj.[[DateValue]] 设置为 u。
  12. 返回 u。

此方法的 "length" 属性是 2𝔽。

注

如果不存在 millisecond，则此方法的行为如同 millisecond 存在且值为 getMilliseconds()。

21.4.4.27 Date.prototype.setTime ( time )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 t 为 ? ToNumber(time)。
  4. 令 v 为 TimeClip(t)。
  5. 将 dateObj.[[DateValue]] 设置为 v。
  6. 返回 v。

21.4.4.28 Date.prototype.setUTCDate ( day )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 dayNumber 为 ? ToNumber(day)。
  5. 如果 tv 是 NaN，则返回 NaN。
  6. 令 newDate 为 MakeDate(MakeDay(𝔽(YearFromTime(tv)), 𝔽(MonthFromTime(tv)), dayNumber), 𝔽(TimeWithinDay(tv)))。
  7. 令 v 为 TimeClip(newDate)。
  8. 将 dateObj.[[DateValue]] 设置为 v。
  9. 返回 v。

21.4.4.29 Date.prototype.setUTCFullYear ( year [ , month [ , day ] ] )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则将 tv 设置为 +0𝔽。
  5. 令 yearNumber 为 ? ToNumber(year)。
  6. 如果存在 month，则令 monthNumber 为 ? ToNumber(month)；否则令 monthNumber 为 𝔽(MonthFromTime(tv))。
  7. 如果存在 day，则令 dayNumber 为 ? ToNumber(day)；否则令 dayNumber 为 𝔽(DateFromTime(tv))。
  8. 令 newDate 为 MakeDate(MakeDay(yearNumber, monthNumber, dayNumber), 𝔽(TimeWithinDay(tv)))。
  9. 令 v 为 TimeClip(newDate)。
  10. 将 dateObj.[[DateValue]] 设置为 v。
  11. 返回 v。

此方法的 "length" 属性是 3𝔽。

注

如果不存在 month，则此方法的行为如同 month 存在且值为 getUTCMonth()。如果不存在 day，则其行为如同 day 存在且值为 getUTCDate()。

21.4.4.30 Date.prototype.setUTCHours ( hour [ , minute [ , second [ , millisecond ] ] ] )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 hourNumber 为 ? ToNumber(hour)。
  5. 如果存在 minute，则令 minuteNumber 为 ? ToNumber(minute)。
  6. 如果存在 second，则令 secondNumber 为 ? ToNumber(second)。
  7. 如果存在 millisecond，则令 millisecondNumber 为 ? ToNumber(millisecond)。
  8. 如果 tv 是 NaN，则返回 NaN。
  9. 如果不存在 minute，则令 minuteNumber 为 𝔽(MinuteFromTime(tv))。
  10. 如果不存在 second，则令 secondNumber 为 𝔽(SecondFromTime(tv))。
  11. 如果不存在 millisecond，则令 millisecondNumber 为 𝔽(MillisecondFromTime(tv))。
  12. 令 date 为 MakeDate(𝔽(Day(tv)), MakeTime(hourNumber, minuteNumber, secondNumber, millisecondNumber))。
  13. 令 v 为 TimeClip(date)。
  14. 将 dateObj.[[DateValue]] 设置为 v。
  15. 返回 v。

此方法的 "length" 属性是 4𝔽。

注

如果不存在 minute，则此方法的行为如同 minute 存在且值为 getUTCMinutes()。如果不存在 second，则其行为如同 second 存在且值为 getUTCSeconds()。如果不存在 millisecond，则其行为如同 millisecond 存在且值为 getUTCMilliseconds()。

21.4.4.31 Date.prototype.setUTCMilliseconds ( millisecond )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 millisecondNumber 为 ? ToNumber(millisecond)。
  5. 如果 tv 是 NaN，则返回 NaN。
  6. 令 time 为 MakeTime(𝔽(HourFromTime(tv)), 𝔽(MinuteFromTime(tv)), 𝔽(SecondFromTime(tv)), millisecondNumber)。
  7. 令 v 为 TimeClip(MakeDate(𝔽(Day(tv)), time))。
  8. 将 dateObj.[[DateValue]] 设置为 v。
  9. 返回 v。

21.4.4.32 Date.prototype.setUTCMinutes ( minute [ , second [ , millisecond ] ] )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 minuteNumber 为 ? ToNumber(minute)。
  5. 如果存在 second，则令 secondNumber 为 ? ToNumber(second)。
  6. 如果存在 millisecond，则令 millisecondNumber 为 ? ToNumber(millisecond)。
  7. 如果 tv 是 NaN，则返回 NaN。
  8. 如果不存在 second，则令 secondNumber 为 𝔽(SecondFromTime(tv))。
  9. 如果不存在 millisecond，则令 millisecondNumber 为 𝔽(MillisecondFromTime(tv))。
  10. 令 date 为 MakeDate(𝔽(Day(tv)), MakeTime(𝔽(HourFromTime(tv)), minuteNumber, secondNumber, millisecondNumber))。
  11. 令 v 为 TimeClip(date)。
  12. 将 dateObj.[[DateValue]] 设置为 v。
  13. 返回 v。

此方法的 "length" 属性是 3𝔽。

注

如果不存在 second，则此方法的行为如同 second 存在且值为 getUTCSeconds()。如果不存在 millisecond，则其行为如同 millisecond 存在且值为 getUTCMilliseconds() 的返回值。

21.4.4.33 Date.prototype.setUTCMonth ( month [ , day ] )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 monthNumber 为 ? ToNumber(month)。
  5. 如果存在 day，则令 dayNumber 为 ? ToNumber(day)。
  6. 如果 tv 是 NaN，则返回 NaN。
  7. 如果不存在 day，则令 dayNumber 为 𝔽(DateFromTime(tv))。
  8. 令 newDate 为 MakeDate(MakeDay(𝔽(YearFromTime(tv)), monthNumber, dayNumber), 𝔽(TimeWithinDay(tv)))。
  9. 令 v 为 TimeClip(newDate)。
  10. 将 dateObj.[[DateValue]] 设置为 v。
  11. 返回 v。

此方法的 "length" 属性是 2𝔽。

注

如果不存在 day，则此方法的行为如同 day 存在且值为 getUTCDate()。

21.4.4.34 Date.prototype.setUTCSeconds ( second [ , millisecond ] )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 令 secondNumber 为 ? ToNumber(second)。
  5. 如果存在 millisecond，则令 millisecondNumber 为 ? ToNumber(millisecond)。
  6. 如果 tv 是 NaN，则返回 NaN。
  7. 如果不存在 millisecond，则令 millisecondNumber 为 𝔽(MillisecondFromTime(tv))。
  8. 令 date 为 MakeDate(𝔽(Day(tv)), MakeTime(𝔽(HourFromTime(tv)), 𝔽(MinuteFromTime(tv)), secondNumber, millisecondNumber))。
  9. 令 v 为 TimeClip(date)。
  10. 将 dateObj.[[DateValue]] 设置为 v。
  11. 返回 v。

此方法的 "length" 属性是 2𝔽。

注

如果不存在 millisecond，则此方法的行为如同 millisecond 存在且值为 getUTCMilliseconds()。

21.4.4.35 Date.prototype.toDateString ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 "Invalid Date"。
  5. 令 t 为 LocalTime(tv)。
  6. 返回 DateString(t)。

21.4.4.36 Date.prototype.toISOString ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则抛出 RangeError 异常。
  5. 断言：tv 是整数 Number。
  6. 如果 tv 对应于无法在日期时间字符串格式中表示的年份，则抛出 RangeError 异常。
  7. 返回 tv 在 UTC 时间尺度上采用日期时间字符串格式的 String 表示，包括所有格式元素以及 UTC 偏移表示 "Z"。

21.4.4.37 Date.prototype.toJSON ( key )

此方法提供用于 JSON.stringify（25.5.4）的 Date 的 String 表示。

调用时，它执行以下步骤：

  1. 令 obj 为 ? ToObject(this value)。
  2. 令 tv 为 ? ToPrimitive(obj, number)。
  3. 如果 tv 是 Number 且 tv 不是有限 Number，返回 null。
  4. 返回 ? Invoke(obj, "toISOString")。
 注 1

该参数会被忽略。

 注 2

此方法有意设计为通用方法；它不要求其 this value 是 Date。因此，它可以被转移到其他种类的对象上用作方法。不过，它要求任何此类对象都具有 toISOString 方法。

21.4.4.38 Date.prototype.toLocaleDateString ( [ reserved1 [ , reserved2 ] ] )

包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 的规定实现此方法。否则，使用以下此方法的规范：

此方法返回一个 String 值。该 String 的内容由实现定义，但旨在以方便、人类可读且符合宿主环境当前区域设置惯例的形式，表示当前时区中 Date 的“日期”部分。

此方法可选参数的含义定义于 ECMA-402；不包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。

21.4.4.39 Date.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )

包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 的规定实现此方法。否则，使用以下此方法的规范：

此方法返回一个 String 值。该 String 的内容由实现定义，但旨在以方便、人类可读且符合宿主环境当前区域设置惯例的形式，表示当前时区中的 Date。

此方法可选参数的含义定义于 ECMA-402；不包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。

21.4.4.40 Date.prototype.toLocaleTimeString ( [ reserved1 [ , reserved2 ] ] )

包含 ECMA-402 国际化 API 的 ECMAScript 实现必须按照 ECMA-402 的规定实现此方法。否则，使用以下此方法的规范：

此方法返回一个 String 值。该 String 的内容由实现定义，但旨在以方便、人类可读且符合宿主环境当前区域设置惯例的形式，表示当前时区中 Date 的“时间”部分。

此方法可选参数的含义定义于 ECMA-402；不包含 ECMA-402 支持的实现不得将这些参数位置用于其他用途。

21.4.4.41 Date.prototype.toString ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 返回 ToDateString(tv)。
 注 1

对于任何满足 d.[[DateValue]] 能被 1000 整除的 Date d，Date.parse(d.toString()) 的结果 = d.valueOf()。参见 21.4.3.2。

 注 2

此方法不是通用方法；如果其 this value 不是 Date，则会抛出 TypeError 异常。因此，它不能被转移到其他种类的对象上用作方法。

21.4.4.41.1 TimeString ( tv )

抽象操作 TimeString，接收参数 tv (a Number, but not NaN)；返回值：String。 调用时执行以下步骤：

  1. 令 hour 为 ToZeroPaddedDecimalString(HourFromTime(tv), 2)。
  2. 令 minute 为 ToZeroPaddedDecimalString(MinuteFromTime(tv), 2)。
  3. 令 second 为 ToZeroPaddedDecimalString(SecondFromTime(tv), 2)。
  4. 返回 hour、":"、minute、":"、second、码元 0x0020 (SPACE) 和 "GMT" 的字符串连接。

21.4.4.41.2 DateString ( tv )

抽象操作 DateString，接收参数 tv (a Number, but not NaN)；返回值：String。 调用时执行以下步骤：

  1. 令 weekday 为 表 61 中 WeekDay Index = WeekDay(tv) 的条目的 Name。
  2. 令 month 为 表 62 中 Month Index = MonthFromTime(tv) 的条目的 Name。
  3. 令 day 为 ToZeroPaddedDecimalString(DateFromTime(tv), 2)。
  4. 令 yv 为 YearFromTime(tv)。
  5. 如果 yv ≥ 0，则令 yearSign 为空 String；否则令 yearSign 为 "-"。
  6. 令 paddedYear 为 ToZeroPaddedDecimalString(abs(yv), 4)。
  7. 返回 weekday、码元 0x0020 (SPACE)、month、码元 0x0020 (SPACE)、day、码元 0x0020 (SPACE)、yearSign 和 paddedYear 的字符串连接。
表 61: 一周各日的名称
WeekDay 索引 名称
0 "Sun"
1 "Mon"
2 "Tue"
3 "Wed"
4 "Thu"
5 "Fri"
6 "Sat"
表 62: 一年各月的名称
Month 索引 名称
0 "Jan"
1 "Feb"
2 "Mar"
3 "Apr"
4 "May"
5 "Jun"
6 "Jul"
7 "Aug"
8 "Sep"
9 "Oct"
10 "Nov"
11 "Dec"

21.4.4.41.3 TimeZoneString ( tv )

抽象操作 TimeZoneString，接收参数 tv (整数 Number)；返回值：String。 调用时执行以下步骤：

  1. 令 systemTimeZoneIdentifier 为 SystemTimeZoneIdentifier()。
  2. 如果 IsTimeZoneOffsetString(systemTimeZoneIdentifier) 是 true，则
    1. 令 offsetNanoseconds 为 ParseTimeZoneOffsetString(systemTimeZoneIdentifier)。
  3. 否则，
    1. 令 offsetNanoseconds 为 GetNamedTimeZoneOffsetNanoseconds(systemTimeZoneIdentifier, ℝ(tv) × NanosecondsPerMillisecond)。
  4. 令 offsetMilliseconds 为 truncate(offsetNanoseconds / NanosecondsPerMillisecond)。
  5. 如果 offsetMilliseconds ≥ 0，则
    1. 令 offsetSign 为 "+"。
    2. 令 absOffsetMilliseconds 为 offsetMilliseconds。
  6. 否则，
    1. 令 offsetSign 为 "-"。
    2. 令 absOffsetMilliseconds 为 -offsetMilliseconds。
  7. 令 offsetMinute 为 ToZeroPaddedDecimalString(MinuteFromTime(𝔽(absOffsetMilliseconds)), 2)。
  8. 令 offsetHour 为 ToZeroPaddedDecimalString(HourFromTime(𝔽(absOffsetMilliseconds)), 2)。
  9. 令 timeZoneName 为实现定义的字符串，它要么是空 String，要么是码元 0x0020 (SPACE)、码元 0x0028 (LEFT PARENTHESIS)、实现定义的时区名称和码元 0x0029 (RIGHT PARENTHESIS) 的字符串连接。
  10. 返回 offsetSign、offsetHour、offsetMinute 和 timeZoneName 的字符串连接。

21.4.4.41.4 ToDateString ( tv )

抽象操作 ToDateString，接收参数 tv ((整数 Number 或 NaN))；返回值：String。 调用时执行以下步骤：

  1. 如果 tv 是 NaN，则返回 "Invalid Date"。
  2. 令 localTime 为 LocalTime(tv)。
  3. 返回 DateString(localTime)、码元 0x0020 (SPACE)、TimeString(localTime) 和 TimeZoneString(tv) 的字符串连接。

21.4.4.42 Date.prototype.toTimeString ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 "Invalid Date"。
  5. 令 localTime 为 LocalTime(tv)。
  6. 返回 TimeString(localTime) 和 TimeZoneString(tv) 的字符串连接。

21.4.4.43 Date.prototype.toUTCString ( )

此方法返回表示与 this value 对应的时间瞬间的 String 值。该 String 的格式基于 RFC 7231 中的 HTTP-date，并推广为支持 ECMAScript Date 所支持的完整时间范围。

调用时，它执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 令 tv 为 dateObj.[[DateValue]]。
  4. 如果 tv 是 NaN，则返回 "Invalid Date"。
  5. 令 weekday 为 表 61 中 WeekDay Index = WeekDay(tv) 的条目的 Name。
  6. 令 month 为 表 62 中 Month Index = MonthFromTime(tv) 的条目的 Name。
  7. 令 day 为 ToZeroPaddedDecimalString(DateFromTime(tv), 2)。
  8. 令 yv 为 YearFromTime(tv)。
  9. 如果 yv ≥ 0，则令 yearSign 为空 String；否则令 yearSign 为 "-"。
  10. 令 paddedYear 为 ToZeroPaddedDecimalString(abs(yv), 4)。
  11. 返回 weekday、","、码元 0x0020 (SPACE)、day、码元 0x0020 (SPACE)、month、码元 0x0020 (SPACE)、yearSign、paddedYear、码元 0x0020 (SPACE) 和 TimeString(tv) 的字符串连接。

21.4.4.44 Date.prototype.valueOf ( )

调用时，此方法执行以下步骤：

  1. 令 dateObj 为 this value。
  2. 执行 ? RequireInternalSlot(dateObj, [[DateValue]])。
  3. 返回 dateObj.[[DateValue]]。

21.4.4.45 Date.prototype [ %Symbol.toPrimitive% ] ( hint )

ECMAScript 语言运算符会调用此方法，将 Date 转换为原始值。hint 允许的值是 "default"、"number" 和 "string"。Date 在内置 ECMAScript 对象中是独特的，因为它们将 "default" 视为等价于 "string"；所有其他内置 ECMAScript 对象都将 "default" 视为等价于 "number"。

调用时，它执行以下步骤：

  1. 令 obj 为 this value。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 如果 hint 是 "string" 或 "default"，则
    1. 令 tryFirst 为 string。
  4. 否则如果 hint 是 "number"，则
    1. 令 tryFirst 为 number。
  5. 否则，
    1. 抛出 TypeError 异常。
  6. 返回 ? OrdinaryToPrimitive(obj, tryFirst)。

此属性具有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

此方法的 "name" 属性值是 "[Symbol.toPrimitive]"。

21.4.5 Date 实例的属性

Date 实例是从 Date 原型对象继承属性的普通对象。Date 实例还具有 [[DateValue]] 内部槽。[[DateValue]] 内部槽是此 Date 表示的时间值。