QAQMiao

ECMA-262 7ᵗʰ Edition 第 20 章

原文链接: www.ecma-international.org

20 Number 和 Date


20.1 Number 对象

20.1.1 Number 构造函数

Number 构造函数是 %Number% 的内部对象也是全局对象Number 属性的初始值。当作为构造函数被调用时,它会创建并初始化一个新的 Number 对象。当作为函数被调用时,它会执行类型转换。

Number 构造函数被设计成可继承的,可以将其复制给继承类。想要继承 Number 行为的子类构造函数为了创建和初始化带有内置 [[NumberData]] 的子类实例中必须包含一个 super 调用 Number 构造函数。

20.1.1.1 Number( <var>value</var> )

当调用 Number 传递了一个 number 参数时,会执行以下步骤:

  1. 如果函数调用没有传参,则设置 n 为 +0。
  2. 否则令 n 等于 ToNumber(value)。
  3. 如果结果为 undefined,返回 n。
  4. 初始化 O = OrdinaryCreateFromConstructor(n, "%NumberPrototype%", « [[NumberData]] »)。
  5. 设置 O 的内置 [[NumberData]] 的值为 n。
  6. 返回 O。

20.1.2 Number构造函数的属性

Number 构造函数的内部 [[Prototype]] 的值为内部对象 %FunctionPrototype%

Number 构造函数有以下属性:

20.1.2.1 Number.EPSILON

Number.EPSILON 表示的是比 1 大的最小的数与 1 的差的数值,大约为 2.2204460492503130808472633361816 x 10-16

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]:false, [[Configurable]]:false }。

20.1.2.2 Number.isFinite ( <var>number</var> )

当调用 Number.isFinite 传递了一个 number 参数时,会执行以下步骤:

  1. 如果 Type(number) 的结果不是 Number 类型,返回 false。
  2. 如果 number 的值为 NaN,+∞,或是 -∞,返回 false。
  3. 其他情况返回 true。

20.1.2.3 Number.isInteger ( <var>number</var> )

当调用 Number.isFinite 传递了一个 number 参数时,会执行以下步骤:

  1. 如果 Type(number) 的结果不是 Number 类型,返回 false。
  2. 如果 number 的值为 NaN,+∞,或是 -∞,返回 false。
  3. 初始化 integer 为 ToInteger(number)。
  4. 如果 integer 不等于 number,返回 false。
  5. 其他情况返回 true。

20.1.2.4 Number.isNaN ( <var>number</var> )

当调用 Number.isNaN 传递了一个 number 参数时,会执行以下步骤:

  1. 如果 Type(number) 的结果不是 Number 类型,返回 false。
  2. 如果 number 的值为 NaN,返回 true。
  3. 其他情况返回 false。

注 这个函数与全局函数 isNaN 18.2.3 是不同的。isNaN 在确定当前参数是否是 NaN 之前不会对其进行转换。

20.1.2.5 Number.isSafeInteger ( <var>number</var> )

当调用 Number.isSafeInteger 传递了一个 number 参数时,会执行以下步骤:

  1. 如果 Type(number) 的结果不是 Number 类型,返回 false。
  2. 如果 number 的值为 NaN,+∞,或是 -∞,返回 false。
  3. 初始化 integer 为 ToInteger(number)。
  4. 如果 integer 不等于 number,返回 false。
  5. 如果 abs(integer) ≤ 253 - 1,返回 true。
  6. 其他情况返回 false。

20.1.2.6 Number.MAX_SAFE_INTEGER

Number.MAX_SAFE_INTEGER 的值是 Number 类型最大值 - 1。

Number.MAX_SAFE_INTEGER 的值等于 9007199254740991 (253 - 1)。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.7 Number.MAX_VALUE

Number.MAX_VALUE 的值代表最大的正数,约为 1.7976931348623157 × 10308

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.8 Number.MIN_SAFE_INTEGER

Number.MIN_SAFE_INTEGER 的值是 Number 类型最小值 + 1。

Number.MIN_SAFE_INTEGER 的值等于 -9007199254740991 (-(253-1))。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.9 Number.MIN_VALUE

Number.MIN_VALUE 代表最小的正数,约为5 × 10-324

在 IEEE 754-2008 双精度二进制表示法中,最小的可取值为非规格化数。如果一个实现中不支持非规格化值,那 Number.MIN_VALUE 的值应为最小的非零正数,实际以实现为准。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.10 Number.NaN

Number.NaN 的值为 NaN。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.11 Number.NEGATIVE_INFINITY

Number.NEGATIVE_INFINITY 的值为 -∞。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.12 Number.parseFloat ( <var>string</var> )

Number.parseFloat 数据属性的值与全局对象的内置函数 parseFloat 属性的值是相同的,其定义位于 18.2.4。

20.1.2.13 Number.parseInt ( <var>string</var>, <var>radix</var> )

Number.parseInt 数据属性的值与全局对象的内置函数 parseInt 属性的值是相同的,其定义位于 18.2.5。

20.1.2.14 Number.POSITIVE_INFINITY

Number.POSITIVE_INFINITY 的值为 +∞。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.15 Number.prototype

Number.prototype 的初始值为内部对象 %NumberPrototype%

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.3 Number 原型对象的属性

Number 原型对象就是内部对象 %NumberPrototype%。Number 原型对象是一个普通对象。Number 原型本身是一个 Number 对象;它有一个值为 +0 的内置 [[NumberData]]。

Number 原型对象的内置 [[Prototype]] 的值为内部对象 %ObjectPrototype%

除非另有明确说明,以下定义的 Number 原型对象均为非通用的,传递给它们的 this 值必须为一个 Number 值或者一个内置 [[NumberData]] 已经初始化为 Number 值的对象。

抽象操作 thisNumberValue(value) 执行以下步骤:

  1. 如果 Type(value) 为 Number,返回 value。
  2. 如果 Type(value) 为对象,并且 value 有内置 [[NumberData]],则
    1. 断言: value 的内置 [[NumberData]] 是 Number 类型值。
    2. 返回: value 的内置 [[NumberData]]。
  3. 抛出 TypeError 异常。

在规范的方法中,短语 "this Number value"指的是通过将 this 的值作为参数传递来调用抽象操作 thisNumberValue 返回相应的值。

20.1.3.1 Number.prototype.constructor

Number.prototype.constructor 的初始值为内部对象 %Number%

20.1.3.2 Number.prototype.toExponential ( <var>fractionDigits</var> )

返回一个科学计数法表示的代表 this 数字值的字符串,它的有效数字的小数点前有一个数字,有效数字的小数点后有 fractionDigits 个数字。如果 fractionDigits 是 undefined,包括指定唯一数字值需要的尽可能多的有效数字(就像 ToString,但在这里总是以科学计数法输出)。具体来说执行以下步骤:

  1. 令 x 等于 thisNumberValue(this value)。
  2. 令 f 等于 ToInteger(fractionDigits)。
  3. 断言: 当 fractionDigits 为 undefined 时,f 为 0。
  4. 如果 x 是 NaN, 返回字符串 "NaN"
  5. 令 s 为空字符串。
  6. 如果 x < 0,则
    1. 令 s 为 "-"
    2. 令 x 为 -x。
  7. 如果 x = +∞,则
    1. 返回拼接字符串 s 和 "Infinity" 后的结果。
  8. 如果 f < 0 或者 f > 20,抛出一个 RangeError 的异常。然而实现被允许扩展 toExponential 对于 f 的值小于0或者大于20时的行为。在这种情况下,toExponential 不再必须抛出 RangeError 的异常。
  9. 如果 x = 0,则
    1. 令 m 为由 f + 1 个码元 0x0030(数字0)所组成的字符串。
    2. 令 e 等于 0。
  10. 如果 x ≠ 0,
    1. 如果 fractionDigits 不是 undefined,则
      1. 令 e 和 n 为整数,使得满足 10f ≤ n < 10f+1 且 n × 10e–f – x 的准确数值尽可能接近零。如果 e 和 n 有两个这样的组合,选择使 n × 10e–f 更大的组合。
    2. 如果 fractionDigits 是 undefined
      1. 令 e, n, 和 f 为整数,使得满足 f ≥ 0 且 10f≤ n < 10f+1, n × 10e–f 的数值等于 x, 且 f 的值尽可能小。需要注意的是,n 的十进制表示有 f + 1 个数字,n 不能被 10 整除,并且 n 的最少有效位数未必由这些条件唯一确定。
    3. 令 m 等于 n 的十进制表示的字符串(没有前导零)。
  11. 如果 f ≠ 0,则
    1. 另 a 为 m 中的第一个元素,b 为 m 中剩下的 f 个元素。
    2. 令 m 等于 a,".",b 三个字符串的拼接。
  12. 如果 e = 0,则
    1. 令 c = "+"
    2. 令 d = "0"
  13. 否则,
    1. 如果 e > 0,令 c 等于 "+"
    2. 如果 e ≤ 0,
      1. 令 c 等于 "-"
      2. 令 e 等于 -e。
    3. 令 d 等于 e 的十进制表示的字符串(没有前导零)。
  14. 令 m 等于 m,"e",c,d 四个字符串的拼接。

如果调用 toExponential 方法时多于一个参数,则该行为未定义(详见规范17)。

注 对于需要提供比上述规则更准确转换的实现,建议用以下算法作为指引替代步骤 10.2.1:

  1. 令 e, n, 和 f 为整数,使得满足 f ≥ 0, 10f≤ n < 10f+1, n × 10e–f 的数值等于 x,且 f 的值尽可能小。如果这样的 n 值可能多个,选择使 n × 10e–f 的值尽可能接近 x 的 n 值。如果有两个这样的 n 值,则选择偶数。

20.1.3.3 Number.prototype.toFixed ( <var>fractionDigits</var> )

注 1 tiFixed 返回一个包含了 -- 代表 this 数字值的留有小数点后 fractionDigits 个数字的十进制固定小数点记法 -- 的字符串。如果 fractionDigits 是 undefined,就认为是 0。

执行以下步骤:

  1. 令 x 等于 thisNumberValue(this value)。
  2. 令 f 等于 ToInteger(fractionDigits)。(如果 fractionDigits 是 undefined,这步产生的值为 0)。
  3. 如果 f < 0 或 f > 20, 抛出一个 RangeError 异常。不过允许实现去扩展 toFixed 的值使 f 小于 0 或者是大于 20。在这种情况下,toFixed 不必在此时抛出 RangeError 异常。
  4. 如果 x 是 NaN,返回字符串 "NaN"
  5. 令 s 为空字符串。
  6. 如果 x < 0,则
    1. 令 s 为 "-"。
    2. 令 x = –x。
  7. 如果 x ≥ 1021,则
    1. 令 m = ToString(x)。
  8. 如果 x < 1021
    1. 令 n 为一个整数,让 n ÷ 10f – x 准确的数学值尽可能接近零。如果有两个这样 n 值,选择较大的 n。
    2. 如果 n = 0,令 m 为字符串 "0"。否则,令 m 等于 n 的十进制表示的字符串(为了没有前导零)。
    3. 如果 f ≠ 0,则
      1. 令 k 等于 m 里的字符个数。
      2. 如果 k ≤ f,则
        1. 令 z 等于 f+1–k 个码元 0x0030(数字0)组成的字符串。
        2. 令 m 等于字符串 z 和 m 的拼接。
        3. 令 k 等于 f + 1。
      3. 令 a 等于 m 的前 k–f 个字符,令 b 为其余 f 个字符。
      4. 令 m 等于 a,".",b 三个字符串的拼接。
  9. 返回字符串 s 和 m 的拼接。

如果调用 toFixed 方法时传递了多于一个参数,这种行为是未定义的(详见规范17

注 2 对于某些值,toFixed 的输出可比 toString 的更精确,因为 toString 只打印区分相邻数字值的足够的有效数字。例如,

(1000000000000000128).toString() 返回 "1000000000000000100"

(1000000000000000128).toFixed(0) 返回 "1000000000000000128"

20.1.3.4 Number.prototype.toLocaleString ( [ <var>reserved1</var> [, <var>reserved2</var> ] ])

一个包含 ECMA-402 国际化 API 的 ECMAScript 实现必须要按照 ECMA-402 规范中的定义进行实现 Number.prototype.toLocaleString,如果这个 ECMAScript 实现没有包含 ECMA-402 API,那么接下来的规范适用于 toLocaleString

根据宿主环境的当前语言环境惯例来格式化当前 Number 值,生成代表这个值的字符串。此函数是依赖于实现的,允许但不鼓励它的返回值与 toString 相同。

这个方法可选参数的意义被定义在 ECMA-402 规范中。实现如果没有包含 ECMA-402 支持,应当不使用此参数做任何用途。

20.1.3.5 Number.prototype.toPrecision ( <var>precision</var> )

返回一个包含当前 Number 值的科学计数法(有效数字的小数点前有一个数字,有效数字的小数点后有 precision-1 个数字)或十进制固定计数法(precision 个有效数字)的字符串。如果 precision 是 undefined,调用 ToString 代替。具体执行以下步骤:

  1. 令 x 等于 thisNumberValue(this value)。
  2. 如果 precision 为 undefined,返回 ToString(x)。
  3. 令 p 等于 ToInteger(precision)。
  4. 如果 x 为 NaN,返回字符串 "NaN"
  5. 令 s 为空字符串。
  6. 如果 x < 0,则
    1. 令 s 等于 码元 0x002D(连字符暨减号)
    2. 令 x 等于 -x。
  7. 如果 x = +∞,则
    1. 返回 s 和 "Infinity" 拼接的字符串。
  8. 如果 p < 1 或者 p > 21,抛出 RangeError 异常。不过允许实现扩展 toPrecision 的行为使 p 小于1或是大于21。在这种情况下,toPrecision 不必抛出 RangeError 异常。
  9. 如果 x = 0,则
    1. 令 m 等于 p 个 码元 0x0030(数字 0)拼接的字符串。
    2. 令 e 等于 0。 10 如果 x ≠ 0,
    3. 令 e 和 n 为整数,并且满足 10p–1 ≤ n < 10p 且 n × 10e–p+1 – x 的值尽可能的接近0。如果有两个这样 e 和 n 的集合,选择 n × 10e–p+1 的值更大的那组。
    4. 令 m 等于 n 的十进制表示的字符串(没有前导零)
    5. 如果 e < -6 或者 e ≥ p,则
      1. 断言: e ≠ 0。
      2. 令 a 等于 m 的第一个字符,令 b 等于剩下的 p - 1 个字符。
      3. 令 m 等于 a,".",b 三个字符串的拼接。
      4. 如果 e > 0,则
        1. 令 c 等于码元 0x002B(加号)。
      5. 如果 e < 0,
        1. 令 c 等于码元 0x002D(连字符暨减号)。
        2. 令 e 等于 -e。
      6. 令 d 等于 e 的十进制表示的字符串(没有前导零)。
      7. 返回 s,m,码元0x0065(小写拉丁字母 E),c,d五个字符串的拼接。
  10. 如果 e = p - 1,返回字符串 s 和 m 的拼接。
  11. 如果 e ≥ 0,则
    1. 令 m 等于 m 的前 e+1 个字符, 码元0x002E(字符 ‘.’), m 的其余 p– (e+1) 个字符拼接的结果。
  12. 如果 e < 0,
    1. 令 m 等于码元 0x0030(数字 0),码元0x002E(字符 ‘.’),-(e + 1)个码元 0x0030(数字 0),字符串 m 的拼接。
  13. 返回字符串 s 和 m 的拼接。

toPrecision 方法调用时传递多于一个参数,这种行为是未定义的(详见规范17

20.1.3.6 Number.prototype.toString ( [ <var>radix</var> ] )

注 可选参数 radix 应当为 2 - 36 之间的一个整数值。如果没有给出 radix 或者其为 undefined,则使用数字 10 作为默认值。

将会执行以下步骤:

  1. 令 x 等于 thisNumberValue(this value)。
  2. 如果 radix 不存在,令 radixNumber 等于 10。
  3. 否则如果 radix 为 undefined,令 radixNumber 等于 10。
  4. 否则令 radixNumber 等于 ToInteger(radix)。
  5. 如果 radixNumber < 2 或者 radixNumber > 36,抛出 RangeError 异常。
  6. 如果 radixNumber = 10,返回 ToString(x)。
  7. 根据 radixNumber 的值返回当前数值特定进制的字符串表示。字母 'a'-'z' 用来代表 10 到 35。算法的精确度依赖于实现,算法应当是7.1.12.1中指定的实现。

toString 函数是不通用的,如果 this 值不是 Number 或者 Number 对象,他就会抛出 TypeError 异常。因此,它不能作为一个转移到其他对象上的方法。

toString 方法的 length 属性等于 1。

20.1.3.7Number.prototype.valueOf( )

  1. 返回 thisNumberValue(this value)。

20.1.4 Number 实例的属性

Number 实例从 Number 原型对象继承属性,Number 实例还有一个 [[NumberData]] 内部属性。[[NumberData]] 存储着当前 Number 对象的 Number 值。

20.2 Math 对象

Math 对象是 %Math% 的内部对象以及全局对象Math 属性的初始值。Math 对象是一个独立普通对象。

Math 对象内置 [[Prototype]] 的值是内部对象 %ObjectPrototype%

Math 对象不是一个函数对象。它没有 [[Construct]] 内置函数。在 new 操作符后使用 Math 对象作为构造器是不可以的。同时 Math 对象也没有内置的 [[Call]] 方法。没办法作为一个函数调用 Math 对象。

注 在本规范中,“x 的数值”在 6.1.6中有技术含义。

20.2.1 Math 对象的值属性

20.2.1.1 Math.E

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

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.2.1.2 Math.LN10

10 的自然对数的数字值,约为 2.302585092994046。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.2.1.3 Math.LN2

2 的自然对数的数字值,约为 0.6931471805599453。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.2.1.4 Math.LOG10E

自然对数的底数 e 的以 10 为底数的对数的数字值;约为 0.4342944819032518。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

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

20.2.1.5 Math.LOG2E

自然对数的底数 e 的以 2 为底数的对数的数字值;约为 1.4426950408889634。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

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

20.2.1.6 Math.PI

圆的周长与直径之比π的数字值,约为 3.1415926535897932。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.2.1.7 Math.SQRT1_2

½ 的平方根的数字值,约为 0.7071067811865476。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

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

20.2.1.8 Math.SQRT2

2 的平方根的数字值,约为 1.4142135623730951。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.2.1.9 Math [ @@toStringTag ]

@@toStringTag 属性的初始值为字符串 "Math"

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

20.2.2 Math 对象的函数属性

对以下 Math 对象函数的每个参数(如果有多个,以左到右的顺序)应用 ToNumber 抽象操作,然后对结果数字值执行计算。如果 ToNumber返回突然中止,那么中止记录将被马上返回。否则,函数对结果数值执行计算。每个函数返回的值都是一个 Number。

在下面的函数描述中,符号 NaN,-0,+0,-∞,以及 +∞ 都指的是 6.1.6 中描述的数值。

注 这里没有精确规定函数 acos,asin,atan,atan2,cos,exp,logpow,sin,sqrt 的行为,除了需要特别说明对边界情况某些参数值的结果之外。对其他参数值,这些函数旨在计算计算常见数学函数的结果,但选择的近似算法中的某些范围是被允许的。这样做的目的是为了实现人员可以在给定的硬件平台上为 ECMAScript 与 C 语言程序员使用相同的数学库。

尽管实现拥有算法的选择权,但是推荐(不是本标准中指定)实现使用 fdlibm 中包含的 IEEE 754-2008 算法来作为近似算法,由 Sun Microsystems(http://www.netlib.org/fdlibm)免费提供。

20.2.2.1 Math.abs ( <var>x</var> )

返回 x 的绝对值,返回结果大小与 x 相同,但是有正数标记。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 -0,返回结果是 +0。
  • 如果 x 是 -∞,返回结果是 +∞。

20.2.2.2 Math.acos ( <var>x</var> )

返回 x 的反余弦的依赖实现的近似值。结果以弧度形式表示,范围是 +0 到 +π。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 大于 1,返回结果是 NaN。
  • 如果 x 小于 −1,返回结果是 NaN。
  • 如果 x 是 1,返回结果是 +0。

20.2.2.3Math.acosh ( <var>x</var> )

返回 x 的反双曲余弦的依赖实现的近似值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 小于 1,返回结果是 NaN。
  • 如果 x 是 1,返回结果是 +0。
  • 如果 x 是 +∞,返回结果是 +∞。

20.2.2.4 Math.asin ( <var>x</var> )

返回 x 的反正弦的依赖实现的近似值。结果以弧度形式表示,范围是−π/2 到 +π/2。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 大于 1,返回结果是 NaN。
  • 如果 x 小于 –1,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 −0,返回结果是 −0。

20.2.2.5 Math.asinh ( <var>x</var> )

返回 x 的反双曲正弦的依赖实现近似值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 -0,返回结果是 -0。
  • 如果 x 是 +∞,返回结果是 +∞。
  • 如果 x 是 -∞,返回结果是 -∞。

20.2.2.6 Math.atan ( <var>x</var> )

返回 x 的反正切的依赖实现的近似值。结果以弧度形式表示,范围是−π/2 到 +π/2。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 −0,返回结果是 −0。
  • 如果 x 是 +∞,返回结果是 一个依赖于实现的近似值 +π/2。
  • 如果 x 是 −∞,返回结果是 一个依赖于实现的近似值 −π/2。

20.2.2.7 Math.atanh ( <var>x</var> )

返回 x 的反双曲正切的依赖实现的近似值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 小于 -1,返回结果是 NaN。
  • 如果 x 大于 1,返回结果是 NaN。
  • 如果 x 是 -1,返回结果是 -∞。
  • 如果 x 是 +1,返回结果是 +∞。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 -0,返回结果是 -0。

20.2.2.8 Math.atan2 ( <var>y</var>, <var>x</var> )

返回 -- 参数 y 和 x 的商 y/x-- 的反正切的依赖实现的近似值,y 和 x 的符号用于确定返回值的象限。注:命名为 y 的参数为第一个,命名为 x 的参数为第二个,这是有意,是反正切函数俩参数的惯例。结果以弧度形式表示,范围是−π到 +π。

  • 如果 x 和 y 至少一个是 NaN,返回结果是 NaN。
  • 如果 y>0 且 x 是 +0,返回结果是一个依赖于实现的近似值 +π/2。
  • 如果 y>0 且 x 是 −0,返回结果是一个依赖于实现的近似值 +π/2。
  • 如果 y 是 +0 且 x>0,返回结果是 +0。
  • 如果 y 是 +0 且 x 是 +0,返回结果是 +0。
  • 如果 y 是 +0 且 x 是 −0,返回结果是一个依赖于实现的近似值 +π。
  • 如果 y 是 +0 且 x < 0,返回结果是 一个依赖于实现的近似值 +π。
  • 如果 y 是 −0 且 x > 0,返回结果是 −0。
  • 如果 y 是 −0 且 x 是 +0,返回结果是 −0。
  • 如果 y 是 −0 且 x 是 −0,返回结果是一个依赖于实现的近似值 −π。
  • 如果 y 是 −0 且 x < 0,返回结果是一个依赖于实现的近似值 −π。
  • 如果 y < 0 且 x 是 +0,返回结果是一个依赖于实现的近似值 −π/2。
  • 如果 y < 0 且 x 是 −0,返回结果是一个依赖于实现的近似值 −π/2。
  • 如果 y > 0 且 y 是有限的且 x 是 +∞,返回结果是 +0。
  • 如果 y > 0 且 y 是有限的且 x 是 −∞,返回结果是一个依赖于实现的近似值 +π。
  • 如果 y < 0 且 y 是有限的且 x 是 +∞,返回结果是 −0。
  • 如果 y < 0 且 y 是有限的且 x 是 −∞,返回结果是一个依赖于实现的近似值 −π。
  • 如果 y 是 +∞ 且 x 是有限的,返回结果是 返回结果是一个依赖于实现的近似值 +π/2。
  • 如果 y 是 −∞ 且 x 是有限的,返回结果是 返回结果是一个依赖于实现的近似值 −π/2。
  • 如果 y 是 +∞ 且 x 是 +∞,返回结果是一个依赖于实现的近似值 +π/4。
  • 如果 y 是 +∞ 且 x 是 −∞,返回结果是一个依赖于实现的近似值 +3π/4。
  • 如果 y 是 −∞ 且 x 是 +∞,返回结果是一个依赖于实现的近似值 −π/4。
  • 如果 y 是 −∞ 且 x 是 −∞,返回结果是一个依赖于实现的近似值 −3π/4。

20.2.2.9 Math.cbrt ( <var>x</var> )

返回 x 的立方根的依赖实现的近似值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 -0,返回结果是 -0。
  • 如果 x 是 +∞,返回结果是 +∞。
  • 如果 x 是 -∞,返回结果是 -∞。

20.2.2.10 Math.ceil ( <var>x</var> )

返回不小于 x 的且为数学整数的最小(接近 −∞)数字值。如果 x 已是整数,则返回 x。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 −0,返回结果是 −0。
  • 如果 x 是 +∞,返回结果是 +∞。
  • 如果 x 是 −∞,返回结果是 −∞。
  • 如果 x 小于 0 但大于 -1,返回结果是 −0。

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

20.2.2.11 Math.clz32 ( <var>x</var> )

当调用 Math.clz32 传递了一个参数 x 时,执行以下步骤:

  1. 令 n 等于 ToUint32(x)。
  2. 令 p 等于 n 的 32 位二进制表示中前导 0 的位数。
  3. 返回 p。

注 如果 n 等于 0,p 等于 32。如果 n 的 32 位二进制编码的最高位为 1,则 p 等于 0。

20.2.2.12 Math.cos ( <var>x</var> )

返回 x 的余弦的依赖实现的近似值。参数被当做是弧度值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 1。
  • 如果 x 是 −0,返回结果是 1。
  • 如果 x 是 +∞,返回结果是 NaN。
  • 如果 x 是 −∞,返回结果是 NaN。

20.2.2.13 Math.cosh ( <var>x</var> )

返回 x 的双曲余弦的依赖实现的近似值。

  • 如果 x 等于 NaN,返回结果是 NaN。
  • 如果 x 等于 +0,返回结果是 1。
  • 如果 x 等于 -0,返回结果是 1。
  • 如果 x 等于 +∞,返回结果是 +∞。
  • 如果 x 等于 -∞,返回结果是 +∞。

注 cosh(x) 的值等同于 (exp(x) + exp(-x))/2

20.2.2.14 Math.exp ( <var>x</var> )

返回 x 的指数的依赖实现的近似值(返回 e 的 x 次幂,e 代表自然对数的底数)。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 1。
  • 如果 x 是 −0,返回结果是 1。
  • 如果 x 是 +∞,返回结果是 +∞。
  • 如果 x 是 −∞,返回结果是 +0。

20.2.2.15 Math.expm1 ( <var>x</var> )

返回 x 的指数减 1 的依赖实现的近似值(返回 e 的 x 次幂,e 代表自然对数的底数)。即使当 x 的值接近 0 的时候,计算的结果也是准确的。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 -0,返回结果是 -0。
  • 如果 x 是 +∞,返回结果是 +∞。
  • 如果 x 是 -∞,返回结果是 -1。

20.2.2.16 Math.floor ( <var>x</var> )

返回不大于 x 的且为数学整数的最大(接近 +∞)数值。如果 x 已是整数,则返回 x。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 −0,返回结果是 −0。
  • 如果 x 是 +∞,返回结果是 +∞。
  • 如果 x 是 −∞,返回结果是 −∞。
  • 如果 x 大于 0 但小于 1,返回结果是 +0。

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

20.2.2.17 Math.fround ( <var>x</var> )

当调用 Math.fround 传递了一个参数时,将执行以下步骤:

  1. 如果 x 等于 NaN,返回 NaN。
  2. 如果 x 等于 +0,-0,+∞,-∞ 其中之一时,返回 x。
  3. 令 x32 等于用 roundTiesToEven 将 x 转换为 IEEE 754-2008 单精度形式的值。
  4. 令 x64 等于将 x32 转换为 IEEE 754-2008 双精度形式的值。
  5. 返回 ECMAScript 数值相应的 x64。

20.2.2.18 Math.hypot ( <var>value1</var>, <var>value2</var>, ...<var>values</var> )

  • 如果没有参数传递,返回结果是 +0。
  • 如果其中某个参数为 +∞,返回结果是 +∞。
  • 如果其中某个参数为 -∞,返回结果是 -∞。
  • 如果没有参数为 +∞ 或 -∞,并且某个参数为 NaN,返回结果是 NaN。
  • 如果所有的参数都是 +0 或者 -0,返回结果是 +0。

注 实现应当注意避免上溢出和下溢出所带来的精度损失,当函数调用时传递了两个及以上参数时,不成熟的实现很容易出现这种问题。

20.2.2.19 Math.imul ( <var>x</var>, <var>y</var> )

当调用 Math.imul 传递了两个参数 x 和 y 时,将执行以下步骤:

  1. 令 a 等于 ToUint32(x)。
  2. 令 b 等于 ToUint32(y)。
  3. 令 product 等于 (a × b) 232
  4. 如果 product ≥ 231,返回 product - 232。否则返回 product。

20.2.2.20 Math.log ( <var>x</var> )

返回 x 的自然对数的依赖于实现的近似值 .

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 小于 0,返回结果是 NaN。
  • 如果 x 是 +0 或 −0,返回结果是 −∞。
  • 如果 x 是 1,返回结果是 +0。
  • 如果 x 是 +∞,返回结果是 +∞。

20.2.2.21 Math.log1p ( <var>x</var> )

返回 x + 1 的自然对数的依赖于实现的近似值。即使 x 接近 0,计算出的结果也是准确的。

  • 如果 x NaN,返回结果是 NaN。
  • 如果 x 小于 -1,返回结果是 NaN。
  • 如果 x 等于 -1,返回结果是 -∞。
  • 如果 x 等于 +0,返回结果是 +0。
  • 如果 x 等于 -0,返回结果是 -0。
  • 如果 x 等于 +∞,返回结果是 +∞。

20.2.2.22 Math.log10 ( <var>x</var> )

返回 x 以 10 为底的对数的依赖于实现的近似值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 小于 0,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 -∞。
  • 如果 x 是 -0,返回结果是 -∞。
  • 如果 x 是 1,返回结果是 +0。
  • 如果 x 是 +∞,返回结果是 +∞。

20.2.2.23 Math.log2 ( <var>x</var> )

返回 x 以 2 为底的对数的依赖于实现的近似值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 小于 0,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 -∞。
  • 如果 x 是 -0,返回结果是 -∞。
  • 如果 x 是 1,返回结果是 +0。
  • 如果 x 是 +∞,返回结果是 +∞。

20.2.2.24 Math.max ( <var>value1</var>, <var>value2</var>, ...<var>values</var> )

给定零或多个参数,对每个参数调用 ToNumber 并返回调用结果里的最大值。

  • 如果没有给定参数,返回结果是 −∞。
  • 如果某个值是 NaN,返回结果是 NaN。
  • 比较以确定最大值是使用了抽象关系比较算法,除了 +0 被认为大于 -0 这一特殊情况。

20.2.2.25 Math.min ( <var>value1</var>, <var>value2</var>, ...<var>values</var> )

给定零或多个参数,对每个参数调用 ToNumber 并返回调用结果里的最小值。

  • 如果没有给定参数,返回结果是 −∞。
  • 如果某个值是 NaN,返回结果是 NaN。
  • 比较以确定最小值是使用了抽象关系比较算法,除了 +0 被认为大于 -0 这一特殊情况。

20.2.2.26 Math.pow ( <var>base</var>, <var>exponent</var> )

  1. 返回如规范12.7.3.4中所定义的对 base 和 exponent 应用 ** 操作符的结果。

20.2.2.27 Math.random ( )

返回一个大于或等于 0 但小于 1 的符号为正的数字值,选择随机或在该范围内近似均匀分布的伪随机,用一个依赖与实现的算法或策略。此函数不需要参数。

不同领域创建的每个 Math.random 函数都必须在连续调用的情况下返回不同的序列。

20.2.2.28 Math.round ( <var>x</var> )

返回最接近 x 且为数学整数的数值。如果两个整数同等接近 x,则选择接近 +∞的数值 。如果 x 已是整数,则返回 x。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 −0,返回结果是 −0。
  • 如果 x 是 +∞,返回结果是 +∞。
  • 如果 x 是 −∞,返回结果是 −∞。
  • 如果 x 大于 0 但小于 0.5,返回结果是 +0。
  • 如果 x 小于 0 但大于或等于 -0.5,返回结果是 −0。

注 1 Math.round(3.5) 返回 4,但 Math.round(–3.5) 返回 –3.

注 2 当 x 为 −0 或 x 小于 0 当大于大于等于 -0.5 时,Math.round(x) 返回 −0, 但 Math.floor(x+0.5) 返回 +0,除了这种情况之外 Math.round(x) 的返回值与 Math.floor(x+0.5) 的返回值相同。

20.2.2.29 Math.sign (<var>x</var>)

返回 x 的标识位,标识 x 是正数,负数,或者 0。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 -0,返回结果是 -0。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是负数并且不为 -0,返回结果是 -1。
  • 如果 x 是正数并且不为 +0,返回结果是 +1。

20.2.2.30Math.sin ( <var>x</var> )

返回 x 的正弦的依赖实现的近似值。参数被当做是弧度值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 −0,返回结果是 −0。
  • 如果 x 是 +∞ 或 −∞,返回结果是 NaN。

20.2.2.31 Math.sinh ( <var>x</var> )

返回 x 的双曲正弦的依赖实现的近似值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 −0,返回结果是 −0。
  • 如果 x 是 +∞,返回结果是 +∞。
  • 如果 x 是 -∞,返回结果是 -∞。

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

20.2.2.32 Math.sqrt ( <var>x</var> )

返回 x 的平方根的依赖实现的近似值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 小于 0,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 −0,返回结果是 −0。
  • 如果 x 是 +∞,返回结果是 +∞。

20.2.2.33 Math.tan ( <var>x</var> )

返回 x 的正切的依赖实现的近似值。参数被当做是弧度值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 −0,返回结果是 −0。
  • 如果 x 是 +∞ 或 −∞,返回结果是 NaN。

20.2.2.34 Math.tanh ( <var>x</var> )

返回 x 的双曲正切的依赖实现的近似值。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 −0,返回结果是 −0。
  • 如果 x 是 +∞,返回结果是 +1。
  • 如果 x 是 -∞,返回结果是 -1。

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

20.2.2.35 Math.trunc ( <var>x</var> )

返回 x 的整数部分,删除所有小数部分。如果 x 已经是整数,则返回 x。

  • 如果 x 是 NaN,返回结果是 NaN。
  • 如果 x 是 -0,返回结果是 -0。
  • 如果 x 是 +0,返回结果是 +0。
  • 如果 x 是 +∞,返回结果是 +∞。
  • 如果 x 是 -∞,返回结果是 -∞。
  • 如果 x 大于 0 小于 1,返回结果是 +0。
  • 如果 x 小于 0 大于 -1,返回结果是 -0。

20.3 Date 对象

20.3.1O Date 对象的概述和抽象操作的定义

下面的函数是操作时间值的抽象操作(在规范20.3.1.1中定义)。需要注意的是,在任何情况下,如果以下这些函数某个参数是 NaN,返回结果则为 NaN。

20.3.1.1 时间值和时间范围

一个 Date 对象包含一个表示特定时间瞬间的毫秒的数字值。这样的 Number 叫做时间值 。一个时间值也可以是 NaN,说明这个 Date 对象不表示特定时间瞬间。

ECMAScript 中测量时间以毫秒为单位自 1970 年 1 月 1 日开始的。在时间值中闰秒是被忽略的,假设每天正好有 86,400,000 毫秒。ECMAScript 数字值可表示的所有从–9,007,199,254,740,991 到 9,007,199,254,740,991 的整数;这个范围足以衡量在约 1970 年 1 月 1 日前后约 285,616 年内时间精确到毫秒的任何时刻。

ECMAScript Date 对象支持的实际时间范围是略小一些的:相对 1970 年 1 月 1 日午夜 0 点的精确的 –100,000,000 天到 100,000,000 天。这给出了 1970 年 1 月 1 日前后 8,640,000,000,000,000 毫秒的范围。

精确的协调世界时 1970 年 1 月 1 日午夜 0 点用 +0 表示。

20.3.1.2 天数和天内时间

一个给定时间值 t 所属的天数是

Day(t) = floor(t / msPerDay)

其中每天的毫秒数是

msPerDay = 86400000

余数叫做天内时间

TimeWithinDay(t) = t %msPerDay

20.3.1.3 年数

ECMAScript 使用一个推算公历系统,来将一个天数映射到一个年数,并确定在那年的月份的日期。在这个系统中,闰年是且仅是(可被 4 整除)且((不可被 100 整除)或(可被 400 整除))的年份。因此,y 年的天的数目定义为

DaysInYear(y)

= 365 if (y % 4) ≠ 0

= 366 if (y % 4) = 0 and (y modulo 100) ≠ 0

= 365 if (y % 100) = 0 and (y modulo 400) ≠ 0

= 366 if (y % 400) = 0

所有非闰年有 365 天,其中每月的天的数目是常规的。闰年的二月里有个多出来的一天。 y 年第一天的天数是:

DayFromYear(y) = 365 × (y-1970) + floor((y-1969)/4) - floor((y-1901)/100) + floor((y-1601)/400)

y 年的起始时间值是:

TimeFromYear(y) = msPerDay × DayFromYear(y)

一个时间值决定的年数是:

YearFromTime(t) = 最大整数 y (距离正无穷最近) 这样 TimeFromYear(y) ≤ t

若时间值在闰年内,闰年函数返回 1,否则返回 0:

InLeapYear(t)

= 0 if DaysInYear(YearFromTime(t)) = 365

= 1 if DaysInYear(YearFromTime(t)) = 366

20.3.1.4 月数

月份是由闭区间 0 到 11 内的一个整数确定。一个时间值 t 到一个月数的映射 MonthFromTime(t) 的定义为:

MonthFromTime(t)

= 0 if 0 ≤ DayWithinYear(t) < 31

= 1 if 31 ≤ DayWithinYear(t) < 59+InLeapYear(t)

= 2 if 59+InLeapYear(t) ≤ DayWithinYear(t) < 90+InLeapYear(t)

= 3 if 90+InLeapYear(t) ≤ DayWithinYear(t) < 120+InLeapYear(t)

= 4 if 120+InLeapYear(t) ≤ DayWithinYear(t) < 151+InLeapYear(t)

= 5 if 151+InLeapYear(t) ≤ DayWithinYear(t) < 181+InLeapYear(t)

= 6 if 181+InLeapYear(t) ≤ DayWithinYear(t) < 212+InLeapYear(t)

= 7 if 212+InLeapYear(t) ≤ DayWithinYear(t) < 243+InLeapYear(t)

= 8 if 243+InLeapYear(t) ≤ DayWithinYear(t) < 273+InLeapYear(t)

= 9 if 273+InLeapYear(t) ≤ DayWithinYear(t) < 304+InLeapYear(t)

= 10 if 304+InLeapYear(t) ≤ DayWithinYear(t) < 334+InLeapYear(t)

= 11 if 334+InLeapYear(t) ≤ DayWithinYear(t) < 365+InLeapYear(t)

DayWithinYear(t) = Day(t)-DayFromYear(YearFromTime(t))

月数值 0 指一月;1 指二月;2 指三月;3 指四月;4 指五月;5 指六月;6 指七月;7 指八月;8 指九月;9 指十月;10 指十一月;11 指十二月。注:MonthFromTime(0) = 0,对应 1970 年 1 月 1 日,星期四。

20.3.1.5 日期数

一个日期数用闭区间 1 到 31 内的一个整数标识。从一个时间值 t 到一个日期数的映射 DateFromTime(t) 的定义为:

DateFromTime(t)

= DayWithinYear(t)+1 if MonthFromTime(t)=0

= DayWithinYear(t)-30 if MonthFromTime(t)=1

= DayWithinYear(t)-58-InLeapYear(t) if MonthFromTime(t)=2

= DayWithinYear(t)-89-InLeapYear(t) if MonthFromTime(t)=3

= DayWithinYear(t)-119-InLeapYear(t) if MonthFromTime(t)=4

= DayWithinYear(t)-150-InLeapYear(t) if MonthFromTime(t)=5

= DayWithinYear(t)-180-InLeapYear(t) if MonthFromTime(t)=6

= DayWithinYear(t)-211-InLeapYear(t) if MonthFromTime(t)=7

= DayWithinYear(t)-242-InLeapYear(t) if MonthFromTime(t)=8

= DayWithinYear(t)-272-InLeapYear(t) if MonthFromTime(t)=9

= DayWithinYear(t)-303-InLeapYear(t) if MonthFromTime(t)=10

= DayWithinYear(t)-333-InLeapYear(t) if MonthFromTime(t)=11

20.3.1.6 星期数

特定时间值 t 对应的星期数的定义为:

WeekDay(t) = (Day(t) + 4) % 7

星期数的值 0 指星期日;1 指星期一;2 指星期二;3 指星期三;4 指星期四;5 指星期五;6 指星期六。注:WeekDay(0) = 4, 对应 1970 年 1 月 01 日 星期四。

20.3.1.7 本地时区校准

一个 ECMAScript 的实现预期可以进行确定本地时区校准。本地时区校准是一个毫秒为单位的值 LocalTZA,它加上 UTC 代表本地标准时间。LocalTZA 不体现夏令时。LocalTZA 值不随时间改变,只取决于地理位置。

注 推荐实现使用 IANA 时区数据库http://www.iana.org/time-zones/提供的信息。

20.3.1.8 夏时令校准

实现依赖算法来使用关于时区最佳可得的信息来确定本地的夏时令校准 DaylightSavingTA(t),以毫秒计。一个 ECMAScript 实现预期应尽最大努力来确定本地的夏时令校准。

注 推荐实现使用 IANA 时区数据库http://www.iana.org/time-zones/提供的信息。

20.3.1.9 LocalTime (<var> t </var>)

带有参数 t 的抽象操作 LocalTime 将 t 从国际协调时间(UTC)转换为本地时间,具体执行以下步骤:

  1. 返回 t + LocalTZA + DaylightSavingTA(t)。

20.3.1.10 UTC (<var> t </var>)

The abstract operation UTC with argument t converts t from local time to UTC is defined by performing the following steps: 带有参数 t 的抽象操作 UTC 将 t 从本地时间转换为 UTC,具体执行以下步骤:

  1. 返回 t - LocalTZA - DaylightSavingTA(t - LocalTZA)。

UTC(LocalTime(t))不必恒等于 t。

20.3.1.11 时,分,秒,毫秒

以下函数用于分解时间值:

HourFromTime(t) = floor(t / msPerHour) % HoursPerDay

MinFromTime(t) = floor(t / msPerMinute) % MinutesPerHour

SecFromTime(t) = floor(t / msPerSecond) % SecondsPerMinute

msFromTime(t) = t % msPerSecond

此时

HoursPerDay = 24

MinutesPerHour = 60

SecondsPerMinute = 60

msPerSecond = 1000

msPerMinute = 60000 = msPerSecond × SecondsPerMinute

msPerHour = 3600000 = msPerMinute × MinutesPerHour

20.3.1.1