ES5/标准 ECMAScript 内置对象

From HTML5 Chinese Interest Group Wiki
< ES5(Redirected from ES5/builtins)
Jump to: navigation, search

ECMAScript 代码运行时会有一些可用的内置对象。一是作为执行程序词法环境的一部分的全局对象。其他的可通过全局对象的初始属性访问。

除非另外指明,如果内置对象拥有 [[Call]] 内部属性,那么它的 [[Class]] 内部属性是 "Function",如果没有 [[Call]] 内部属性,那么它的 [[Class]] 内部属性是 "Object"。除非另外指明,内置对象的 [[Extensible]] 内部属性的初始值是 true

许多内置对象是函数:它们可以通过参数调用。其中有些还作为构造器:这些函数可被 new 运算符调用。对于每个内置函数,本规范描述了这些函数的必须参数和作为函数对象的属性。对于每个内置构造器,本规范还描述了这些构造器原型对象的属性,还描述了用 new 表达式调用这个构造器后返回的具体实例对象的属性。

除非另外指明了某一特定函数的描述,如果在调用本章中描述的函数或构造器时传入的参数少于必须的参数个数,那么这些函数或构造器将表现为仿佛传入了足够的参数,而那些缺少的参数会设定为 undefined 值。

除非另外指明了某一特定函数的描述,如果在调用本章中描述的函数或构造器时传入了比函数指定允许的更多的参数时,额外的参数会被函数忽略。然而,一个实现可以为这样的参数列表定义依赖于实现的特别行为,只要这种行为在单纯添加额外参数时不抛出 TypeError 异常。

注: 实现为了给内置函数集合增添一些额外功能而添加新函数是被鼓励的,而不是为现有函数增加新参数。

所有内置函数和内置构造器都有作为其 [[Prototype]] 内置属性值的 Function 原型对象,它的初始值是 Function.prototype 表达式的值。

除非另外指定,每一个内置原型对象都有作为其 [[Prototype]] 内部属性的 Object 原型对象,它的初始值是表达式 Object.prototype 的值,Object 自己的原型对象例外。Note.png

除非另外指明了特定函数的描述,否则本章描述的内置函数中不存在不是构造器而要实现 [[Construct]] 内部方法的内置函数。除非另外指明了特定函数的描述,否则本章描述的内置函数都没有 prototype 属性。 Note.png

本章通常描述构造器的 “作为函数调用” 和 “用 new 表达式调用” 有不同行为。“作为函数调用” 的行为对应于调用构造器的 [[Call]] 内部方法,“用 new 表达式调用”的行为对应于调用构造器的 [[Construct]] 内部方法。

本章描述的每个内置 Function 对象,无论是构造器还是普通函数甚至二者都是,他们都拥有一个 length 属性,其值是个整数。除非另外指明,此值等于显示在函数描述的子章节标题的形式参数的个数,包括可选参数。

注: 例如描述 String 的原型对象的 slice 属性初始值的函数对象的子章节标题是“String.prototype.slice (start, end)”,这说明有两个形参 startend,所以这个函数对象的 length 属性值是 2

任何情况下,本章描述的内置函数对象的 length 属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。除非另外指明,本章描述的所有其他属性拥有特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }。


Contents

全局对象

唯一的全局对象在控制进入任何执行环境前被创建。

除非另外指明,全局对象的标准内置属性拥有特性 {[[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}。

全局对象没有 [[Construct]] 内部属性 ; 全局对象不可能当做构造器用 new 运算符调用。

全局对象没有 [[Call]] 内部属性,全局对象不可能当做函数来调用。

全局对象的 [[Prototype]][[Class]] 内部属性值是依赖于实现的。

除了本规范定义的属性之外,全局对象还可以拥有额外的宿主定义的属性。全局对象可包含一个值是全局对象自身的属性;例如,在 HTML 文档对象模型中全局对象的 window 属性是全局对象自身。


全局对象的值属性

NaN

NaN 的值是 NaN(见 8.5)。这个属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。V8.png

Infinity

Infinity 的值是 +∞(见 8.5)。这个属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。 V8.png

undefined

undefined 的值是 undefined(见 8.1)。这个属性拥有特性 <{ [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。 V8.png


全局对象的函数属性

eval (x)

当用一个参数 x 调用 eval 函数,采用如下步骤:

  1. 如果 Type(x) 不是 String,返回 x
  2. prog 为 ECMAScript 代码,它是将 x 作为一个程序解析的结果。如果解析失败,抛出一个 SyntaxError 异常 ( 见 16 章 )。
  3. evalCtx 为给 eval 代码 prog 建立的新执行环境 (10.4.2)。V8.pngV8.png
  4. result 为解释执行程序 prog 的结果。
  5. 退出执行环境 evalCtx,恢复到之前的执行环境。
  6. 如果 result.typenormal 并且其完结类型值是 V,则返回 V 值。
  7. 如果 result.typenormal 并且其完结类型值是 empty,则返回 undefined 值。
  8. 否则,result.type 必定是 throw。将 result.value 作为异常抛出。
直接调用 Eval

一个 eval 函数的直接调用是表示为符合以下两个条件的 CallExpression

解释执行 CallExpression 中的 MemberExpression 的结果是个引用,这个引用拥有一个环境记录项作为其基值,并且这个引用的名称是 "eval"Note.png

以这个引用作为参数调用 GetValue 抽象操作的结果是 15.1.2.1 定义的标准内置函数。

parseInt (string, radix)

parseInt 函数产生一个根据 radix 来解释 string 得到的整数值。Note.png string 开头的空白会被忽略。如果 radixundefined0,则将 radix 当作 10 处理 O.pngMoz.png,除非数字是以字符对 0x0X 开头,在这种情形下将 radix 当作是 16。如果传入的 radix 参数直接就是 16,那么在数字前面加上 0x0X 也无妨。Note.png

当调用 parseInt 函数时,采用以下步骤:

  1. inputStringToString(string)。V8.png
  2. S 为一个新创建的子字符串,它由 inputString 的第一个非 StrWhiteSpaceChar 字符和它后面跟着的所有字符组成。( 换句话说,删掉前面的空白。) 如果 inputString 不包含任何这样的字符,则令 S 为空字符串。
  3. sign1
  4. 如果 S 不为空并且 S 的第一个字符是减号 -,则令 sign−1V8.png
  5. 如果 S 不是空并且 S 的第一个字符加号 + 或减号 -,则删除 S 的第一个字符。
  6. R = ToInteger(radix)。
  7. stripPrefixtrue
  8. 如果 R0,则
    1. 如果 R < 2R > 36,则返回 NaNV8.png
    2. 如果 R16,令 stripPrefixfalse
  9. 否则,R = 0
    1. R = 10V8.png
  10. 如果 stripPrefixtrue,则
    1. 如果 S 长度大于 2 并且 S 的头两个字符是 “0x” 或 “0X”,则删除 S 的头两个字符并且令 R = 16V8.png
  11. 如果 S 包含任何不是 R进制 数位的字符 Note.png,则令 ZS 中这样的字符之前的所有字符组成的子字符串;否则令 ZS Note.pngV8.png
  12. 如果 Z 是空,返回 NaNV8.png
  13. mathIntZR进制 表示的数学值,用字母 A-Za-z 来表示 1035 之间的值。( 但如果 R10 并且 Z 包含多余 20 位的值,可以替换 20 位后的每个数字为 0,这是实现可选的功能;如果 R 不是 248101632,则 mathInt 可以是 ZR进制 表示的依赖于实现的近似值。)
  14. numbermathIntNumber 值。
  15. 返回 sign × numberV8.png
注:parseInt 可以只把 string 的开头部分解释为整数值;它会忽略所有不能解释为整数记法的一部分的字符,并且没有指示会给出任何这些忽略的字符。

parseFloat (string)

parseFloat 函数根据 string 参数的内容解释为十进制字面量的结果来决定,产生一个数值。

当调用 parseFloat 函数,采用以下步骤:

  1. inputStringToString(string)。
  2. trimmedString 为一个新创建的子字符串,它由 inputString 的非 StrWhiteSpaceChar 字符的最左边字符和它右边跟着的所有字符组成。( 换句话说,删掉前面的空白。) 如果 inputString 不包含任何这样的字符,则令 trimmedString 为空字符串。
  3. 如果 trimmedStringtrimmedString 的任何前缀都不满足 StrDecimalLiteral 的语法,返回 NaN
  4. numberString 为满足 StrDecimalLiteral 语法的 trimmedString 的最长前缀,可能是 numberString 自身。
  5. 返回 numberString 数学值的 Number 值。
注: parseFloat 可以只把 string 的开头部分解释为数值;它会忽略所有不能解释为数值字面量记法的一部分的字符,并且没有指示会给出任何这些忽略的字符。

isNaN (number)

如果指定参数为 NaN,则返回 true,否则返回 false

  1. 如果 ToString(number) 是 NaN,返回 trueV8.png
  2. 否则 ,返回 false
注: 一个用 ECMAScript 代码来测试值 X 是否是 NaN 的方式是使用表达式 X !== X。仅当 XNaN 时结果才是 true

isFinite (number)

如果指定参数为 NaN+∞−∞,则返回 false,否则返回 true

  1. 如果 ToNumber(number) 是 NaN+∞−∞,返回 falseV8.png
  2. 否则,返回 true

处理 URI 的函数属性


统一资源标识符,或叫做 URI,是用来标识互联网上的资源(例如,网页或文件)和怎样访问这些资源的传输协议(例如,HTTP 或 FTP)的字符串。除了 15.1.3.1, 15.1.3.2, 15.1.3.315.1.3.4 说明的用来编码和解码 URI 的函数之外 ECMAScript 语言自身不提供任何使用 URL 的支持。

注: 许多 ECMAScript 实现提供额外的函数,方法来操作网页;这些函数超出了本标准的范围。

一个 URI 是由组件分隔符分割的组件序列组成。其一般形式是:

Scheme : First / Second ; Third ? Fourth

其中斜体的名字代表组件;“:”, “/”, “;”,“?”是当作分隔符的保留字符。encodeURIdecodeURI 函数操作的是完整的 URI;这俩函数假定 URI 中的任何保留字符都有特殊意义,所有不会编码它们。encodeURIComponentdecodeURIComponent 函数操作的是组成 URI 的个别组件;这俩函数假定任何保留字符都代表普通文本,所以必须编码它们,所以它们出现在组成一个完整 URI 的组件里面时不会解释成保留字符了。

以下词法文法指定了编码后 URI 的形式。

 uri :::
   uriCharactersopt
 uriCharacters :::
   uriCharacter uriCharactersopt
 uriCharacter :::
   uriReserved
   uriUnescaped
   uriEscaped
 uriReserved ::: one of
   ; / ? : @ & = + $ ,
 uriUnescaped :::
   uriAlpha
   DecimalDigit
   uriMark
 uriEscaped :::
   % HexDigit HexDigit
 uriAlpha ::: one of
   a b c d e f g h i j k l m n o p q r s t u v w x y z
   A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
 uriMark ::: one of
   - _ . ! ~ * ' ( )
注: 以上语法是基于 RFC 2396 的,并且较新的 RFC 3986 引入的更改没有反应在这里。

当 URI 里包含一个没在上面列出的字符或有时不想让给定的保留字符有特殊意义,那么必须编码这个字符。字符被转换成 UTF-8 编码,首先从 UT​​F-16 转换成相应的代码点值的替代。(注:对于 [0,127] 范围的代码单元,转换到单字节时它们的值是相同的。)然后返回的字节序列转换为一个字符串,每个字节用一个“%xx”形式的转移序列表示。

描述编码和转义过程的抽象操作 Encode 需要两个字符串参数 stringunescapedSet

  1. strLenstring 的字符个数。
  2. R 为空字符串。
  3. k0
  4. 重复
    1. 如果 k 等于 strLen,返回 R
    2. Cstring 中位置为 k 的字符。
    3. 如果 CunescapedSet 里,则
      1. S 为一个只包含字符 C 的字符串。
      2. R 为之前 R 的值和 S 连接得到的一个新字符串值。
    4. 否则,C 不在 unescapedSet
      1. 如果 C 的代码单元值不小于 0xDC00 并且不大于 0xDFFF,则抛出一个 URIError 异常。Note.png
      2. 如果 C 的代码单元值小于 0xD800 或大于 0xDBFF,则 Note.png
        1. VC 的代码单元值。
      3. 否则 Note.png
        1. k 递增 1
        2. 如果 k 等于 strLen,抛出一个 URIError 异常。 Note.png
        3. kCharstringk 位置的字符的代码单元值。
        4. 如果 kChar 小于 0xDC00 或大于 0xDFFF,则抛出一个 URIError 异常。Note.png
        5. V 为 (((C的代码单元值 ) – 0xD800) * 0x400 + (kChar0xDC00) + 0x10000)。Note.png
      4. OctetsV 执行 UTF-8 转换的结果字节数组,令 L 为这个字节数组的长度。
      5. j0
      6. 只要 j < L,就重复
        1. jOctetOctetsj 位置的值。
        2. S 为一个包含三个字符“%XY”的字符串,这里 XY 是编码 jOctet 值的两个大写16进制数字。
        3. R 为之前 R 的值和 S 连接得到的一个新字符串值。
        4. j 递增 1
    5. k 递增 1


描述反转义和解码过程的抽象操作 Decode 需要两个字符串参数 stringreservedSet

  1. strLenstring 的字符个数。
  2. R 为空字符串。
  3. k0
  4. 重复
    1. 如果 k 等于 strLen,返回 R
    2. Cstringk 位置的字符。
    3. 如果 C 不是‘%’,则
      1. S 为只包含字符 C 的字符串。
    4. 否则,C 是‘%
      1. startk
      2. 如果 k + 2 大于或等于 strLen,抛出一个 URIError 异常。 Note.png
      3. 如果 string 的 (k + 1) 和 (k + 2) 位置的字符没有表示为16进制数字,则抛出一个 URIError 异常。Note.png
      4. B 为 (k + 1) 和 (k + 2) 位置的两个16进制数字表示的8位值。
      5. k 递增 2.
      6. 如果 B 的最高有效位是 0,则 Note.png
        1. C 为代码单元值是 B 的字符。
        2. 如果 C 不在 reservedSet 里,则
          1. S 为只包含字符 C 的字符串。
        3. 否则,CreservedSet
          1. Sstring 的从位置 start 到位置 k 的子字符串。
      7. 否则,B 的最高有效位是 1 Note.png
        1. n 为满足 (B << n) & 0x80 等于 0 的最小非负数。Note.png
        2. 如果 n 等于 1n 大于 4,抛出一个 URIError 异常。Note.png
        3. Octets 为一个长度为 n 的字节数组。
        4. B 放到 Octets0 位置。
        5. 如果 k + (3 * (n1)) 大于或等于 strLen,抛出一个 URIError 异常。Note.png
        6. j1
        7. 重复,直到 j < n
          1. k 递增 1
          2. 如果 stringk 位置的字符不是‘%’,抛出一个 URIError 异常。
          3. 如果 string 的 (k + 1) 和 (k + 2) 位置的字符没有表示为16进制数字,抛出一个 URIError 异常。
          4. Bstring 的 (k + 1') 和 (k + 2) 位置的两个16进制数字表示的8位值。
          5. 如果 B 的两个最高有效位不是二进制的 10,抛出一个 URIError 异常。Note.png
          6. k 递增 2
          7. B 放到 Octetsj 位置。
          8. j 递增 1
        8. V 为给 Octets 执行 UTF-8 转换得到的值,这是从一个字节数组到一个21位值的转换过程。Note.png如果 Octets 不包含有效的 UTF-8 编码的 Unicode 代码点,则抛出一个 URIError 异常。
        9. 如果 V 小于 0x10000,则 Note.png
          1. C 为代码单元值是 V 的字符。
          2. 如果 C 不在 reservedSet 里,则
            1. S 为只包含字符 C 的字符串。
          3. 否则,CreservedSet
            1. Sstring 的从位置 start 到位置 k 的子字符串。
        10. 否则,V0x10000 Note.png
          1. L 为 (((V0x10000) & 0x3FF) + 0xDC00)。
          2. H 为 ((((V0x10000) >> 10) & 0x3FF) + 0xD800)。
          3. S 为代码单元值是 HL 的两个字符组成的字符串。
  5. R 为之前的 RS 连接成的新字符串。
  6. k 递增 1
注: 统一资源标识符的语法由 RFC 2396 给出,这里并没有反应更新的替换了 RFC 2396RFC 3986RFC 3629 给出了实现 UTF-8 的正式描述。

在 UTF-8 中,用 1 到 6 个位的字节序列来编码字符。只有“序列”中高阶位设置为 0 的字节,其余的 7 位才用于编码字符值。在一个 n 个字节的序列中,n > 1,初始字节有 n 个设置为 1 的高阶位,其后的一位设置为 0。这个字节的其它位包含了字符编码的位。随后的其它字节都是最高位为 1、次高位为 0、剩下的 6 位为字符编码。表21 指定了 ECMAScript 字符可能的 UTF-8 编码。


表21 — UTF-8 Encodings
单位代码值 表现 第一字节 第二字节 第三字节 第四字节
0x0000 - 0x007F 00000000 0zzzzzzz 0zzzzzzz
0x0080 - 0x07FF 00000yyy yyzzzzzz 110yyyyy 10zzzzzz
0x0800 - 0xD7FF xxxxyyyy yyzzzzzz 1110xxxx 10yyyyyy 10zzzzzz
0xD800 - 0xDBFF
挨着
0xDC00 - 0xDFFF
110110vv vvwwwwxx
挨着
110111yy yyzzzzzz
11110uuu 10uuwwww 10xxyyyy 10zzzzzz
0xD800 - 0xDBFF
不挨着
0xDC00 - 0xDFFF
引发URIError
0xDC00 - 0xDFFF 引发URIError
0xE000 - 0xFFFF xxxxyyyy yyzzzzzz 1110xxxx 10yyyyyy 10zzzzzz

在这里

uuuuu = vvvv + 1

以补足替代符的 0x10000 附加值,在 Unicode 标准 3.7 章节。


0xD800-0xDFFF 范围的代码单元值用来编码替代符对;如上将 UTF-16 替代符对转换组合成一个 UTF-32 表示法,并将其编码到一个 UTF-8 的21位值中。这就是替代符对的解码方式。 Note.png

RFC 3629 禁止对无效 UTF-8 字节序列的解码。例如,无效序列 C0 80 不能解码成字符 U+0000。当 Decode 算法的实现遇到这样的无效序列必须抛出一个 URIError 异常。


decodeURI (encodedURI)

decodeURI 函数计算出一个新版 URI,将 URI 中可能是 encodeURI 函数引入的每个转义序列和 UTF-8 编码组替换为代表它们的字符。不是 encodeURI 导入的转义序列不会被替换。

当以一个参数 encodedURI 调用 decodeURI 函数,采用如下步骤:

  1. uriStringToString(encodedURI)。V8.png
  2. reservedURISet 为一个包含 uriReserved 中的所有字符组成的字符串连接上 "#" 组成的字符串。
  3. 返回调用 Decode(uriString, reservedURISet) 的结果。
注: "#" 字符不会从转义序列中解码,即使它不是 URI 保留字符。


decodeURIComponent (encodedURIComponent)

decodeURIComponent 函数计算出一个新版 URI,将 URI 中可能是 encodeURIComponent 函数引入的每个转义序列和 UTF-8 编码组替换为代表它们的字符。

当以一个参数 encodedURIComponent 调用 decodeURIComponent 函数,采用如下步骤:

  1. componentStringToString(encodedURIComponent)。V8.png
  2. reservedURIComponentSet 为一个空字符串。
  3. 返回调用 Decode(componentString, reservedURIComponentSet) 的结果。


encodeURI (uri)

encodeURI 函数计算出一个新版 URI,将 URI 中某些字符的每个实例替换为代表这些字符 UTF-8 编码的一个,两个或三个转义序列。

当以一个参数 uri 调用 encodeURI 函数,采用如下步骤:

  1. uriStringToString(uri)。V8.png
  2. unescapedURISet 为一个包含 uriReserveduriUnescaped 中所有字符组成的字符串连接上 "#" 组成的字符串。
  3. 返回调用 Encode(uriString, unescapedURISet) 的结果。
注: 字符 "#" 不会被编码为一个转义序列,即使它不是 URI 保留字符或非转义字符。


encodeURIComponent (uriComponent)

encodeURIComponent 函数计算出一个新版 URI,将 URI 中某些字符的每个实例替换为代表这些字符 UTF-8 编码的一个,两个或三个转义序列。

当以一个参数 uriComponent 调用 encodeURIComponent 函数,采用如下步骤:

  1. componentStringToString(uriComponent)。V8.png
  2. unescapedURIComponentSet 为一个包含 uriUnescaped 中所有字符组成的字符串。
  3. 返回调用 Encode(componentString, unescapedURIComponentSet) 的结果。

全局对象的构造器属性

Object ( . . . )


15.2.115.2.2.

Function ( . . . )


15.3.115.3.2

Array ( . . . )


15.4.115.4.2.

String ( . . . )


15.5.115.5.2.

Boolean ( . . . )


15.6.115.6.2.

Number ( . . . )


15.7.115.7.2.

Date ( . . . )


15.9.2.

RegExp ( . . . )


15.10.315.10.4.

Error ( . . . )


15.11.115.11.2.

EvalError ( . . . )


见 15.11.6.1.

RangeError ( . . . )


15.11.6.2.

ReferenceError ( . . . )


15.11.6.3.

SyntaxError ( . . . )


15.11.6.4.

TypeError ( . . . )


15.11.6.5.

URIError ( . . . )


15.11.6.6.

全局对象的其他属性

Math


15.8.

JSON


15.12.

Object 对象


作为函数调用 Object 构造器

当把 Object 当做一个函数来调用,而不是一个构造器,它会执行一个类型转换。


Object ( [ value ] )

当以一个参数 value 或者无参数调用 Object 函数,采用如下步骤:

  1. 如果 valuenullundefined 或未指定,则创建并返回一个新 Object 对象,这个对象与仿佛用相同参数调用标准内置的 Object 构造器 (15.2.2.1) 的结果一样。V8.png
  2. 返回 ToObject(value)。V8.png


Object 构造器

Objectnew 表达式调用的一部分时,它是一个构造器,可创建一个对象。


new Object ( [ value ] )

当以一个参数 value 或者无参数调用 Object 构造器,采用如下步骤:

  1. 如果提供了 value,则
    1. 如果 Type(value) 是 Object,则
      1. 如果 value 是个原生 ECMAScript 对象,不创建新对象,简单的返回 value
      2. 如果 value 是宿主对象,则采取动作和返回依赖实现的结果的方式可以使依赖于宿主对象的。
    2. 如果 Type(value) 是 String,返回 ToObject(value)。
    3. 如果 Type(value) 是 Boolean,返回 ToObject(value)。
    4. 如果 Type(value) 是 Number,返回 ToObject(value)。
  2. 断言:未提供参数 value 或其类型是 NullUndefined
  3. obj 为一个新创建的原生 ECMAScript 对象。
  4. 设定 obj[[Prototype]] 内部属性为标准内置的 Objectprototype 对象 (15.2.4)。
  5. 设定 obj[[Class]] 内部属性为 "Object"
  6. 设定 obj[[Extensible]] 内部属性为 true
  7. 设定 obj8.12 指定的所有内部方法
  8. 返回 obj


Object 构造器的属性

Object 构造器的 [[Prototype]] 内部属性值是标准内置 Functionprototype 对象。

除了内部属性和 length 属性(其值是 1)之外,Object 构造器拥有以下属性:


Object.prototype

Object.prototype 的初始值是标准内置 Objectprototype 对象(15.2.4)。

这个属性包含特性 {[[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }


Object.getPrototypeOf ( O )

当以参数 O 调用 getPrototypeOf 函数,采用如下步骤:

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常。V8.png
  2. 返回 O[[Prototype]] 内部属性的值。V8.png


Object.getOwnPropertyDescriptor ( O, P )

当调用 getOwnPropertyDescriptor 函数,采用如下步骤:

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常。V8.png
  2. nameToString(P)。
  3. desc 为以参数 name 调用 O[[GetOwnProperty]] 内部方法的结果。V8.png
  4. 返回调用 FromPropertyDescriptor(desc) 的结果。


Object.getOwnPropertyNames ( O )

当调用 getOwnPropertyNames 函数,采用如下步骤:Note.png

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常。V8.png
  2. array 为仿佛是用表达式 new Array () 创建新对象的结果,这里的 Array 是标准内置构造器名。
  3. n0
  4. O 的每个自身属性 P
    1. name 为值是 P 的名称的字符串。
    2. ToString(n) 和属性描述 {[[Value]]: name, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 为参数调用 array[[DefineOwnProperty]] 内部方法。V8.png
    3. n 递增 1
  5. 返回 array
注: 如果 O 是一个字符串实例,第4步 处理的自身属性集合包含 15.5.5.2 定义的隐藏属性,他们对应对象的 [[PrimitiveValue]] 字符串中相应位置的字符。


Object.create ( O [, Properties] )

create 函数按照指定的原型创建一个新对象。当调用 create 函数,采用如下步骤:

  1. 如果 Type(O) 不是 ObjectNull,则抛出一个 TypeError 异常。V8.png
  2. obj 为仿佛是用表达式 new Object() 创建新对象的结果,这里的 Object 是标准内置构造器名。 V8.png
  3. 设定 obj[[Prototype]] 内部属性为 OV8.png
  4. 如果传入了 Properties 参数并且不是 undefined,则仿佛是用 objProperties 当作参数调用标准内置函数 Object.defineProperties 一样给 obj 添加自身属性。V8.png
  5. 返回 obj


Object.defineProperty ( O, P, Attributes )

defineProperty 函数用于给一个对象添加一个自身属性以及更新现有自身属性的特性。当调用 defineProperty 函数,采用如下步骤:

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常。V8.png
  2. nameToString(P)。
  3. desc 为以 Attributes 作为参数调用 ToPropertyDescriptor 的结果。V8.png
  4. namedesctrue 作为参数调用 O[[DefineOwnProperty]] 内部方法 .V8.png
  5. 返回 O


Object.defineProperties ( O, Properties )

defineProperties 函数用于给一个对象添加一些自身属性以及更新现有的一些自身属性的特性。当调用 defineProperties 函数,采用如下步骤:

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常。V8.png
  2. propsToObject(Properties)。V8.png
  3. names 为一个内部列表,它包含 props 的每个可遍历自身属性的名称。
  4. descriptors 为一个空的内部列表。
  5. names 的每个元素 P,按照列表顺序 ,
    1. descObj 为以 P 作为参数调用 props[[Get]] 内部方法的结果。
    2. desc 为以 descObj 作为参数调用 ToPropertyDescriptor 的结果。
    3. desc 插入 descriptors 的尾部。
  6. descriptors 的每个元素 desc,按照列表顺序 ,
    1. 以参数 Pdesctrue 调用 O[[DefineOwnProperty]] 内部方法。V8.png
  7. 返回 O

如果一个实现为 for-in 语句 的定义了特定的枚举顺序,那么在这个算法的 第3步 中的列表元素必须也用相同的顺序排列。


Object.seal ( O )

当调用 seal 函数,采用如下步骤:

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常。V8.png
  2. O 的每个命名自身属性名 P,
    1. desc 为以参数 P 调用 O[[GetOwnProperty]] 内部方法的结果。V8.png
    2. 如果 desc.[[Configurable]]true,设定 desc.[[Configurable]]falseV8.png
    3. Pdesctrue 为参数调用 O[[DefineOwnProperty]] 内部方法。
  3. 设定 O[[Extensible]] 内部属性为 falseV8.png
  4. 返回 O


Object.freeze ( O )

当调用 freeze 函数,采用如下步骤:

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常。V8.png
  2. O 的每个命名自身属性名 P,
    1. desc 为以参数 P 调用 O[[GetOwnProperty]] 内部方法的结果。V8.png
    2. 如果 IsDataDescriptor(desc) 是 true,则
      1. 如果 desc.[[Writable]]true,设定 desc[[Writable]]false.V8.png
    3. 如果 desc.[[Configurable]]true,设定 desc[[Configurable]]false
    4. Pdesctrue 作为参数调用 O[[DefineOwnProperty]] 内部方法。
  3. 设定 O[[Extensible]] 内部属性为 falseV8.png
  4. 返回 O


Object.preventExtensions ( O )

当调用 preventExtensions 函数,采用如下步骤:

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常 .V8.png
  2. 设定 O[[Extensible]] 内部属性为 falseV8.png
  3. 返回 O


Object.isSealed ( O )

当以参数 O 调用 isSealed 函数,采用如下步骤:

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常。V8.png
  2. O 的每个命名自身属性名 P
    1. desc 为以参数 P 调用 O[[GetOwnProperty]] 内部方法的结果 .V8.png
    2. 如果 desc.[[Configurable]]true,则返回 false
  3. 如果 O[[Extensible]] 内部属性是 false,则返回 true
  4. 否则,返回 false


Object.isFrozen ( O )

当以参数 O 调用 isFrozen 函数,采用如下步骤:

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常。V8.png
  2. O 的每个命名自身属性名 P,
    1. desc 为以参数 P 调用 O[[GetOwnProperty]] 内部方法的结果 .
    2. 如果 IsDataDescriptor(desc) 是 true,则
      1. 如果 desc.[[Writable]]true,则返回 false
    3. 如果 desc.[[Configurable]]true,则返回 false
  3. 如果 O[[Extensible]] 内部属性是 false,则返回 true
  4. 否则,返回 false


Object.isExtensible ( O )

当以参数 O 调用 isExtensible 函数,采用如下步骤:

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常。V8.png
  2. 返回 O[[Extensible]] 内部属性布尔值。V8.pngV8.png


Object.keys ( O )

当以参数 O 调用 keys 函数,采用如下步骤:

  1. 如果 Type(O) 不是 Object,则抛出一个 TypeError 异常。V8.png
  2. nO 的可遍历自身属性的个数
  3. array 为仿佛是用表达式 new Array() 创建新对象的结果,这里的 Array 是标准内置构造器名。
  4. index0
  5. O 的每个可遍历自身属性名 PNote.png
    1. ToString(index),属性描述 {[[Value]]: P, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true},和 false 作为参数调用 array 的 [[DefineOwnProperty]] 内部方法。
    2. index 递增 1
  6. 返回 array

如果一个实现为 for-in 语句 的定义了特定的枚举顺序,那么在这个算法的 第5步 中的必须使用相同的枚举顺序。


Object 的 prototype 对象的属性

Objectprototype 对象的 [[Prototype]] 内部属性的值是 null Note.png[[Class]] 内部属性的值是 "Object"[[Extensible]] 内部属性的初始值是 true


Object.prototype.constructor

Object.prototype.constructor 的初始值是标准内置的 Object 构造器。


Object.prototype.toString ( )

当调用 toString 方法,采用如下步骤:Note.png

  1. 如果 this 的值是 undefined,返回 "[object Undefined]"V8.png
  2. 如果 this 的值是 null,返回 "[object Null]"V8.png
  3. O 为以 this 作为参数调用 ToObject 的结果。
  4. classO[[Class]] 内部属性的值。V8.png
  5. 返回三个字符串 "[object "class"]" 连起来的字符串。


Object.prototype.toLocaleString ( )

当调用 toLocaleString 方法,采用如下步骤:

  1. O 为以 this 作为参数调用 ToObject 的结果。
  2. toString 为以 "toString" 作为参数调用 O[[Get]] 内部方法的结果.
  3. 如果 IsCallable(toString) 是 false,抛出一个 TypeError 异常。V8.png
  4. 返回以 O 作为 this 值,无参数调用 toString[[Call]] 内部方法的结果。
注: 这个函数给所有 Object 对象提供一个通用的 toLocaleString 接口,即使并不是所有的都使用它。目前,ArrayNumberDate 都提供了它们自身的语言环境敏感的 toLocaleString 方法。
注: 这个函数的第一个参数可能会在此标准的未来版本中使用到;因此建议实现不要用这个位置参数来做其他事情。


Object.prototype.valueOf ( )

当调用 valueOf 方法,采用如下步骤:

  1. O 为以 this 作为参数调用 ToObject 的结果。V8.png
  2. 如果 O 是以一个宿主对象 (15.2.2.1) 为参数调用 Object 构造器的结果,则
    1. 返回 O 或返回先前传递给构造器的原宿主对象。返回的具体结果是由实现定义的。
  3. 返回 O


Object.prototype.hasOwnProperty (V)

当以参数 V 调用 hasOwnProperty 方法,采用如下步骤:

  1. PToString(V)。V8.png
  2. O 为以 this 值作为参数调用 ToObject 的结果。
  3. desc 为以 P 为参数调用 O[[GetOwnProperty]] 内部方法的结果。
  4. 如果 descundefined,返回 false
  5. 返回 true
注: 不像 [[HasProperty]](8.12.6),这个方法不考虑原形链中的对象。
注: 第1步第2步 选择这样的顺序是为了确保,即使 this 值是 undefinednull,本规范之前版本中任何会在 第1步 抛出的异常,都会继续在本规范中抛出。Note.png


Object.prototype.isPrototypeOf (V)

当以参数 V 调用 isPrototypeOf 方法,采用如下步骤:

  1. 如果 V 不是个对象,返回 false
  2. O 为以 this 作为参数调用 ToObject 的结果。V8.png
  3. 重复
    1. VV[[Prototype]] 内部属性的值。V8.png
    2. 如果 Vnull,返回 false
    3. 如果 OV 指向同一个对象,返回 true
注: 第1步第2步 选择这样的顺序是为了,当 V 不是对象并且 this 值是 undefinednull 时能够保持本规范之前版本指定的行为。


Object.prototype.propertyIsEnumerable (V)

当以参数 V 调用 propertyIsEnumerable 方法,采用如下步骤:

  1. PToString(V)。V8.png
  2. O 为以 this 作为参数调用 ToObject 的结果。
  3. desc 为以 P 作为参数调用 O[[GetOwnProperty]] 内部方法的结果。V8.png
  4. 如果 descundefined,返回 false
  5. 返回 desc.[[Enumerable]] 的值。
注: 这个方法不考虑原型链中的对象。
注: 第1步第2步 选择这样的顺序是为了确保,即使 this 值是 undefinednull,本规范之前版本中任何会在 第1步 抛出的异常,都会继续在本规范中抛出。Note.png


Object 的实例的属性

Object 的实例除了拥从 Objectprototype 对象继承来的属性之外不包含特殊的属性。

Function 对象


作为函数调用 Function 构造器

当将 Function 作为函数来调用,而不是作为构造器,它会创建并初始化一个新函数对象。所以函数调用 Function() 与用相同参数的 new Function() 表达式创建的对象相同。


Function (p1, p2, … , pn, body)

当以 p1p2、…、pnbody 作为参数调用 Function 函数(这里的 n 可以是 0,也就是说没有“p”参数,这时还可以不提供 body),采用如下步骤:

  1. 创建并返回一个新函数对象,它仿佛是用相同参数给标准内置构造器 Function (15.3.2.1). 用一个 new 表达式创建的。


Function 构造器

Function 作为 new 表达式的一部分被调用时,它是一个构造器:它初始化新创建的对象。


new Function (p1, p2, … , pn, body)

最后一个参数指定为函数的 body(可执行代码);之前的任何参数都指定为形式参数。

当以 p1p2、…、pnbody 作为参数调用 Function 构造器(这里的 n 可以是 0,也就是说没有“p”参数,这时还可以不提供 body),采用如下步骤:

  1. argCount 为传给这个函数调用的参数总数。
  2. P 为空字符串。
  3. 如果 argCount = 0,令 body 为空字符串。
  4. 否则如果 argCount = 1,令 body 为那个参数。
  5. 否则,argCount > 1
    1. firstArg 为第一个参数。
    2. PToString( firstArg )。
    3. k2
    4. 只要 k < argCount 就重复
      1. nextArg 为第 k 个参数。
      2. P 为之前的 P 值,字符串 ","(一个逗号),ToString( nextArg ) 串联的结果。V8.png
      3. k 递增 1
    5. body 为第 k 个参数。
  6. bodyToString( body )。
  7. 如果 P 不可解析为一个 FormalParameterList,则抛出一个 SyntaxError 异常。Note.png Note.png V8.png
  8. 如果 body 不可解析为 FunctionBody,则抛出一个 SyntaxError 异常。Note.png V8.png
  9. 如果 body 是严格模式代码 ( 见 10.1.1),则令 stricttrue,否则令 strictfalse
  10. 如果 stricttrue,适用 13.1 指定抛出的任何异常。
  11. 返回一个新创建的函数对象,它是依照 13.2 专递 P 作为 FormalParameterListbody 作为 FunctionBody全局环境作为 Scope 参数、strict 作为严格模式标志。

每个函数都会自动创建一个 prototype 属性,用来支持函数被当做构造器使用的可能性。

注: 为每个形参指定一个参数是允许的,但没必要。例如以下三个表达式产生相同的结果:
 new Function("a", "b", "c", "return a+b+c")
 new Function("a, b, c", "return a+b+c")
 new Function("a,b", "c", "return a+b+c")


Function 构造器的属性

Function 构造器自身是个函数对象,它的 [[Class]]"Function"Function 构造器的 [[Prototype]] 内部属性值是标准内置 Functionprototype 对象 (15.3.4)。

Function 构造器的 [[Extensible]] 内部属性值是 true.

Function 构造器有如下属性 :


Function.prototype

Function.prototype 的初始值是标准内置 Functionprototype 对象 (15.3.4)。

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


Function.length

这是个值为 1 的数据属性。此属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。


Function 的 prototype 对象的属性

Functionprototype 对象自身是一个函数对象 ( 它的 [[Class]]"Function"),调用这个函数对象时,接受任何参数并返回 undefinedNote.png

Functionprototype 对象的 [[Prototype]] 内部属性值是标准内置 Objectprototype 对象 (15.2.4)。Functionprototype 对象的 [[Extensible]] 内部属性的初始值是 true

Functionprototype 对象自身没有 valueOf 属性 ; 但是,它从 Objectprototype 对象继承了 valueOf 属性。

Functionprototype 对象的 length 属性是 0


Function.prototype.constructor

Function.prototype.constructor 的初始值是内置 Function 构造器。


Function.prototype.toString ( )

此函数的返回值的表示是依赖于实现的。这个表示包含 FunctionDeclaration 的语法。特别注意,怎样在这个字符串表示中使用和放置空白、行终止符、分号,是依赖于实现的。 Note.png Ms.png

这个 toString 不是通用的;如果它的 this 值不是一个函数对象,它会抛出一个 TypeError 异常。因此,它不能当做方法来转移到其他类型的对象中。V8.png


Function.prototype.apply (thisArg, argArray)

当以 thisArgargArray 为参数在一个 func 对象上调用 apply 方法,采用如下步骤:

  1. 如果 IsCallable( func ) 是 false,则抛出一个 TypeError 异常。
  2. 如果 argArraynullundefined,则
    1. 返回提供 thisArg 作为 this 值并以空参数列表调用 func[[Call]] 内部方法的结果。
  3. 如果 Type( argArray ) 不是 Object,则抛出一个 TypeError 异常。
  4. len 为以 "length" 作为参数调用 argArray[[Get]] 内部方法的结果。
  5. nToUint32( len )。
  6. argList 为一个空列表。
  7. index0
  8. 只要 index < n 就重复
    1. indexNameToString( index )。
    2. nextArg 为以 indexName 作为参数调用 argArray[[Get]] 内部方法的结果。
    3. nextArg 作为最后一个元素插入到 argList 里。
    4. 设定 indexindex + 1
  9. 提供 thisArg 作为 this 值并以 argList 作为参数列表,调用 func[[Call]] 内部方法,返回结果。

apply 方法的 length 属性是 2

注: 在外面传入的 thisArg 值会修改并成为 this 值。thisArgundefinednull 时它会被替换成全局对象,所有其他值会被应用 ToObject 并将结果作为 this 值,这是第三版引入的更改。


Function.prototype.call (thisArg [ , arg1 [ , arg2, … ] ] )

当以 thisArg 和可选的 arg1arg2 等等作为参数在一个 func 对象上调用 call 方法,采用如下步骤:

  1. 如果 IsCallable(func) 是 false,则抛出一个 TypeError 异常。
  2. argList 为一个空列表。
  3. 如果调用这个方法的参数多余一个,则从 arg1 开始以从左到右的顺序将每个参数插入为 argList 的最后一个元素。
  4. 提供 thisArg 作为 this 值并以 argList 作为参数列表,调用 func[[Call]] 内部方法,返回结果。

call 方法的 length 属性是 1

注: 在外面传入的 thisArg 值会修改并成为 this 值。thisArgundefinednull 时它会被替换成全局对象,所有其他值会被应用 ToObject 并将结果作为 this 值,这是第三版引入的更改。

Function.prototype.bind (thisArg [, arg1 [, arg2, …]])

bind 方法需要一个或更多参数,thisArg 和(可选的)arg1arg2,等,执行如下步骤返回一个新函数对象:

  1. Targetthis 值 .
  2. 如果 IsCallable( Target ) 是 false,抛出一个 TypeError 异常 .V8.png
  3. A 为一个(可能为空的)新内部列表,它包含按顺序的 thisArg 后面的所有参数(arg1arg2,等)。
  4. F 为一个新原生 ECMAScript 对象。
  5. 依照 8.12 指定,设定 F 的除了 [[Get]] 之外的所有内部方法。
  6. 依照 15.3.5.4 指定,设定 F[[Get]] 内部属性。
  7. 设定 F[[TargetFunction]] 内部属性为 Target
  8. 设定 F[[BoundThis]] 内部属性为 thisArg 的值。
  9. 设定 F[[BoundArgs]] 内部属性为 A
  10. 设定 F[[Class]] 内部属性为 "Function"
  11. 设定 F[[Prototype]] 内部属性为 15.3.3.1 指定的标准内置 Functionprototype 对象。
  12. 依照 15.3.4.5.1 描述,设定 F[[Call]] 内置属性。
  13. 依照 15.3.4.5.2 描述,设定 F[[Construct]] 内置属性。
  14. 依照 15.3.4.5.3 描述,设定 F[[HasInstance]] 内置属性。
  15. 如果 Target[[Class]] 内部属性是 "Function",则
    1. LTargetlength 属性减 A 的长度。V8.png
    2. 设定 Flength 自身属性为 0L 中更大的值。
  16. 否则设定 Flength 自身属性为 0.
  17. 设定 Flength 自身属性的特性为 15.3.5.1 指定的值。
  18. 设定 F[[Extensible]] 内部属性为 true
  19. thrower[[ThrowTypeError]] 函数对象 (13.2.3)。
  20. "caller", 属性描述符 {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, 和 false 作为参数调用 F 的 [[DefineOwnProperty]] 内部方法。
  21. "arguments", 属性描述符 {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, 和 false 作为参数调用 F 的 [[DefineOwnProperty]] 内部方法。
  22. 返回 F.

bind 方法的 length 属性是 1

注:Function.prototype.bind 创建的函数对象不包含 prototype 属性或 [[Code]][[FormalParameters]][[Scope]] 内部属性。


[[Call]]

当调用一个用 bind 函数创建的函数对象 F[[Call]] 内部方法,传入一个 this 值和一个参数列表 ExtraArgs,采用如下步骤:

  1. boundArgsF[[BoundArgs]] 内部属性值。
  2. boundThisF[[BoundThis]] 内部属性值。
  3. targetF[[TargetFunction]] 内部属性值。
  4. args 为一个新列表,它包含与列表 boundArgs 相同顺序相同值,后面跟着与 ExtraArgs 是相同顺序相同值。
  5. 提供 boundThis 作为 this 值,提供 args 为参数调用 target[[Call]] 内部方法,返回结果。


[[Construct]]

当调用一个用 bind 函数创建的函数对象 F[[Construct]] 内部方法,传入一个参数列表 ExtraArgs,采用如下步骤:

  1. targetF[[TargetFunction]] 内部属性值。
  2. 如果 target 不包含 [[Construct]] 内部方法,抛出一个 TypeError 异常。
  3. boundArgsF[[BoundArgs]] 内部属性值。
  4. args 为一个新列表,它包含与列表 boundArgs 相同顺序相同值,后面跟着与 ExtraArgs 是相同顺序相同值。
  5. 提供 args 为参数调用 target[[Construct]] 内部方法,返回结果。


[[HasInstance]] (V)

当调用一个用 bind 函数创建的函数对象 F[[HasInstance]] 内部方法,并以 V 作为参数,采用如下步骤:

  1. targetF[[TargetFunction]] 内部属性值。
  2. 如果 target 不包含 [[HasInstance]] 内部方法,抛出一个 TypeError 异常。
  3. 提供 V 为参数调用 target[[HasInstance]] 内部方法,返回结果。


Function 的实例的属性

除了必要的内部属性之外,每个函数实例还有一个 [[Class]] 内部属性并且在大多数情况下使用不同版本的 [[Call]] 内部属性。函数实例根据怎样创建的(见 8.6.213.21515.3.4.5)可能还有一个 [[HasInstance]] 内部属性、一个 [[Scope]] 内部属性、一个 [[Construct]] 内部属性、一个 [[FormalParameters]] 内部属性、一个 [[Code]] 内部属性、一个 [[TargetFunction]] 内部属性、一个 [[BoundThis]] 内部属性、一个 [[BoundArgs]] 内部属性。

[[Class]] 内部属性的值是 "Function"

对应于严格模式函数 (13.2) 的函数实例和用 Function.prototype.bind 方法 (15.3.4.5) 创建的函数实例有名为“caller”和 “arguments”的属性时,抛出一个 TypeError 异常。一个 ECMAScript 实现不得为在严格模式函数代码里访问这些属性关联任何依赖实现的特定行为。 V8.png


length

length 属性值是个整数,它指出函数预期的“一般的”参数个数。然而,语言允许用其他数量的参数来调用函数。当以与函数的 length 属性指定的数量不同的参数个数调用函数时,它的行为依赖于函数自身。这个属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。


prototype

prototype 属性的值用于初始化一个新创建对象的的 [[Prototype]] 内部属性,为了这个新创建对象要先将函数对象作为构造器调用。这个属性拥有特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }。

注: 用 Function.prototype.bind 创建的函数对象没有 prototype 属性。


[[HasInstance]] (V)

F 是个函数对象。 当以 V 作为参数调用 F[[HasInstance]] 内部方法,采用如下步骤:

  1. 如果 V 不是个对象,返回 false
  2. O 为用属性名 "prototype" 调用 F[[Get]] 内部方法的结果。
  3. 如果 Type(O) 不是 Object,抛出一个 TypeError 异常。
  4. 重复
    1. VV[[Prototype]] 内部属性值。
    2. 如果 Vnull,返回 false
    3. 如果 OV 指向相同对象,返回 true
注: 用 Function.prototype.bind 创建的函数对象拥有的不同的 [[HasInstance]] 实现,在 15.3.4.5.3 中定义。


[[Get]] (P)

函数对象与其他原生 EMACScript 对象 (8.12.3) 用不同的 [[Get]] 内部方法。

F 是一个函数对象,当以属性名 P 调用 F[[Get]] 内部方法,采用如下步骤:

  1. v 为传入 P 作为属性名参数调用 F 的默认 [[Get]] 内部方法 (8.12.3) 的结果。
  2. 如果 P"caller" 并且 v 是个严格模式函数对象,抛出一个 TypeError 异常。
  3. 返回 v
注: 用 Function.prototype.bind 创建的函数对象使用默认的 [[Get]] 内部方法。

Array 对象

数组对象会给予一些特定种类的属性名特殊待遇。对一个属性名 P(字符串形式),当且仅当 ToString(ToUint32(P)) 等于 P 并且 ToUint32(P) 不等于 232 - 1 时,它是个数组索引。一个属性名是数组索引的属性还叫做元素 。所有数组对象都有一个 length 属性,其值始终是一个小于 232 的非负整数。length 属性值在数值上比任何名为数组索引的属性名称还要大;每当创建或更改一个数组对象的属性,都要调整其他属性以保持上面那个条件不变。具体来说,每当添加一个名为数组索引的属性时,如果需要就更改 length 属性为在数值上比这个数组索引大 1 的值;每当更改 length 属性,所有属性名是数组索引并且其值不小于新 length 的属性会被自动删除。Note.png 这个限制只应用于数组对象的自身属性,并且从原型中继承的 length 或数组索引不影响这个限制。

对一个对象 O,如果以下算法返回 true,那么就叫这个对象为 稀疏 的:

  1. len 为以 "length" 作为参数调用 O 的 [[Get]] 内部方法的结果。
  2. 对每个范围在 0i < ToUint32(len) 的整数 i
    1. elem 为以 ToString(i) 作为参数调用 O[[GetOwnProperty]] 内部方法的结果。
    2. 如果 elemundefined,返回 true
  3. 返回 false


作为函数调用 Array 构造器

当将 Array 作为函数来调用,而不是作为构造器,它会创建并初始化一个新数组对象。所以函数调用 Array(…) 与用相同参数的 new Array(…) 表达式创建的对象相同。


Array ( [ item1 [ , item2 [ , … ] ] ] )

当调用 Array 函数,采用如下步骤:

  1. 创建并返回一个新函数对象,它仿佛是用相同参数给标准内置构造器 Array 用一个 new 表达式创建的 (15.4.2)。


Array 构造器

Array 作为 new 表达式的一部分被调用时,它是一个构造器:它初始化新创建的对象。


new Array ( [ item0 [ , item1 [ , … ] ] ] )

当且仅当以无参数或至少两个参数调用 Array 构造器时,适用这里的描述。

新构造对象的 [[Prototype]] 内部属性要设定为原始的数组原型对象,他是 Array.prototype(15.4.3.1) 的初始值。

新构造对象的 [[Class]] 内部属性要设定为 "Array"

新构造对象的 [[Extensible]] 内部属性要设定为 true

新构造对象的 length 属性要设定为参数的个数。

新构造对象的 0 属性要设定为 item0(如果提供了);新构造对象的 1 属性要设定为 item1(如果提供了);更多的参数可应用普遍规律,新构造对象的 k 属性要设定为第 k 个参数,这里的 k 是从 0 开始的。所有这些属性都有特性 { [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true }。


new Array (len)

新构造对象的 [[Prototype]] 内部属性要设定为原始的数组原型对象,他是 Array.prototype(15.4.3.1) 的初始值。新构造对象的 [[Class]] 内部属性要设定为 "Array"。新构造对象的 [[Extensible]] 内部属性要设定为 true

如果参数 len 是个Number值 并且 ToUint32(len) 等于 len,则新构造对象的 length 属性要设定为 ToUint32(len)。如果参数 len 是个数字值并且 ToUint32(len) 不等于 len,则抛出一个 RangeError 异常。V8.png

如果参数 len 不是Number值,则新构造对象的 length 属性要设定为 0,并且新构造对象的 0 属性要设定为 len,设定它的特性为 { [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true }。


Array 构造器的属性

Array 构造器的 [[Prototype]] 内部属性值是函数原型对象 (15.3.4)。

Array 构造器除了有一些内部属性和 length 属性(其值是 1)之外,还有如下属性:


Array.prototype

Array.prototype 的初始值是数组原型对象 (15.4.4)。

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

Array.isArray ( arg )


isArray 函数需要一个参数 arg,如果参数是个对象并且 [[Class]] 内部属性是 "Array",返回布尔值 true;否则它返回 false。采用如下步骤:

  1. 如果 Type(arg) 不是 Object,返回 false
  2. 如果 arg 的 [[Class]] 内部属性值是 "Array",则返回 true
  3. 返回 false

数组原型对象的属性


数组原型对象的 [[Prototype]] 内部属性值是标准内置 Object 原型对象 (15.2.4)。

数组原型对象自身是个数组;它的 [[Class]]"Array",它拥有一个 length 属性(初始值是 +0)和 15.4.5.1 描述的特殊的 [[DefineOwnProperty]] 内部方法。

在以下的对数组原型对象的属性函数的描述中,短语“this 对象”指的是调用这个函数时的 this 值对象。允许 this[[Class]] 内部属性值不是 "Array" 的对象。

注: 数组原型对象自身没有 valueOf 属性;但它从标准内置 Object 原型对象继承 valueOf 属性。


Array.prototype.constructor

Array.prototype.constructor 的初始值是标准内置 Array 构造器。


Array.prototype.toString ( )

当调用 toString 方法,采用如下步骤:V8.png

  1. array 为用 this 值调用 ToObject 的结果。
  2. func 为以 "join" 作为参数调用 array[[Get]] 内部方法的结果。
  3. 如果 IsCallable(func) 是 false,则令 func 为标准内置方法 Object.prototype.toString (15.2.4.2)。V8.png
  4. 提供 array 作为 this 值并以空参数列表调用 func[[Call]] 内部方法,返回结果。
注: toString 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 toString 函数是依赖于实现的。


Array.prototype.toLocaleString ( )

先用数组元素的 toLocaleString 方法,将他们转换成字符串。然后将这些字符串串联,用一个分隔符分割,这里的分隔符字符串是与特定语言环境相关,由实现定义的方式得到的。调用这个函数的结果除了与特定语言环境关联之外,与 toString 的结果类似。

结果是按照一下方式计算的:V8.png

  1. array 为以 this 值作为参数调用 ToObject 的结果。
  2. arrayLen 为以 "length" 作为参数调用 array[[Get]] 内部方法的结果。
  3. lenToUint32(arrayLen)。
  4. separator 为宿主环境的当前语言环境对应的列表分隔符字符串(这是实现定义的方式得到的)。Note.png
  5. 如果 len 是零,返回空字符串。
  6. firstElement 为以 "0" 作为参数调用 array[[Get]] 内部方法的结果。
  7. 如果 firstElementundefinednull,则
    1. R 为空字符串。V8.png
  8. 否则
    1. elementObjToObject(firstElement).
    2. func 为以 "toLocaleString" 作为参数调用 elementObj[[Get]] 内部方法的结果。
    3. 如果 IsCallable(func) 是 false,抛出一个 TypeError 异常。
    4. R 为提供 elementObj 作为 this 值并以空参数列表调用 func[[Call]] 内部方法的结果。
  9. k1
  10. 只要 k < len 就重复
    1. S 为串联 Rseparator 产生的字符串。
    2. nextElement 为以 ToString(k) 作为参数调用 array[[Get]] 内部方法的结果。
    3. 如果 nextElementundefinednull,则
      1. R 为空字符串。
    4. 否则
      1. elementObjToObject(nextElement).
      2. func 为以 "toLocaleString" 作为参数调用 elementObj[[Get]] 内部方法的结果。
      3. 如果 IsCallable(func) 是 false,抛出一个 TypeError 异常。
      4. R 为提供 elementObj 作为 this 值并以空参数列表调用 func[[Call]] 内部方法的结果。
    5. R 为串联 SR 产生的字符串。
    6. k 递增 1
  11. 返回 R
注:此函数的第一个参数可能会在本标准的未来版本中用到;建议实现不要以任何其他用途使用这个参数位置。
注:toLocaleString 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 toLocaleString 函数是依赖于实现的。

Array.prototype.concat ( [ item1 [ , item2 [ , … ] ] ] )

当以零个或更多个参数 item1item2,等,调用 concat 方法时,会返回一个数组。 返回的数组包含 调用对象的数组元素Note.png 和随后顺序每个参数的数组元素Note.png

采用如下步骤:V8.png V8.png

  1. O 为以 this 值作为参数调用 ToObject 的结果。V8.png
  2. A 为仿佛是用表达式 new Array() 创建的新数组,这里的 Array 是标准内置构造器名。
  3. n0
  4. items 为一个内部列表,他的第一个元素是 O,之后的元素是调用时传给这个函数的各参数(以从左到右的顺序)。
  5. 只要 items 不是空就重复
    1. 删除 items 的第一个元素,并令 E 为这个元素值。V8.png
    2. 如果 E[[Class]] 内部属性是 "Array",则
      1. k0
      2. len 为以 "length" 为参数调用 E[[Get]] 内部方法的结果。
      3. 只要 k < len 就重复
        1. PToString(k).
        2. exists 为以 P 作为参数调用 E[[HasProperty]] 内部方法的结果。
        3. 如果 existstrue,则
          1. subElement 为以 P 作为参数调用 E[[Get]] 内部方法的结果。
          2. ToString(n)、属性描述符 { [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true } 和 false 作为参数调用 A[[DefineOwnProperty]] 内部方法。
        4. n 递增 1
        5. k 递增 1
    3. 否则,E 不是数组
      1. ToString(n)、属性描述符 { [[Value]]: E, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: false } 和 false 作为参数调用 A[[DefineOwnProperty]] 内部方法。
      2. n 递增 1
  6. 返回 A

concat 方法的 length 属性是 1

注:concat 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 concat 函数是依赖于实现的。


Array.prototype.join (separator)

数组元素先被转换为字符串,再将这些字符串用 separator 分割连接在一起。如果没提供分隔符,将一个逗号用作分隔符。

join 方法需要一个参数 separator,执行以下步骤 :V8.png

  1. O 为以 this 值作为参数调用 ToObject 的结果。
  2. lenVal 为以 "length" 作为参数调用 O[[Get]] 内部方法的结果。
  3. lenToUint32(lenVal)。V8.png
  4. 如果 separatorundefined,令 separator 为单字符字符串 ","V8.png
  5. sepToString(separator)。
  6. 如果 len 是零,返回空字符串。V8.png
  7. element0 为以 "0" 作为参数调用 O[[Get]] 内部方法的结果。
  8. 如果 element0undefinednull, 令 R 为空字符串;否则,令 RToString(element0)。
  9. k1.
  10. 只要 k < len 就重复
    1. S 为串联 Rsep 产生的字符串值。 V8.png
    2. element 为以 ToString(k) 作为参数调用 O[[Get]] 内部方法的结果。
    3. 如果 elementundefinednull,令 next 为空字符串;否则,令 nextToString(element)。
    4. R 为串联 Snext 产生的字符串值。
    5. k 递增 1
  11. 返回 R

join 方法的 length 属性是 1

注: join 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 join 函数是依赖于实现的。


Array.prototype.pop ( )

删除并返回数组的最后一个元素。

  1. O 为以 this 值作为参数调用 ToObject 的结果V8.png
  2. lenVal 为以 "length" 作为参数调用 O[[Get]] 内部方法的结果。
  3. lenToUint32(lenVal)。
  4. 如果 len 是零
    1. "length"0trueV8.pngMoz.png 作为参数调用 O[[Put]] 内部方法。Note.png
    2. 返回 undefinedV8.png
  5. 否则,len > 0
    1. indxToString(len - 1)。
    2. element 为以 indx 作为参数调用 O[[Get]] 内部方法的结果。
    3. indxtrue 作为参数调用 O[[Delete]] 内部方法。V8.png
    4. "length"indxtrue 作为参数调用 O[[Put]] 内部方法Bug.png
    5. 返回 element
注: pop 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 pop 函数是依赖于实现的。


Array.prototype.push ( [ item1 [ , item2 [ , … ] ] ] )

将参数以他们出现的顺序追加到数组末尾。数组的新 length 属性值会作为调用的结果返回。

当以零或更多个参数 item1item2,等,调用 push 方法,采用以下步骤:V8.png

  1. O 为以 this 值作为参数调用 ToString 的结果。
  2. lenVal 为以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  3. nToUint32(lenVal)。
  4. items 为一个内部列表,它的元素是调用这个函数时传入的参数(从左到右的顺序)。
  5. 只要 items 不是空就重复
    1. 删除 items 的第一个元素,并令 E 为这个元素的值。
    2. ToString(n)、Etrue 作为参数调用 O[[Put]] 内部方法。V8.png
    3. n 递增 1
  6. "length"ntrue 作为参数调用 O[[Put]] 内部方法。
  7. 返回 nV8.png

push 方法的 length 属性是 1

注: push 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 push 函数是依赖于实现的。


Array.prototype.reverse ( )

重新排列数组元素,以翻转它们的顺序。对象会被当做调用的结果返回。V8.png

  1. O 为以 this 值作为参数调用 ToObject 的结果。
  2. lenVal 为以 "length" 作为参数调用 O[[Get]] 内部方法的结果。
  3. lenToUint32(lenVal)。V8.png
  4. middlefloor(len / 2)。
  5. lower0
  6. 只要 lowermiddle 就重复
    1. upperlen - lower - 1
    2. upperPToString(upper)。
    3. lowerPToString(lower)。
    4. lowerValue 为以 lowerP 作为参数调用 O[[Get]] 内部方法的结果。
    5. upperValue 为以 upperP 作为参数调用 O[[Get]] 内部方法的结果。
    6. lowerExists 为以 lowerP 作为参数调用 O[[HasProperty]] 内部方法的结果。
    7. upperExists 为以 upperP 作为参数调用 O[[HasProperty]] 内部方法的结果。
    8. 如果 lowerExiststrue 并且 upperExiststrue,则
      1. lowerPupperValuetrue 作为参数调用 O[[Put]] 内部方法。
      2. upperPlowerValuetrue 作为参数调用 O[[Put]] 内部方法。
    9. 否则如果 lowerExistsfalse 并且 upperExiststrue,则
      1. lowerPupperValuetrue 作为参数调用 O[[Put]] 内部方法。
      2. upperPtrue 作为参数调用 O[[Delete]] 内部方法。V8.png
    10. 否则如果 lowerExiststrue 并且 upperExistsfalse,则
      1. lowerPtrue 作为参数调用 O[[Delete]] 内部方法。 V8.png
      2. upperPlowerValuetrue 作为参数调用 O[[Put]] 内部方法。
    11. 否则,lowerExistsupperExists 都是 false
      1. 不需要做任何事情。
    12. lower 递增 1
  7. 返回 O
注: reverse 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 reverse 函数是依赖于实现的。


Array.prototype.shift ( )

删除并返回数组的第一个元素。V8.png V8.png

  1. O 为以 this 值作为参数调用 ToObject 的结果。
  2. lenVal 为以 "length" 作为参数调用 O[[Get]] 内部方法的结果。
  3. lenToUint32(lenVal)。
  4. 如果 len 是零 , 则
    1. "length"0true 作为参数调用 O[[Put]] 内部方法。
    2. 返回 undefinedV8.png
  5. first 为以 "0" 作为参数调用 O[[Get]] 内部方法的结果。
  6. k1
  7. 只要 k < len 就重复
    1. fromToString(k)。
    2. toToString(k - 1)。
    3. fromPresent 为以 from 作为参数调用 O[[HasProperty]] 内部方法的结果。
    4. 如果 fromPresenttrue, 则
      1. fromVal 为以 from 作为参数调用 O[[Get]] 内部方法的结果。
      2. tofromValtrue 作为参数调用 O[[Put]] 内部方法。
    5. 否则,fromPresentfalse
      1. toture 作为参数调用 O[[Delete]] 内部方法。
    6. k 递增 1
  8. ToString(len - 1) 和 true 作为参数调用 O[[Delete]] 内部方法。
  9. "length"、(len - 1) 和 true 作为参数调用 O[[Put]] 内部方法。V8.png
  10. 返回 first
注: shift 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 shift 函数是依赖于实现的。


Array.prototype.slice (start, end)

slice 方法需要 startend 两个参数,返回一个数组,这个数组包含从下标为 start 的元素到下标为 end(不含 end)的元素(或如果 endundefined 就到数组末尾)。如果 start 为负,它会被当做是 length + start,这里的 length 是数组长度。如果 end 为负,它会被当做是 length + end,这里的 length 是数组长度。采用如下步骤:V8.png

  1. O 为以 this 值作为参数调用 ToObject 的结果。
  2. A 为仿佛用表达式 new Array() 创建的新数组,这里的 Array 是标准内置构造器名。
  3. lenVal 为以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  4. lenToUint32(lenVal)。
  5. relativeStartToInteger(start)。
  6. 如果 relativeStart 为负,令 kmax((len + relativeStart), 0);否则令 kmin(relativeStart, len)。
  7. 如果 endundefined,令 relativeEndlen;否则令 relativeEndToInteger(end)。
  8. 如果 relativeEnd 为负,令 finalmax((len + relativeEnd), 0);否则令 finalmin(relativeEnd, len)。
  9. n0
  10. 只要 k < final 就重复
    1. PkToString(k)。
    2. kPresentPk 作为参数调用 O[[HasProperty]] 内部方法的结果。
    3. 如果 kPresenttrue, 则
      1. kValue 为以 Pk 作为参数调用 O[[Get]] 内部方法的结果。
      2. ToString(n)、属性描述符 {[[Value]]: kValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 作为参数调用 A[[DefineOwnProperty]] 内部方法。
    4. k 递增 1
    5. n 递增 1
  11. 返回 A

slice 方法的 length 属性是 2

注: slice 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 slice 函数是依赖于实现的。


Array.prototype.sort (comparefn)

this 数组的元素排序。排序不一定是稳定的(相等的元素们不一定按照他们原来的顺序排列)。如果 comparefn 不是 undefined,它就必须是个函数,这个函数接受两个参数 xy,如果 x < y 返回一个负值,如果 x = y 返回零,如果 x > y 返回一个正值。Question.png

obj 为以 this 值作为参数调用 ToObject 的结果。

"length" 作为参数调用 obj[[Get]] 内部方法,将结果作为参数调用 Uint32Question.png,令 len 为返回的结果。V8.png

如果 comparefn 不是 undefined 并且不是对 this 数组的元素保持一致的比较函数(见下面),那么这种情况下 sort 的行为是由实现来定义的。

protoobj[[Prototype]] 内部属性。如果 proto 不是 null 并且存在一个整数 j 满足下面列出的全部条件,那么这种情况下 sort 的行为是实现定义的:

如果 obj 是稀疏的并且以下任何条件为真,那么这种情况下 sort 的行为也是实现定义的:

  • obj[[Extensible]] 内部属性是 false
  • 任何名为小于 len 的非负整数的数组索引属性中,有 [[Configurable]] 特性是 false 的数据属性。

任何名为小于 len 的非负整数的数组索引属性中,有访问器属性,或有 [[Writable]] 特性是 false 的数据属性,那么这种情况下 sort 的行为也是实现定义的。

否则,采用如下步骤。Note.png

  1. 根据实现定义的排序算法,通过调用若干次 obj[[Get]][[Put]][[Delete]] 内部方法和 SortCompare 的有机组合来完成排序。这里对每个 [[Get]][[Put]][[Delete]] 调用的第一个参数是小于 len 的非负整数,SortCompare 调用的参数是前面调用 [[Get]] 内部方法的结果。调用 [[Put]][[Delete]] 内部方法时,throw 参数是 true。如果 obj 不是稀疏的,则必须不调用 [[Delete]]
  2. 返回 obj

返回的对象必须拥有下面两个性质。Note.png

  • 必须有这样的数学排列 π,它是由比 len 小的非负整数组成,对于每个比 len 小的非负整数 j,如果属性 old[j] 存在 , 则 new[π(j)] 有与 old[j] 相同的值,如果属性 old[j] 不存在,则 new[π(j)] 也不存在。
  • 对于都比 len 小的所有非负整数 jk,如果 SortCompare(j, k) < 0, 则 π(j) < π(k).

这里的符号 old[j] 用来指:假定在执行这个函数之前以 j 作为参数调用 obj[[Get]] 内部方法的结果,符号 new[j] 用来指:假定在执行这个函数后以 j 作为参数调用 obj[[Get]] 内部方法的结果。

如果对于集合 S 里的任何值 abc(可以是相同值),都满足以下所有条件,那么函数 comparefn 是在集合 S 上保持一致的比较函数(以下,符号 a <CF b 表示 comparefn(a, b) < 0;符号 a =CF b 表示 comparefn(a, b) = 0不论正负); 符号 a >CF b 表示 comparefn(a, b) > 0):

  • 当用指定值 ab 作为两个参数调用 comparefn(a, b),总是返回相同值 v。此外 Type(v) 是 Number, 并且 v 不是 NaN。注意,这意味着对于给定的 aba <CF ba =CF ba >CF b 中正好有一个为真。
  • 调用 comparefn(a, b) 不改变 this 对象。
  • a =CF a(自反性)
  • 如果 a =CF b, 则 b =CF a(对称性)
  • 如果 a =CF b 并且 b =CF c,则 a =CF c=CF 传递)
  • 如果 a <CF b 并且 b <CF c, 则 a <CF c<CF 传递)
  • 如果 a >CF b 并且 b >CF c,则 a >CF c>CF 传递)
注: 这些条件是确保 comparefn 划分集合 S 为等价类并且是完全排序等价类的充分必要条件。

当用两个参数 jk 调用抽象操作 SortCompare,采用如下步骤:Question.png

  1. jStringToString(j)。
  2. kStringToString(k)。
  3. hasj 为 以 jString 作为参数调用 obj[[HasProperty]] 内部方法的结果。
  4. hask 为 以 kString 作为参数调用 obj[[HasProperty]] 内部方法的结果。
  5. 如果 hasjhask 都是 false,则返回 +0
  6. 如果 hasjfalse,则返回 1
  7. 如果 haskfalse,则返回 -1
  8. x 为 以 jString 作为参数调用 obj[[Get]] 内部方法的结果。
  9. y 为 以 kString 作为参数调用 obj[[Get]] 内部方法的结果。
  10. 如果 xy 都是 undefined,返回 +0
  11. 如果 xundefined,返回 1
  12. 如果 yundefined,返回 −1
  13. 如果 参数 comparefn 不是 undefined, 则
    1. 如果 IsCallable(comparefn) 是 false,抛出一个 TypeError 异常。
    2. 传入 undefined 作为 this 值,以 xy 作为参数调用 comparefn[[Call]] 内部方法,返回结果。
  14. xStringToString(x)。
  15. yStringToString(y)。
  16. 如果 xString < yString,返回 −1
  17. 如果 xString > yString,返回 1
  18. 返回 +0
注: 因为不存在的属性值总是比 undefined 属性值大,并且 undefined 属性值总是比任何其他值大,所以 undefined 属性值总是排在结果的末尾,后面跟着不存在的属性值。
注: sort 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 sort 函数是依赖于实现的。


Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , … ] ] ] )

当以两个或更多参数 startdeleteCount 和(可选的)item1item2, 等,调用 splice 方法,从数组索引 start 开始的 deleteCount 个数组元素会被替换为参数 item1item2, 等。返回一个包含参数元素(如果有)的数组。采用以下步骤:V8.png

  1. O 为 以 this 值作为参数调用 ToObject 的结果。
  2. A 为 仿佛用表达式 new Array() 创建的新数组,这里的 Array 是标准内置构造器名。
  3. lenVal 为 以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  4. lenToUint32(lenVal)。
  5. relativeStartToInteger(start)。
  6. 如果 relativeStart 为负,令 actualStartmax((len + relativeStart),0); 否则令 actualStartmin(relativeStart, len)。
  7. actualDeleteCountmin(max(ToInteger(deleteCount),0),len - actualStart)。
  8. k0
  9. 只要 k < actualDeleteCount 就重复 Note.png
    1. fromToString(actualStart + k)。
    2. fromPresent 为 以 from 作为参数调用 O[[HasProperty]] 内部方法的结果。
    3. 如果 fromPresenttrue,则
      1. fromValue 为 以 from 作为参数调用 O[[Get]] 内部方法的结果。
      2. ToString(k), 属性描述符 {[[Value]]: fromValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作为参数调用 A[[DefineOwnProperty]] 内部方法。
    4. k 递增 1.
  10. items 为一个内部列表,它的元素是实际参数列表中 item1 开始的参数(从左到右的顺序)。如果没传入这些项目,则列表是空的。
  11. itemCountitems 的元素个数。
  12. 如果 itemCount < actualDeleteCount,则 Note.png
    1. kactualStart
    2. 只要 k < (len - actualDeleteCount) 就重复
      1. fromToString(k + actualDeleteCount)。
      2. toToString(k + itemCount)。
      3. fromPresent 为 以 from 作为参数调用 O[[HasProperty]] 内部方法的结果。
      4. 如果 fromPresenttrue,则
        1. fromValue 为 以 from 作为参数调用 O[[Get]] 内部方法的结果。
        2. tofromValuetrue 作为参数调用 O[[Put]] 内部方法。
      5. 否则,fromPresentfalse
        1. totrue 作为参数调用 O[[Delete]] 内部方法。
      6. k 递增 1
    3. klen
    4. 只要 k > (len - actualDeleteCount + itemCount) 就重复
      1. ToString(k - 1) 和 true 作为参数调用 O[[Delete]] 内部方法。
      2. k 递减 1.
  13. 否则如果 itemCount > actualDeleteCount,则 Note.png
    1. k 为 (len - actualDeleteCount)。
    2. 只要 k > actualStart 就重复
      1. fromToString(k + actualDeleteCount - 1)。
      2. toToString(k + itemCount - 1)
      3. fromPresent 为 以 from 作为参数调用 O[[HasProperty]] 内部方法的结果。
      4. 如果 fromPresenttrue, 则
        1. fromValue 为 以 from 作为参数调用 O[[Get]] 内部方法的结果。
        2. tofromValuetrue 作为参数调用 O[[Put]] 内部方法。
      5. 否则,fromPresentfalse
        1. totrue 作为参数调用 O[[Delete]] 内部方法。
      6. k 递减 1
  14. kactualStart
  15. 只要 items 不是空 就重复 Note.png
    1. 删除 items 的第一个元素,并令 E 为这个元素值。
    2. ToString(k)、Etrue 作为参数调用 O[[Put]] 内部方法。
    3. k 递增 1
  16. "length"、(len - actualDeleteCount + itemCount) 和 true 作为参数调用 O[[Put]] 内部方法。
  17. 返回 A

splice 方法的 length 属性是 2

注: splice 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 splice 函数是依赖于实现的。


Array.prototype.unshift ( [ item1 [ , item2 [ , … ] ] ] )

将参数们插入到数组的开始位置,它们在数组中的顺序与它们出现在参数列表中的顺序相同。

当以零或更多个参数 item1item2,等,调用 unshift 方法,采用如下步骤:V8.png

  1. O 为 以 this 值作为参数调用 ToObject 的结果。
  2. lenVal 为 以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  3. lenToUint32(lenVal)。
  4. argCount 为 实际参数的个数。
  5. klen
  6. 只要 k > 0,就重复 Note.png
    1. fromToString(k - 1)。
    2. toToString(k + argCount - 1)。
    3. fromPresent 为 以 from 作为参数调用 O[[HasProperty]] 内部方法的结果。
    4. 如果 fromPresenttrue,则
      1. fromValue 为 以 from 作为参数调用 O[[Get]] 内部方法的结果。
      2. tofromValuetrue 作为参数调用 O[[Put]] 内部方法。
    5. 否则,fromPresentfalse
      1. totrue 作为参数调用 O[[Delete]] 内部方法。
    6. k 递减 1
  7. j0
  8. items 为一个内部列表,它的元素是调用这个函数时传入的实际参数(从左到右的顺序)。
  9. 只要 items 不是空,就重复 Note.png
    1. 删除 items 的第一个元素,并令 E 为这个元素值 .
    2. ToString(j)、Etrue 作为参数调用 O[[Put]] 内部方法。
    3. j 递增 1
  10. "length"len + argCounttrue 作为参数调用 O[[Put]] 内部方法。
  11. 返回 len + argCount

unshift 方法的 length 属性是 1

注: unshift 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 unshift 函数是依赖于实现的。


Array.prototype.indexOf ( searchElement [ , fromIndex ] )

indexOf 按照索引的升序比较 searchElement 和数组里的元素们,它使用内部的严格相等比较算法(11.9.6),如果找到一个或更多这样的位置,返回这些位置中第一个索引;否则返回 -1V8.png

可选的第二个参数 fromIndex 默认是 0(即搜索整个数组)。如果它大于或等于数组长度,返回 -1,即不会搜索数组。如果它是负的,就把它当作从数组末尾到计算后的 fromIndex 的偏移量。如果计算后的索引小于 0,就搜索整个数组。 Note.png

当用一个或两个参数调用 indexOf 方法,采用以下步骤:

  1. O 为 以 this 值作为参数调用 ToObject 的结果。
  2. lenValue 为 以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  3. lenToUint32(lenValue)。
  4. 如果 len0,返回 -1
  5. 如果 传入了参数 fromIndex,则令 nToInteger(fromIndex);否则令 n0
  6. 如果 nlen,返回 -1
  7. 如果 n0,则
    1. kn
  8. 否则,n < 0
    1. klen - abs(n)。 Question.png
    2. 如果 k 小于 0,则令 k0
  9. 只要 k < len,就重复
    1. kPresent 为 以 ToString(k) 为参数调用 O[[HasProperty]] 内部方法的结果。
    2. 如果 kPresenttrue,则
      1. elementK 为 以 ToString(k) 为参数调用 O[[Get]] 内部方法的结果。
      2. same 为 对 searchElementelementK 执行严格相等比较算法的结果。
      3. 如果 sametrue,返回 k
    3. k 递增 1
  10. 返回 -1

indexOf 方法的 length 属性是 1

注: indexOf 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 indexOf 函数是依赖于实现的。


Array.prototype.lastIndexOf ( searchElement [ , fromIndex ] )

lastIndexOf 按照索引的降序比较 searchElement 和数组里的元素们,它使用内部的严格相等比较算法 (11.9.6),如果找到一个或更多这样的位置,返回这些位置中最后一个索引;否则返回 -1V8.png

可选的第二个参数 fromIndex 默认是数组的长度减一(即搜索整个数组)。如果它大于或等于数组长度,将会搜索整个数组。如果它是负的,就把它当作从数组末尾到计算后的 fromIndex 的偏移量。如果计算后的索引小于 0,返回 -1Note.png

当用一个或两个参数调用 lastIndexOf 方法,采用如下步骤 :

  1. O 为 以 this 值作为参数调用 ToObject 的结果。
  2. lenValue 为 以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  3. lenToUint32(lenValue)。
  4. 如果 len0,返回 -1
  5. 如果 传入了参数 fromIndex,则令 nToInteger(fromIndex); 否则令 nlen
  6. 如果 n0,则令 kmin(n, len - 1)。
  7. 否则,n < 0
    1. klen - abs(n)。Question.png
  8. 只要 k0 就重复
    1. kPresent 为 以 ToString(k) 作为参数调用 O[[HasProperty]] 内部方法的结果。
    2. 如果 kPresenttrue,则
      1. elementK 为 以 ToString(k) 作为参数调用 O[[Get]] 内部方法的结果。
      2. same 为 对 searchElementelementK 执行严格相等比较算法的结果。
      3. 如果 sametrue,返回 k
    3. k 递减 1
  9. 返回 -1

lastIndexOf 方法的 length 属性是 1

注: lastIndexOf 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 lastIndexOf 函数是依赖于实现的。


Array.prototype.every ( callbackfn [ , thisArg ] )

callbackfn 应该是个函数,它接受三个参数并返回一个可转换为布尔值 truefalse 的值。every 按照索引的升序,对数组里存在的每个元素调用一次 callbackfn,直到他找到一个使 callbackfn 返回 false 的元素。如果找到这样的元素,every 马上返回 false,否则如果对所有元素 callbackfn 都返回 trueevery 将返回 truecallbackfn 只被数组里实际存在的元素调用;它不会被缺少的元素调用。

如果提供了一个 thisArg 参数,它会被当作 this 值传给每个 callbackfn 调用。如果没提供它,用 undefined 替代。

调用 callbackfn 时将传入三个参数:元素的值,元素的索引,和遍历的对象。

every 的调用不直接更改对象,但是对 callbackfn 的调用可能更改对象。

every 处理的元素范围是在首次调用 callbackfn 之前设定的。在 every 调用开始后追加到数组里的元素们不会被 callbackfn 访问。如果更改以存在数组元素,every 访问这些元素时的值会传给 callbackfn;在 every 调用开始后删除的和之前被访问过的元素们是不访问的。every 的行为就像数学量词“所有(for all)”。特别的,对一个空数组,它返回 true

当以一个或两个参数调用 every 方法,采用以下步骤:V8.png

  1. O 为 以 this 值作为参数调用 ToObject 的结果。
  2. lenValue 为 以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  3. lenToUint32(lenValue)。
  4. 如果 IsCallable(callbackfn) 是 false,抛出一个 TypeError 异常。
  5. 如果提供了 thisArg,令 TthisArg;否则令 Tundefined
  6. k0
  7. 只要 k < len,就重复
    1. PkToString(k)。
    2. kPresent 为 以 Pk 作为参数调用 O[[HasProperty]] 内部方法的结果。
    3. 如果 kPresenttrue,则
      1. kValue 为 以 Pk 作为参数调用 O[[Get]] 内部方法的结果 .
      2. testResult 为 以 T 作为 this 值以包含 kValuekO 的参数列表调用 callbackfn[[Call]] 内部方法的结果。
      3. 如果 ToBoolean(testResult) 是 false,返回 false
    4. k 递增 1
  8. 返回 true

every 方法的 length 属性是 1

注: every 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 every 函数是依赖于实现的。


Array.prototype.some ( callbackfn [ , thisArg ] )

callbackfn 应该是个函数,它接受三个参数并返回一个可转换为布尔值 truefalse 的值。some 按照索引的升序,对数组里存在的每个元素调用一次 callbackfn,直到他找到一个使 callbackfn 返回 true 的元素。如果找到这样的元素,some 马上返回 true,否则,some 返回 falsecallbackfn 只被实际存在的数组元素调用;它不会被缺少的数组元素调用。

如果提供了一个 thisArg 参数,它会被当作 this 值传给每个 callbackfn 调用。如果没提供它,用 undefined 替代。

调用 callbackfn 时将传入三个参数:元素的值,元素的索引,和遍历的对象。

some 的调用不直接更改对象,但是对 callbackfn 的调用可能更改对象。

some 处理的元素范围是在首次调用 callbackfn 之前设定的。在 some 调用开始后追加到数组里的元素们不会被 callbackfn 访问。如果更改以存在数组元素,some 访问这些元素时的值会传给 callbackfn;在 some 调用开始后删除的和之前被访问过的元素们是不访问的。some 的行为就像数学量词“存在(exists)”。特别的,对一个空数组,它返回 false

当以一个或两个参数调用 some 方法,采用以下步骤:V8.png

  1. O 为 以 this 值作为参数调用 ToObject 的结果。
  2. lenValue 为 以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  3. lenToUint32(lenValue)。
  4. 如果 IsCallable(callbackfn) 是 false, 抛出一个 TypeError 异常。V8.png
  5. 如果提供了 thisArg,令 TthisArg;否则令 Tundefined
  6. k0
  7. 只要 k < len,就重复
    1. PkToString(k)。
    2. kPresent 为 以 Pk 作为参数调用 O[[HasProperty]] 内部方法的结果。
    3. 如果 kPresenttrue,则
      1. kValue 为 以 Pk 作为参数调用 O[[Get]] 内部方法的结果。
      2. testResult 为 以 T 作为 this 值以包含 kValuekO 的参数列表调用 callbackfn[[Call]] 内部方法的结果。
      3. 如果 ToBoolean(testResult) 是 true,返回 true
    4. k 递增 1
  8. 返回 false

some 方法的 length 属性是 1

注: some 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 some 函数是依赖于实现的。


Array.prototype.forEach ( callbackfn [ , thisArg ] )


callbackfn 应该是个函数,它接受三个参数。forEach 按照索引的升序,对数组里存在的每个元素调用一次 callbackfncallbackfn 只被实际存在的数组元素调用;它不会被缺少的数组元素调用。

如果提供了一个 thisArg 参数,它会被当作 this 值传给每个 callbackfn 调用。如果没提供它,用 undefined 替代。

调用 callbackfn 时将传入三个参数:元素的值,元素的索引,和遍历的对象。

forEach 的调用不直接更改对象,但是对 callbackfn 的调用可能更改对象。

forEach 处理的元素范围是在首次调用 callbackfn 之前设定的。在 forEach 调用开始后追加到数组里的元素们不会被 callbackfn 访问。如果更改以存在数组元素,forEach 访问这些元素时的值会传给 callbackfn;在 forEach 调用开始后删除的和之前被访问过的元素们是不访问的。

当以一个或两个参数调用 forEach 方法,采用以下步骤:V8.png


  1. O 为 以 this 值作为参数调用 ToObject 的结果。
  2. lenValue 为 以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  3. lenToUint32(lenValue)。
  4. 如果 IsCallable(callbackfn) 是 false,抛出一个 TypeError 异常。V8.png
  5. 如果提供了 thisArg,令 TthisArg;否则令 Tundefined
  6. k0
  7. 只要 k < len,就重复
    1. PkToString(k)。
    2. kPresent 为 以 Pk 作为参数调用 O[[HasProperty]] 内部方法的结果。
    3. 如果 kPresenttrue,则
      1. kValue 为 以 Pk 作为参数调用 O[[Get]] 内部方法的结果。
      2. T 作为 this 值以包含 kValuekO 的参数列表调用 callbackfn 的 [[Call]] 内部方法。
    4. k 递增 1
  8. 返回 undefined

forEach 方法的 length 属性是 1

注:forEach 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 forEach 函数是依赖于实现的。


Array.prototype.map ( callbackfn [ , thisArg ] )

callbackfn 应该是个函数,它接受三个参数。map 按照索引的升序,对数组里存在的每个元素调用一次 callbackfn,并用结果构造一个新数组。callbackfn 只被实际存在的数组元素调用;它不会被缺少的数组元素调用。 V8.png

如果提供了一个 thisArg 参数,它会被当作 this 值传给每个 callbackfn 调用。如果没提供它,用 undefined 替代。

调用 callbackfn 时将传入三个参数:元素的值,元素的索引,和遍历的对象。

map 的调用不直接更改对象,但是对 callbackfn 的调用可能更改对象。

map 处理的元素范围是在首次调用 callbackfn 之前设定的。在 map 调用开始后追加到数组里的元素们不会被 callbackfn 访问。如果更改以存在数组元素,map 访问这些元素时的值会传给 callbackfn;在 map 调用开始后删除的和之前被访问过的元素们是不访问的。

当以一个或两个参数调用 map 方法,采用以下步骤:

  1. O 为 以 this 值作为参数调用 ToObject 的结果。
  2. lenValue 为 以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  3. lenToUint32(lenValue)。
  4. 如果 IsCallable(callbackfn) 是 false,抛出一个 TypeError 异常。V8.png
  5. 如果提供了 thisArg,令 TthisArg;否则令 Tundefined
  6. A 为 仿佛用 new Array(len) Note.png 创建的新数组,这里的 Array 是标准内置构造器名,lenlen 的值。
  7. k0
  8. 只要 k < len,就重复
    1. PkToString(k)。
    2. kPresent 为 以 Pk 作为参数调用 O[[HasProperty]] 内部方法的结果。
    3. 如果 kPresenttrue,则
      1. kValue 为 以 Pk 作为参数调用 O[[Get]] 内部方法的结果。
      2. mappedValue 为 以 T 作为 this 值以包含 kValuekO 的参数列表调用 callbackfn[[Call]] 内部方法的结果。
      3. Pk,属性描述符 {[[Value]]: mappedValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 作为参数调用 A[[DefineOwnProperty]] 内部方法。
    4. k 递增 1
  9. 返回 A

map 方法的 length 属性是 1

注:map 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 map 函数是依赖于实现的。


Array.prototype.filter ( callbackfn [ , thisArg ] )


callbackfn 应该是个函数,它接受三个参数并返回一个可转换为布尔值 truefalse 的值。filter 按照索引的升序,对数组里存在的每个元素调用一次 callbackfn,并用使 callbackfn 返回 true 的所有值构造一个新数组。callbackfn 只被实际存在的数组元素调用;它不会被缺少的数组元素调用。

如果提供了一个 thisArg 参数,它会被当作 this 值传给每个 callbackfn 调用。如果没提供它,用 undefined 替代。

调用 callbackfn 时将传入三个参数:元素的值,元素的索引,和遍历的对象。

filter 的调用不直接更改对象,但是对 callbackfn 的调用可能更改对象。

filter 处理的元素范围是在首次调用 callbackfn 之前设定的。在 filter 调用开始后追加到数组里的元素们不会被 callbackfn 访问。如果更改以存在数组元素,filter 访问这些元素时的值会传给 callbackfn;在 filter 调用开始后删除的和之前被访问过的元素们是不访问的。

当以一个或两个参数调用 filter 方法,采用以下步骤:V8.png

  1. O 为 以 this 值作为参数调用 ToObject 的结果。
  2. lenValue 为 以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  3. lenToUint32(lenValue)。
  4. 如果 IsCallable(callbackfn) 是 false, 抛出一个 TypeError 异常。V8.png
  5. 如果提供了 thisArg,令 TthisArg;否则令 T 为 undefined
  6. A 为 仿佛用 new Array() 创建的新数组,这里的 Array 是标准内置构造器名。
  7. k0
  8. to0
  9. 只要 k < len,就重复
    1. PkToString(k)。
    2. kPresent 为 以 Pk 作为参数调用 O[[HasProperty]] 内部方法的结果。
    3. 如果 kPresenttrue,则
      1. kValue 为 以 Pk 作为参数调用 O[[Get]] 内部方法的结果。
      2. selected 为 以 T 作为 this 值以包含 kValuekO 的参数列表调用 callbackfn[[Call]] 内部方法的结果。
      3. 如果 ToBoolean(selected) 是 true,则
        1. ToString(to),属性描述符 {[[Value]]: kValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 作为参数调用 A[[DefineOwnProperty]] 内部方法。
        2. to 递增 1
    4. k 递增 1
  10. 返回 A

filter 方法的 length 属性是 1

注:filter 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 filter 函数是依赖于实现的。


Array.prototype.reduce ( callbackfn [ , initialValue ] )

callbackfn 应该是个函数,它需要四个参数。reduce 按照索引的升序,对数组里存在的每个元素,将 callbackfn 作为回调函数调用一次。

调用 callbackfn 时将传入四个参数:previousValueinitialValue 的值或上次调用 callbackfn 的返回值)、currentValue(当前元素值)、currentIndex遍历的对象。第一次调用回调函数时,previousValuecurrentValue 的取值可以是下面两种情况之一。如果为 reduce 调用提供了一个 initialValue,则 previousValue 将等于 initialValue 并且 currentValue 将等于数组的首个元素值。如果没提供 initialValue,则 previousValue 将等于数组的首个元素值并且 currentValue 将等于数组的第二个元素值。如果数组里没有元素并且没有提供 initialValue,则抛出一个 TypeError 异常。

reduce 的调用不直接更改对象,但是对 callbackfn 的调用可能更改对象。

reduce 处理的元素范围是在首次调用 callbackfn 之前设定的。在 reduce 调用开始后追加到数组里的元素们不会被 callbackfn 访问。如果更改以存在数组元素,reduce 访问这些元素时的值会传给 callbackfn;在 reduce 调用开始后删除的和之前被访问过的元素们是不访问的。

当以一个或两个参数调用 reduce 方法,采用以下步骤:V8.png

  1. O 为 以 this 值作为参数调用 ToObject 的结果。
  2. lenValue 为 以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  3. lenToUint32(lenValue)。
  4. 如果 IsCallable(callbackfn) 是 false,抛出一个 TypeError 异常。
  5. 如果 len0 并且 initialValue 不是 present,抛出一个 TypeError 异常。V8.png
  6. k0
  7. 如果 initialValue 参数有传入值,则
    1. 设定 accumulatorinitialValue
  8. 否则,initialValue 参数没有传入值 Note.png
    1. kPresentfalse
    2. 只要 kPresentfalse 并且 k < len,就重复
      1. PkToString(k)。
      2. kPresent 为 以 Pk 作为参数调用 O[[HasProperty]] 内部方法的结果。
      3. 如果 kPresenttrue,则
        1. accumulator 为 以 Pk 作为参数调用 O[[Get]] 内部方法的结果。
      4. k 递增 1.
    3. 如果 kPresentfalse,抛出一个 TypeError 异常。
  9. 只要 k < len,重复
    1. PkToString(k)。
    2. kPresent 为 以 Pk 作为参数调用 O[[HasProperty]] 内部方法的结果。
    3. 如果 kPresenttrue,则
      1. kValue 为 以 Pk 作为参数调用 O[[Get]] 内部方法的结果。
      2. accumulator 为 以 undefined 作为 this 值并以包含 accumulatorkValuekO 的参数列表调用 callbackfn[[Call]] 内部方法的结果。
    4. k 递增 1
  10. 返回 accumulator

reduce 方法的 length 属性是 1

注:reduce 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 reduce 函数是依赖于实现的。


Array.prototype.reduceRight ( callbackfn [ , initialValue ] )

callbackfn 应该是个函数,它需要四个参数。reduceRight 按照索引的升序,对数组里存在的每个元素 , 将 callbackfn 作为回调函数调用一次。

调用 callbackfn 时将传入四个参数:previousValueinitialValue 的值或上次调用 callbackfn 的返回值),currentValue(当前元素值),currentIndex遍历的对象。第一次调用回调函数时,previousValuecurrentValue 的取值可以是下面两种情况之一。如果为 reduceRight 调用提供了一个 initialValue,则 previousValue 将等于 initialValue 并且 currentValue 将等于数组的最后一个元素值。如果没提供 initialValue,则 previousValue 将等于数组的最后一个元素值并且 currentValue 将等于数组的倒数第二个元素值。如果数组里没有元素并且没有提供 initialValue,则抛出一个 TypeError 异常。

reduceRight 的调用不直接更改对象,但是对 callbackfn 的调用可能更改对象。

reduceRight 处理的元素范围是在首次调用 callbackfn 之前设定的。在 reduceRight 调用开始后追加到数组里的元素们不会被 callbackfn 访问。如果更改以存在数组元素,reduceRight 访问这些元素时的值会传给 callbackfn;在 reduceRight 调用开始后删除的和之前被访问过的元素们是不访问的。

当以一个或两个参数调用 reduceRight 方法,采用以下步骤:V8.png

  1. O 为 以 this 值作为参数调用 ToObject 的结果。
  2. lenValue 为 以 "length" 作为参数调用 O[[Get]] 内部方法的结果。V8.png
  3. lenToUint32(lenValue)。
  4. 如果 IsCallable(callbackfn) 是 false,抛出一个 TypeError 异常。
  5. 如果 len0 并且 initialValue 不是 present,抛出一个 TypeError 异常。
  6. k0
  7. 如果 initialValue 参数有传入值,则
    1. 设定 accumulatorinitialValue
  8. 否则,initialValue 参数没有传入值 Note.png
    1. kPresentfalse
    2. 只要 kPresentfalse 并且 k0,就重复
      1. PkToString(k)。
      2. kPresent 为 以 Pk 作为参数调用 O[[HasProperty]] 内部方法的结果。
      3. 如果 kPresenttrue,则
        1. accumulator 为 以 Pk 作为参数调用 O[[Get]] 内部方法的结果。
      4. k 递减 1
    3. 如果 kPresentfalse,抛出一个 TypeError 异常。
  9. 只要 k0,就重复
    1. PkToString(k)。
    2. kPresent 为 以 Pk 作为参数调用 O[[HasProperty]] 内部方法的结果。
    3. 如果 kPresenttrue,则
      1. kValue 为 以 Pk 作为参数调用 O[[Get]] 内部方法的结果。
      2. accumulator 为 以 undefined 作为 this 值并以包含 accumulatorkValuekO 的参数列表调用 callbackfn[[Call]] 内部方法的结果。
    4. k 递减 1.
  10. 返回 accumulator

reduceRight 方法的 length 属性是 1

注:reduceRight 函数被有意设计成通用的;它的 this 值并非必须是数组对象。因此,它可以作为方法转移到其他类型的对象中。一个宿主对象是否可以正确应用这个 reduceRight 函数是依赖于实现的。


Array 实例的属性

Array 实例从数组原型对象继承属性,Array 实例的 [[Class]] 内部属性是 "Array"Array 实例还有以下属性。


[[DefineOwnProperty]] ( P, Desc, Throw )

数组对象使用一个,用在其他原生 ECMAscript 对象的 [[DefineOwnProperty]] 内部方法 (8.12.9) 的变化版。

A 为一个数组对象,Desc 为一个属性描述符,Throw 为一个布尔标示。

在以下算法中,术语“拒绝”指代“如果 Throwtrue,则抛出 TypeError 异常,否则返回 false

当用属性名 P、属性描述 Desc、布尔值 Throw 调用 A[[DefineOwnProperty]] 内部方法,采用以下步骤:

  1. oldLenDesc 为 以 "length" 作为参数调用 A[[GetOwnProperty]] 内部方法的结果。 结果绝不会是 undefined 或一个访问器描述符,因为在创建数组时的 length 是一个不可删除或重新配置的数据属性。
  2. oldLenoldLenDesc.[[Value]]
  3. 如果 P"length", 则
    1. 如果 Desc[[Value]] 字段不存在 , 则
      1. "length"Desc、和 Throw 作为参数在 A 上调用默认的 [[DefineOwnProperty]] 内部方法 (8.12.9),返回结果。
    2. newLenDescDesc 的一个拷贝。
    3. newLenToUint32(Desc.[[Value]])。
    4. 如果 newLen 不等于 ToNumber(Desc.[[Value]]),抛出一个 RangeError 异常。
    5. 设定 newLenDesc.[[Value]]newLen
    6. 如果 newLenoldLen,则
      1. "length"newLenDescThrow 作为参数在 A 上调用默认的 [[DefineOwnProperty]] 内部方法 (8.12.9),返回结果。
    7. 如果 oldLenDesc.[[Writable]]false拒绝
    8. 如果 newLenDesc.[[Writable]] 不存在或值是 true,令 newWritabletrue
    9. 否则,
      1. 因为它将使得无法删除任何元素,所以需要延后设定 [[Writable]] 特性为 false
      2. newWritablefalse
      3. 设定 newLenDesc.[[Writable]]true
    10. succeeded 为 以 "length"newLenDescThrow 作为参数在 A 上调用默认的 [[DefineOwnProperty]] 内部方法 (8.12.9) 的结果
    11. 如果 succeededfalse,返回 false
    12. 只要 newLen < oldLen,就重复,
      1. 设定 oldLenoldLen1
      2. deleteSucceeded 为 以 ToString(oldLen) 和 false 作为参数调用 A[[Delete]] 内部方法的结果。
      3. 如果 deleteSucceededfalse,则
        1. 设定 newLenDesc.[[Value]]oldLen + 1
        2. 如果 newWritablefalse,设定 newLenDesc.[[Writable]]false
        3. "length"newLenDescfalse 为参数在 A 上调用默认的 [[DefineOwnProperty]] 内部方法。
        4. 拒绝V8.png
    13. 如果 newWritablefalse,则
      1. "length",属性描述符 {[[Writable]]: false} 和 false 作为参数在 A 上调用 [[DefineOwnProperty]] 内部方法。这个调用始终返回 true
    14. 返回 true
  4. 否则如果 P 是一个数组索引 (15.4),则
    1. indexToUint32(P)。
    2. 如果 indexoldLen 并且 oldLenDesc.[[Writable]]false拒绝
    3. succeeded 为 以 PDescfalse 作为参数在 A 上调用默认的 [[DefineOwnProperty]] 内部方法 (8.12.9) 的结果。
    4. 如果 succeededfalse拒绝
    5. 如果 indexoldLen
      1. 设定 oldLenDesc.[[Value]]index + 1
      2. 以 "length"oldLenDescfalse 作为参数在在 A 上调用默认的 [[DefineOwnProperty]] 内部方法。这个调用始终返回 true
    6. 返回 true
  5. PDescThrow 作为参数在在 A 上调用默认的 [[DefineOwnProperty]] 内部方法 (8.12.9),返回结果。


length

数组对象的 length 属性是个数据属性,其值总是在数值上大于任何属性名是数组索引的可删除属性的属性名。

length 属性拥有的初始特性是 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }。

注: 试图将数组的 length 属性设置为一个值时,如果这个值小于或等于数组中最大不可删除的数字属性,那么 length 将会被设置为比那个属性大一的数字。见 15.4.5.1。


String 对象


作为函数调用 String 构造器

当将 String 作为函数调用,而不是作为构造器,它执行一个类型转换。


String ( [ value ] )

返回一个由 ToString(value) 计算出的字符串值(不是 String 对象)。如果没有提供 value,返回空字符串 ""。


String 构造器

String 作为一个 new 表达式的一部分被调用,它是个构造器:它初始化新创建的对象。


new String ( [ value ] )

新构造对象的 [[Prototype]] 内部属性设定为标准内置的字符串原型对象,它是 String.prototype 的初始值 (15.5.3.1)。

新构造对象的 [[Class]] 内部属性设定为 "String"

新构造对象的 [[Extensible]] 内部属性设定为 true

新构造对象的 [[PrimitiveValue]] 内部属性设定为 ToString(value),或如果没提供 value 则设定为空字符串。


String 构造器的属性

String 构造器的 [[Prototype]] 内部属性的值是标准的内置 Function 原型对象

除了内部属性和 length 属性(值为 1)之外,String 构造器还有以下属性:


String.prototype

String.prototype 的初始值是标准的内置 String 原型对象V8.png

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


String.fromCharCode ( [ char0 [ , char1 [ , … ] ] ] )

返回一个字符串值,包含的字符数与参数数目相同。每个参数指定返回字符串中的一个字符,也就是说第一个参数第一个字符,以此类推(从左到右)。一个参数转换为一个字符,通过先应用 ToUint16 操作,再将返回的16位整数看作字符的代码单元值。如果没提供参数,返回空字符串。V8.png

fromCharCode 函数的 length 属性是 1


字符串原型对象的属性

字符串原型对象本身是一个值为空字符串的 String 对象(它的 [[Class]]"String")。

字符串原型对象的 [[Prototype]] 内部属性值是标准的内置 Object 原型对象


String.prototype.constructor

String.prototype.constructor 的初始值是内置 String 构造器。V8.png


String.prototype.toString ( )

返回 this 字符串值。(注,对于一个 String 对象,toString 方法和 valueOf 方法返回相同值。)

toString 函数是非通用的;如果它的 this 值不是一个字符串或字符串对象,则抛出一个 TypeError 异常。因此它不能作为方法转移到其他类型对象上。V8.png


String.prototype.valueOf ( )

返回 this 字符串值。

valueOf 函数是非通用的;如果它的 this 值不是一个字符串或字符串对象,则抛出一个 TypeError 异常。因此它不能作为方法转移到其他类型对象上。V8.png


String.prototype.charAt (pos)

this 对象转换为一个字符串,返回包含了这个字符串 pos 位置的字符的字符串。如果那个位置没有字符,返回空字符串。返回结果是个字符串值,不是字符串对象。

如果 pos 是一个数字类型的整数值,则 x.charAt(pos) 与 x.substring(pos, pos + 1) 的结果相等。

当用一个参数 pos 调用 charAt 方法,采用以下步骤:

  1. this 值作为参数调用 CheckObjectCoercible
  2. S 为以 this 值作为参数调用 ToString 的结果。
  3. positionToInteger(pos)。
  4. sizeS 的字符数。
  5. 如果 position < 0positionsize,返回空字符串。
  6. 返回一个长度为 1 的字符串,它包含 Sposition 位置的一个字符,在这里 S 中的第一个(最左边)字符被当作是在位置 0,下一个字符被当作是在位置 1,等等。
注: charAt 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.charCodeAt (pos)

this 对象转换为一个字符串,返回一个代表这个字符串 pos 位置字符的代码单元值的数字(小于 216 的非负整数)。如果那个位置没有字符,返回 NaN

当用一个参数 pos 调用 charCodeAt 方法,采用以下步骤:V8.png

  1. this 值作为参数调用 CheckObjectCoercible
  2. S 为以 this 值作为参数调用 ToString 的结果。
  3. positionToInteger(pos)。V8.png
  4. sizeS 的字符数。
  5. 如果 position < 0positionsize,返回 NaN.
  6. 返回一个数字类型值,值是字符串 Sposition 位置字符的代码单元值。 在这里 S 中的第一个(最左边)字符被当作是在位置 0,下一个字符被当作是在位置 1,等等。
注: charCodeAt 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.concat ( [ string1 [ , string2 [ , … ] ] ] )

当用一个或更多参数 string1string2,等,调用 concat 方法,它返回一个字符串,其中包含了转换成字符串类型的 this 对象中的所有字符和后面跟着的每个参数(例如:string1string2,等)转换成字符串类型后里面的所有字符。返回结果是一个字符串值,不是一个字符串对象。采用以下步骤:V8.png

  1. this 值作为参数调用 CheckObjectCoercible
  2. S 为以 this 值作为参数调用 ToString 的结果。V8.png
  3. args 为一个内部列表,它是传给这个函数的参数列表的拷贝。
  4. RS
  5. 只要 args 不是空,就重复
    1. 删除 args 的第一个元素,并令 next 为这个元素。
    2. R 为一个包含了 R 中原有的所有字符跟上 ToString(next) 中的所有字符 的字符串值。
  6. 返回 R

concat 方法的 length 属性是 1.

注: concat 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.indexOf (searchString, position)

this 对象转换为一个字符串,如果 searchString 在这个字符串里大于或等于 position 的位置中的一个或多个位置使它呈现为字符串的子串,那么返回这些位置中最小的索引;否则返回 -1。如果 positionundefined,就认为它是 0,以搜索整个字符串。

indexOf 需要两个参数 searchStringposition,执行以下步骤:V8.png

  1. this 值作为参数调用 CheckObjectCoercible
  2. 令 S 为以 this 值作为参数调用 ToString 的结果。V8.png
  3. searchStrToString(searchString)。
  4. posToInteger(position)。(如果 positionundefined,此步骤产生 0)。
  5. lenS 的字符数。
  6. startmin(max(pos, 0), len)。
  7. searchLenSearchStr 的字符数。
  8. 返回 一个不小于 start 的可能的最小值整数 k,使得 k + searchLen 不大于 len,并且对所有小于 searchLen 的非负数整数 jSk + j 位置字符和 searchStrj 位置字符相同;但如果没有这样的整数 k,则返回 -1Note.png

indexOflength 属性是 1

注: indexOf 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.lastIndexOf (searchString, position)


this 对象转换为一个字符串,如果 searchString 在这个字符串里小于或等于 position 的位置中的一个或多个位置使它呈现为字符串的子串,那么返回这些位置中最大的索引;否则返回 -1。如果 positionundefined Note.png,就认为它是字符串值的长度,以搜索整个字符串。

lastIndexOf 需要两个参数 searchStringposition,执行以下步骤:V8.png

  1. this 值作为参数调用 CheckObjectCoercible
  2. S 为以 this 值作为参数调用 ToString 的结果。V8.png
  3. searchStrToString(searchString)。
  4. numPosToNumber(position)。( 如果 positionundefined,此步骤产生 NaN)。
  5. 如果 numPosNaN,令 pos+∞;否则,令 posToInteger(numPos)。
  6. lenS 的字符数。
  7. startmin(max(pos, 0), len)。
  8. searchLenSearchStr 的字符数。
  9. 返回 一个不大于 start 的可能的最大值整数 k,使得 k + searchLen 不大于 len,并且对所有小于 searchLen 的非负数整数 jSk + j 位置字符和 searchStrj 位置字符相同;但如果没有这样的整数 k,则返回 -1Note.png

lastIndexOflength 属性是 1

注: lastIndexOf 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.localeCompare (that)

当以一个参数 that 来调用 localeCompare 方法,它返回一个非 NaN 数字值,这个数字值反应了对 this 值(转换为字符串)和 that 值(转换为字符串)进行语言环境敏感的字符串比较的结果。两个字符串 SThat 用实现定义的一种方式进行比较。比较结果是按照系统默认语言环境指定的顺序来排列字符串。根据这三种情况:SThat 前面、两字符串相同、SThat 后面,分别返回:负数、零、正数。

在执行比较之前执行以下步骤以预备好字符串:

  1. this 值作为参数调用 CheckObjectCoercible
  2. 令 S 为以 this 值作为参数调用 ToString 的结果。V8.png
  3. ThatToString(that)。

如果将 localeCompare 方法看做是将 thisthat 作为两个参数的函数,那么它是在所有字符串集合上的保持一致的比较函数(在 15.4.4.11 定义)。

实际返回值是实现定义的,允许实现者们在返回值里编码附加信息。但是函数需要定义一个在所有字符串上的总的顺序。并且,当比较的字符串们被认为是 Unicode 标准定义的标准等价,则返回 0

如果宿主环境没有在所有字符串上语言敏感的比较,此函数可执行按位比较。

注: localeCompare 方法自身不适合直接作为 Array.prototype.sort 的参数,因为后者需要的是两个参数的函数。
注: 这个函数的目的是在宿主环境中任何依靠语言敏感的比较方式都可用于 ECMAScript 环境,并根据宿主环境当前语言环境设置的规则进行比较。强烈建议这个函数把根据 Unicode 标准的标准等价的字符串当做是相同的(也就是说,要比较的字符串仿佛是都先被转换为正规化形式 C 或正规化形式 D 了)。还建议这个函数不履行 Unicode 相容等价或分解。
注: 本标准的未来版本可能会使用这个函数的第二个参数;建议实现不将这个参数位用作其他用途。
注: localeCompare 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.match (regexp)

当以 regexp 作为参数调用 match 方法,采用以下步骤:V8.png

  1. this 值作为参数调用 CheckObjectCoercible
  2. S 为以 this 值作为参数调用 ToString 的结果。
  3. 如果 Type(regexp) 是 Object 并且 regexp[[Class]] 内部属性的值是 "RegExp",则令 rxregexpV8.png
  4. 否则,令 rx 为 仿佛是用表达式 new RegExp(regexp) 创建的新正则对象,这里的 RegExp 是标准内置构造器名。V8.png
  5. global 为 以 "global" 为参数调用 rx[[Get]] 内部方法的结果。
  6. exec 为 标准内置函数 RegExp.prototype.exec ( 见 15.10.6.2)
  7. 如果 global 不是 true,则
    1. rx 作为 this 值,用包含 S 的参数列表调用 exec[[Call]] 内部方法,返回结果。
  8. 否则,globaltrue
    1. "lastIndex"0 作为参数调用 rx[[Put]] 内部方法。
    2. A 为 仿佛是用表达式 new Array() 创建的新数组,这里的 Array 是标准内置构造器名。
    3. previousLastIndex0
    4. n0
    5. lastMatchtrue
    6. 只要 lastMatchtrue,就重复
      1. result 为 以 rx 作为 this 值,用包含 S 的参数列表调用 exec[[Call]] 内部方法的结果。
      2. 如果 resultnull,则设定 lastMatchfalse
      3. 否则,result 不是 null
        1. thisIndex 为 以 "lastIndex" 为参数调用 rx[[Get]] 内部方法的结果。
        2. 如果 thisIndex = previousLastIndexQuestion.png
          1. "lastIndex"thisIndex + 1 为参数调用 rx[[Put]] 内部方法。
          2. 设定 previousLastIndexthisIndex + 1
        3. 否则,设定 previousLastIndexthisIndex
        4. matchStr 为 以 0 为参数调用 result[[Get]] 内部方法的结果。
        5. ToString(n),属性描述符 {[[Value]]: matchStr, [[Writable]]: true, [[Enumerable]]: true, [[configurable]]: true} 和 false 作为参数调用 A[[DefineOwnProperty]] 内部方法。
        6. n 递增 1
    7. 如果 n = 0,则返回 null
    8. 返回 A
注: match 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.replace (searchValue, replaceValue)

首先根据以下步骤设定 string

  1. this 值作为参数调用 CheckObjectCoercible
  2. string 为 以 this 值作为为参数调用 ToString 的结果。

如果 searchValue 是一个正则表达式([[Class]] 内部属性是 "RegExp" 的对象),按照如下执行:如果 searchValue.globalfalse,则搜索 string,找出匹配正则表达式 searchValue 的第一个子字符串。如果 searchValue.globaltrue,则搜索 string,找出匹配正则表达式 searchValue 的所有子字符串。搜索的做法与 String.prototype.match 相同,包括对 searchValue.lastIndex 的更新。令 msearchValue 的左捕获括号的个数(使用 15.10.2.1 指定的 NcapturingParens)。V8.png

如果 searchValue 不是正则表达式,令 searchStringToString(searchValue),并搜索 string,找出第一个出现的 searchString 的子字符串。令 m0V8.png

如果 replaceValue 是函数,则对每个匹配的子字符串,以 m + 3 个参数调用这个函数。第一个参数是匹配的子字符串。如果 searchValue 是正则表达式,接下来 m 个参数是 MatchResult 里的所有捕获值。第 m + 2 个参数是发生的匹配在 string 里的偏移量,第 m + 3 个参数是 string。结果是将输入的原字符串里的每个匹配子字符串替换为相应函数调用的返回值(必要的情况下转换为字符串)得到的字符串。

否则,令 newstring 表示 replaceValue 转换为字符串的结果。结果是将输入的原字符串里的每个匹配子字符串替换为 newstring 里的字符根据表22指定的替代文本替换得到的字符串。替换这些 $ 是由左到右进行的,并且一旦执行了这样的替换,新替换的文本不受进一步替换。例如 ,"$1,$2".replace(/(\$(\d))/g, "$$1-$1$2") 返回 "$1-$11,$1-$22"newstring 里的一个 $ ,如果不符合以下任何格式,就保持原状。

表22 替代文本符号替换
字符 替代文本
$$ $
$& 匹配到的子字符串
$` Note.png string 中匹配到的子字符串之前部分。
$' Note.png string 中匹配到的子字符串之后部分。
$n n 个捕获结果,n 是范围在 19 的单个数字,并且紧接着 $n 后面的不是十进制数字。如果 nm 且第 n 个捕获结果是 undefined,就用空字符串代替。如果 n > m,结果是实现定义的。
$nn nn 个捕获结果,nn 是范围在 0199 的十进制两位数。如果 nnm 且第 nn 个捕获结果是 undefined,就用空字符串代替。如果 nn > m,结果是实现定义的。
注: replace 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.search (regexp)

当用参数 regexp 调用 search 方法,采用以下步骤:V8.png

  1. this 值作为参数调用 CheckObjectCoercible
  2. string 为 以 this 值作为参数调用 ToString 的结果。
  3. 如果 Type(regexp) 是 Objectregexp[[Class]] 内部属性的值是 "RegExp", 则令 rxregexpV8.png
  4. 否则,令 rx 为仿佛是用表达式 new RegExp(regexp) 创建的新正则对象,这里的 RegExp 是标准内置构造器名。
  5. string 开始位置搜索正则表达式模式 rx 的匹配。如果找到匹配,令 result 为匹配在 string 里的偏移量;如果没有找到匹配,令 result-1。执行搜索时 regexplastIndexglobal 属性是被忽略的。regexplastIndex 属性保持不变。
  6. 返回 result
注: search 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.slice (start, end)

slice 方法需要两个参数 startend,将 this 对象转换为一个字符串,返回这个字符串中从 start 位置的字符到(但不包含)end 位置的字符的一个子字符串(或如果 endundefined,就直接到字符串尾部)。用 sourceLength 表示字符串长度,如果 start 是负数,就把它看做是 sourceLength + start;如果 end 是负数,就把它看做是 sourceLength + end。返回结果是一个字符串值,不是字符串对象。采用以下步骤:V8.png

  1. this 值作为参数调用 CheckObjectCoercible
  2. S 为以 this 值作为参数调用 ToString 的结果。
  3. lenS 的字符数 .V8.png
  4. intStartToInteger(start)。
  5. 如果 endundefined,令 intEndlen;否则 令 intEndToInteger(end)。
  6. 如果 intStartnegative,令 frommax(len + intStart , 0);否则 令 frommin(intStart , len)。
  7. 如果 intEndnegative,令 tomax(len + intEnd, 0);否则 令 tomin(intEndlen)。
  8. spanmax(to - from, 0 )。
  9. 返回 一个包含 Sform 位置的字符开始的 span 个连续字符 的字符串。V8.png

slice 方法的 length 属性是 2

注: slice 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.split (separator, limit)

this 字符串转换为一个字符串,返回一个数组对象,里面存储了这个字符串的子字符串。子字符串是从左到右搜索 separator 的匹配来确定的;这些匹配结果不成为返回数组的任何子字符串元素,但被用来分割字符串。separator 的值可以是一个任意长度的字符串,也可以是一个正则对象(即,一个 [[Class]] 内部属性为 "RegExp" 的对象;见 15.10)。

separator 值可以是一个空字符串、一个空正则表达式或一个可匹配空字符串的正则表达式。这种情况下,separator 不匹配输入字符串开头和末尾的空的子串,也不匹配分隔符的之前匹配结果末尾的空字串。(例如,如果 separator 是空字符串,要将字符串分割为单个字符们;结果数组的长度等于字符串长度,且每个字串都包含一个字符。)如果 separator 是正则表达式,在 this 字符串的给定位置中只考虑首次匹配结果,即使如果在这个位置上回溯可产生一个非空的子串。(例如,"ab".split(/a*?/) 的执行结果是数组 ["a","b"],而 "ab".split(/a*/) 的执行结果是数组 ["","b"] 。)

如果 this 对象是(或转换成)空字符串,返回的结果取决于 separator 是否可匹配空字符串。如果可以,结果是不包含任何元素的数组。否则,结果是包含一个空字符串元素的数组。

如果 separator 是包含捕获括号的正则表达式,则对 separator 的每次匹配,捕获括号的结果 ( 包括 undefined ) 都拼接为输出数组。

例如,

 "A<B>bold</B>and<CODE>coded</CODE>".split(/<(\/)?([^<>]+)>/)

执行结果是数组:

 ["A", undefined, "B", "bold", "/", "B", "and", undefined,
 "CODE", "coded", "/", "CODE", ""]

如果 separatorundefined,则返回结果是只包含 this 值(转换为字符串)一个字符串元素的数组。如果 limit 不是 undefined,则输出数组被切断为包含不大于 limit 个元素。V8.png


当调用 split 方法,采用以下步骤:V8.png V8.png V8.png

  1. this 值作为参数调用 CheckObjectCoercible
  2. S 为以 this 值作为参数调用 ToString 的结果。
  3. A 为 仿佛使用表达式 new Array() 创建的新对象,这里的 Array 是标准内置构造器名。
  4. lengthA0
  5. 如果 limitundefined,令 lim = 232 - 1; 否则 令 lim = ToUint32(limit)。
  6. sS 的字符数。
  7. p = 0
  8. 如果 separator 是正则对象(它的 [[Class]]"RegExp"),令 R = separator;否则,令 R = ToString(separator)。
  9. 如果 lim = 0,返回 A
  10. 如果 separatorundefined, 则
    1. "0"、属性描述符 {[[Value]]: S, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 作为参数调用 A[[DefineOwnProperty]] 内部方法。
    2. 返回 A
  11. 如果 s = 0,则
    1. 调用 SplitMatch(S, 0, R) 并 令 z 为 它的 MatchResult 结果。
    2. 如果 z 不是 failure,返回 A
    3. "0"、属性描述符 {[[Value]]: S, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 作为参数调用 A[[DefineOwnProperty]] 内部方法。
    4. 返回 A
  12. q = p
  13. 只要 qs,就重复
    1. 调用 SplitMatch(S, q, R) 并 令 z 为 它的 MatchResult 结果。
    2. 如果 zfailure, 则 令 q = q + 1
    3. 否则,z 不是 failure
      1. z 必定是一个 State。令 ezendIndex 并 令 capzcaptures 数组。
      2. 如果 e = p,则 令 q = q + 1
      3. 否则,ep
        1. T 为一个字符串,它的值等于包含 在 Sp(包括它)位置到 q(不包括)位置的字符 的子字符串的值。
        2. ToString(lengthA)、属性描述符 {[[Value]]: T, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 作为参数调用 A[[DefineOwnProperty]] 内部方法 .
        3. lengthA 递增 1
        4. 如果 lengthA = lim,返回 A
        5. p = e
        6. i = 0
        7. 只要 i 不等于 cap 中的元素个数,就重复。
          1. i = i + 1
          2. ToString(lengthA)、属性描述符 {[[Value]]: cap[i], [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 作为参数调用 A 的 [[DefineOwnProperty]] 内部方法。
          3. lengthA 递增 1
          4. 如果 lengthA = lim,返回 A
        8. q = p
  14. T 为 为一个字符串,它的值等于包含 在 Sp(包括它)位置到 q(不包括)位置的字符 的子字符串的值。
  15. ToString(lengthA)、属性描述符 {[[Value]]: T, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 作为参数调用 A[[DefineOwnProperty]] 内部方法。
  16. 返回 A


SplitMatch 抽象操作需要三个参数,字符串 S、整数 q、字符串或正则对象 R,按照以下顺序执行并返回一个 MatchResult

  1. 如果 R 是个正则对象 ( 它的 [[Class]]"RegExp"),则
    1. Sq 作为参数调用 R[[Match]] 内部方法,并返回 MatchResult 的结果。
  2. 否则,Type(R) 必定是 String。令 rR 的字符数。Note.png
  3. sS 的字符数 .
  4. 如果 q + r > s 则返回 MatchResult failure
  5. 如果存在一个在 0(包括)到 r(不包括)之间的整数 i,使得 Sq + i 位置上的字符和 Ri 位置上的字符不同,则返回 failure
  6. capcaptures 的空数组 ( 见 15.10.2.1)。
  7. 返回 State 数据结构 (q + r, cap). ( 见 15.10.2.1)

split 方法的 length 属性是 2.

注: 分隔符是正则对象时,split 方法忽略 separator.global 的值。
注: split 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.substring (start, end)

substring 方法需要两个参数 startend,将 this 对象转换为一个字符串,返回一个子串,这个子串包含了在转换结果字符串中从 start 位置字符一直到(但不包括)end 位置的字符(或如果 endundefined,就到字符串末尾)。返回结果是字符串值,不是字符串对象。

如果任一参数是 NaN 或负数,它被零取代;如果任一参数大于字符串长度,它被字符串长度取代。

如果 start 大于 end,交换它们的值。

采用以下步骤:V8.png

  1. this 值作为参数调用 CheckObjectCoercible
  2. S 为以 this 值作为参数调用 ToString 的结果。V8.png
  3. lenS 的字符数。
  4. intStartToInteger(start)。
  5. 如果 endundefined,令 intEndlen;否则 令 intEndToInteger(end)。
  6. finalStartmin(max(intStart, 0 ), len)。
  7. finalEndmin(max(intEnd, 0 ), len)。
  8. frommin(finalStart, finalEnd)。
  9. tomax(finalStart, finalEnd)。
  10. 返回 一个长度是 to - from 的字符串,它包含 S 中从索引值 formto - 1(按照索引升序)的所有字符。 V8.png

substring 方法的 length 属性是 2

注: substring 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.toLowerCase ( )

采用以下步骤:V8.png

  1. this 值作为参数调用 CheckObjectCoercible
  2. S 为以 this 值作为参数调用 ToString 的结果。V8.png
  3. L 为一个字符串,L 的每个字符是 S 中相应字符的 Unicode 小写等量,或者(如果没有 Unicode 小写等量存在)是实际的 S 中相应字符值。Note.png V8.png
  4. 返回 L

为了此操作,字符串的16位代码单元被看作是 Unicode 基本多文种平面中的代码点。代理代码点直接从 S 转移到 L,不做任何映射。

返回结果必须是根据 Unicode 字符数据库里的大小写映射得到的(对此数据库明确规定,不仅包括 UnicodeData.txt 文件,而且还包括 Unicode 2.1.8 和更高版本里附带的 SpecialCasings.txt 文件)。

注: 某些字符的大小写映射可产生多个字符。这种情况下结果字符串与原字符串的长度未必相等。因为 toUpperCasetoLowerCase 都有上下文敏感的行为,所以这俩函数不是对称的。也就是说,s.toUpperCase().toLowerCase() 不一定等于 s.toLowerCase()
注: toLowerCase 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.toLocaleLowerCase ( )

此函数产生依照 宿主环境的当前语言设置 更正的结果,而不是独立于语言环境的结果,除此之外它的运作方式与 toLowerCase 完全一样。只有在少数情况下有一个区别(如,土耳其语),就是那个语言和正规 Unicode 大小写映射有冲突时的规则。V8.png

注: 此函数的第一个参数可能会用于本标准的未来版本;建议实现不以任何用途使用这个参数位置。
注: toLocaleLowerCase 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.toUpperCase ( )

此函数的将字符映射到在 Unicode 字符数据库中与其等值的大写字符,除此之外此函数的行为采用与 String.prototype.toLowerCase 完全相同的方式。V8.png

注: toUpperCase 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.toLocaleUpperCase ( )

此函数产生依照 宿主环境的当前语言设置 更正的结果,而不是独立于语言环境的结果,除此之外它的运作方式与 toUpperCase 完全一样。只有在少数情况下有一个区别(如,土耳其语),就是那个语言和正规 Unicode 大小写映射有冲突时的规则。V8.png

注: 此函数的第一个参数可能会用于本标准的未来版本;建议实现不以任何用途使用这个参数位置。
注: toLocaleUpperCase 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。


String.prototype.trim ( )

采用以下步骤:V8.png

  1. this 值作为参数调用 CheckObjectCoercible
  2. S 为以 this 值作为参数调用 ToString 的结果。
  3. T 为一个字符串值,它是 S 的一个拷贝,并删除了开头和结尾中空白的。空白的定义是 空白字符行终止符 的并集。V8.png
  4. 返回 T
注: trim 函数被有意设计成通用的;它不要求它的 this 值是字符串对象。因此,他可以当做方法转移到其他类型对象。

String 实例的属性

字符串实例从字符串原型对象继承属性,字符串实例的 [[Class]] 内部属性值是 "String"。字符串实例还有 [[PrimitiveValue]] 内部属性,length 属性,和一组属性名是数组索引的可遍历属性。

[[PrimitiveValue]] 内部属性是代表这个字符串对象的字符串值。以数组索引命名的属性对应字符串值里的单字符。一个特殊的 [[GetOwnProperty]] 内部方法用来为数组索引命名的属性指定数字,值,和特性。

length

在代表这个字符串对象的字符串值里的字符数。

一旦创建了一个字符串对象,这个属性是不可变的。它有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

[[GetOwnProperty]] ( P )

数组对象使用一个,用在其他原生 ECMAscript 对象的 [[GetOwnProperty]] 内部方法的变化版。这个特殊内部方法用来给命名属性添加访问器,对应到字符串对象的单字符。V8.png

S 为一个字符串对象,P 为一个字符串。

当以属性名 P 调用 S[[GetOwnProperty]] 内部方法,采用以下步骤:

  1. desc 为 以 P 为参数调用 S 的默认 [[GetOwnProperty]] 内部方法的结果。
  2. 如果 desc 不是 undefined,返回 desc
  3. 如果 ToString(abs( ToInteger(P ))) 与 P 的值不同,返回 undefined
  4. strS[[PrimitiveValue]] 内部属性字符串值。
  5. indexToInteger(P)。
  6. lenstr 里的字符数。
  7. 如果 lenindex,返回 undefined
  8. resultStr 为一个长度为 1 的字符串,里面包含 strindex 位置的一个字符,在这里 str 中的第一个(最左边)字符被认为是在位置 0,下一个字符在位置 1,依此类推。
  9. 返回一个属性描述符 { [[Value]]: resultStr, [[Enumerable]]: true, [[Writable]]: false, [[Configurable]]: false }

Boolean 对象


作为函数调用 Boolean 构造器

当把 Boolean 作为函数来调用,而不是作为构造器,它执行一个类型转换。


Boolean (value)

返回由 ToBoolean(value) 计算出的 Boolean 值(非 Boolean 对象)。V8.png


Boolean 构造器

Boolean 作为 new 表达式的一部分来调用,那么它是一个构造器:它初始化新创建的对象。


new Boolean (value)

新构造对象的 [[Prototype]] 内部属性设定为原始 Boolean 原型对象,它是 Boolean.prototype 的初始值。

新构造对象的 [[Class]] 内部属性设定为 "Boolean"

新构造对象的 [[PrimitiveValue]] 内部属性设定为 ToBoolean(value)。

新构造对象的 [[Extensible]] 内部属性设定为 true


Boolean 构造器的属性

Boolean 构造器的 [[Prototype]] 内部属性的值是 Function 原型对象

除了内部属性和 length 属性(值为 1)外,Boolean 构造器还有以下属性:


Boolean.prototype

Boolean.prototype 的初始值是 Boolean 原型对象V8.png

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


Boolean 原型对象的属性

Boolean 原型对象自身是一个值为 falseBoolean 对象(它的 [[Class]]"Boolean")。

Boolean 原型对象[[Prototype]] 内部属性值是标准的内置 Object 原型对象


Boolean.prototype.constructor

Boolean.prototype.constructor 的初始值是内置的 Boolean 构造器。V8.png


Boolean.prototype.toString ( )

采用以下步骤:

  1. Bthis 值。
  2. 如果 Type(B) 是 Boolean,则令 bB
  3. 否则如果 Type(B) 是 ObjectB[[Class]] 内部属性值是 "Boolean",则令 bB[[PrimitiveValue]] 内部属性值。
  4. 否则抛出一个 TypeError 异常。V8.png
  5. 如果 btrue,则返回 "true";否则返回 "false"


Boolean.prototype.valueOf ( )

采用以下步骤:

  1. Bthis 值。
  2. 如果 Type(B) 是 Boolean,则令 bB
  3. 否则如果 Type(B) 是 ObjectB[[Class]] 内部属性值是 "Boolean",则令 bB[[PrimitiveValue]] 内部属性值。
  4. 否则抛出一个 TypeError 异常。V8.png
  5. 返回 b


Boolean 实例的属性

Boolean 实例从 Boolean 原型对象继承属性,且 Boolean 实例的 [[Class]] 内部属性值是 "Boolean"Boolean 实例 还有一个 [[PrimitiveValue]] 内部属性。

[[PrimitiveValue]] 内部属性是代表这个 Boolean 对象的 Boolean 值。

Number 对象


作为函数调用的 Number 构造器

当把 Number 当作一个函数来调用,而不是作为构造器,它执行一个类型转换。


Number ( [ value ] )

如果提供了 value,返回 ToNumber(value) 计算出的 Number 值(非 Number 对象),否则返回 +0V8.png


Number 构造器

当把 Number 作为 new 表达式的一部分来调用,它是构造器:它初始化新创建的对象。


new Number ( [ value ] )

新构造对象的 [[Prototype]] 内部属性设定为原始 Number 原型对象,它是 Number.prototype 的初始值。

新构造对象的 [[Class]] 内部属性设定为 "Number"

新构造对象的 [[PrimitiveValue]] 内部属性在提供了 value 时设定为 ToNumber(value),否则设定为 +0

新构造对象的 [[Extensible]] 内部属性设定为 true


Number 构造器的属性

Number 构造器的 [[Prototype]] 内部属性值是 Function 原型对象

除了内部属性和 length 属性(值为 1)之外,Number 构造器还有以下属性:


Number.prototype

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

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


Number.MAX_VALUE

Number.MAX_VALUE 的值是 Number 类型的最大正有限值,约为 1.7976931348623157×10308V8.png Note.png

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


Number.MIN_VALUE

Number.MIN_VALUE 的值是 Number 类型的最小正有限值,约为 5×10-324V8.png Note.png

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


Number.NaN

Number.NaN 的值是 NaNV8.png

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


Number.NEGATIVE_INFINITY

Number.NEGATIVE_INFINITY 的值是-∞V8.png

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


Number.POSITIVE_INFINITY

Number.POSITIVE_INFINITY 的值是 +∞V8.png

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


Number 原型对象的属性

Number 原型对象其自身是 Number 对象(其 [[Class]]"Number"),其值为 +0

Number 原型对象的 [[Prototype]] 内部属性值是标准内置 Object 原型对象

除非另外明确声明,以下定义的 Number 原型对象的方法是非通用的,传递给它们的 this 值必须是 Number 值或 [[Class]] 内部属性值是 "Number" 的对象。

在以下对作为 Number 原型对象属性的函数的描述中,短语“this Number 对象”是指函数调用中的 this,或如果 Type( this ) 是 Number,“this Number 对象”指仿佛是用表达式 new Number( this ) 创建的对象,这里 Number 是标准内置构造器名。此外,短语“this Number 值”是指代表 this Number 对象Number 值,也就是 this Number 对象[[PrimitiveValue]] 内部属性值;或如果 thisNumber 类型,“this Number 值”指 this。如果 this 值不是 [[Class]] 内部属性为 "Number" 的对象,也不是 Number 类型的值,则抛出一个 TypeError 异常。


Number.prototype.constructor

Number.prototype.constructor 的初始值是内置 Number 构造器。V8.png


Number.prototype.toString ( [ radix ] )

可选参数 radix 应当是 236 闭区间上的整数。如果 radix 不存在或是 undefined,用数字 10 作为 radix 的值。如果 ToInteger(radix) 是数字 10,则将 this Number 对象 作为一个参数传给 ToString 抽象操作;返回结果字符串值。

如果 ToInteger( radix ) 不是在 236 闭区间上的整数,则抛出一个 RangeError 异常。如果 ToInteger( radix ) 是 236 的整数,但不是 10,则结果是 this Number 值 使用指定基数表示法的字符串。字母 a-z 用来指值为 1035 的数字。基数不为 10 时的精确算法是依赖于实现的,然而算法应当是 9.8.1 指定算法的推广形式。

toString 函数不是通用的;如果 this 值不是数字或 Number 对象,抛出一个 TypeError 异常。因此它不能当作方法转移到其他类型对象上。V8.png


Number.prototype.toLocaleString()

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

注: 此函数的第一个参数可能会用于本标准的未来版本 ; 建议实现不以任何用途使用这个参数位置。


Number.prototype.valueOf ( )

返回 this Number 值

valueOf 函数不是通用的;如果 this 值不是数字或 Number 对象,抛出一个 TypeError 异常。因此它不能当作方法转移到其他类型对象上。V8.png


Number.prototype.toFixed (fractionDigits)

返回一个包含了 代表 this Number 值的留有小数点后 fractionDigits 个数字的十进制固定小数点记法 的字符串。如果 fractionDigitsundefined,就认为是 0。具体来说,执行以下步骤:V8.png

  1. fToInteger(fractionDigits)。(如果 fractionDigitsundefined,此步骤产生 0 值。)
  2. 如果 f < 0f > 20,抛出一个 RangeError 异常。V8.png
  3. xthis Number 值
  4. 如果 xNaN,返回字符串 "NaN"V8.png
  5. s 为空字符串。
  6. 如果 x < 0,则
    1. s"-"
    2. x = -x
  7. 如果 x1021,则
    1. m = ToString(x)。
  8. 否则,x < 1021
    1. n 为一个整数,让 n ÷ 10f - x 准确的数学值尽可能接近零。如果有两个这样 n 值,选择较大的 nNote.png
    2. 如果 n = 0,令 m 为字符串 "0"。否则,令 m 为由 n 的十进制表示里的数 组成的字符串(为了没有前导零)。
    3. 如果 f0,则
      1. km 里的字符数目。
      2. 如果 kf,则
        1. zf + 1 - k'0' 组成的字符串。
        2. m 为 串联字符串 zm 的结果。
        3. k = f + 1
      3. am 的前 kf 个字符,令 b 为其余 f 个字符。
      4. m 为 串联三个字符串 a"."b 的结果。
  9. 返回串联字符串 sm 的结果。

toFixed 方法的 length 属性是 1

如果以多个参数调用 toFixed 方法,则行为是不确定的(见15章)。

实现是被允许在 fractionDigits 小于 0 或大于 20 时扩展 toFixed 的行为。在这种情况下,对这样的 fractionDigitstoFixed 将未必抛出 RangeError

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

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

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


Number.prototype.toExponential (fractionDigits)

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

  1. xthis Number 值
  2. fToInteger(fractionDigits)。
  3. 如果 xNaN,返回字符串 "NaN"
  4. s 为空字符串。
  5. 如果 x < 0,则
    1. s"-"
    2. x = -x
  6. 如果 x = +∞,则
    1. 返回串联字符串 s"Infinity" 的结果。
  7. 如果 fractionDigits 不是 undefined 且(f < 0f > 20),抛出一个 RangeError 异常。V8.png
  8. 如果 x = 0,则
    1. f = 0
    2. m 为包含 f + 1'0' 的字符串。
    3. e = 0
  9. 否则,x0
    1. 如果 fractionDigits 不是 undefined,则
      1. en 为整数,使得满足 10fn < 10f+1n × 10e-f - x 的准确数学值尽可能接近零。如果 en 有两个这样的组合,选择使 n × 10e-f 更大的组合。
    2. 否则,fractionDigitsundefined
      1. enf 为整数,使得满足 f010fn < 10f+1n × 10e-fNumber 值是 x,且 f 的值尽可能小。注:n 的十进制表示有 f + 1 个数字,n 不能被 10 整除,并且 n 的最少有效位数不一定唯一由这些条件确定。
    3. m 为由 n 的十进制表示里的数 组成的字符串(没有前导零)。
  10. 如果 f0,则
    1. am 中的第一个字符,令 bm 中的其余字符。
    2. m 为串联三个字符串 a"."b 的结果。
  11. 如果 e = 0,则
    1. c = "+"
    2. d = "0"
  12. 否则
    1. 如果 e > 0,则 令 c = "+"
    2. 否则,e0
      1. c = "-"
      2. e = -e
    3. d 为有 e 的十进制表示里的数 组成的字符串(没有前导零)。
  13. m 为串联四个字符串 m"e"cd 的结果。
  14. 返回串联字符串 sm 的结果。

toExponential 方法的 length 属性是 1

如果用多于一个参数调用 toExponential 方法,则行为是未定义的(见15章)。

一个实现可以扩展 fractionDigits 的值小于 0 或大于 20toExponential 的行为。这种情况下对这样的 fractionDigits 值,toExponential 不一定抛出 RangeError 异常。

注: 对于需要提供比上述规则更准确转换的实现,建议用以下算法作为指引替代步骤 9.2.1
  1. enf 为整数,使得满足 f010fn < 10f+1n × 10e-fNumber 值是 x,且 f 的值尽可能小。如果这样的 n 值可能多个,选择使 n × 10e-f 的值尽可能接近 xn 值。如果有两个这样的 n 值,选择偶数。


Number.prototype.toPrecision (precision)

返回一个字符串,它代表 this Number 值 的科学计数法(有效数字的小数点前有一个数字,有效数字的小数点后有 precision - 1 个数字)或十进制固定计数法(precision 个有效数字)。如果 precisionundefined,用 ToString 调用代替。具体来说执行以下步骤:V8.png

  1. xthis 数字值。
  2. 如果 precisionundefined,返回 ToString(x)。
  3. pToInteger(precision)。
  4. 如果 x 是 NaN,返回字符串 "NaN"
  5. s 为空字符串。
  6. 如果 x < 0,则
    1. s"-"
    2. x = -x
  7. 如果 x = +∞,则
    1. 返回串联字符串 s"Infinity" 的结果。
  8. 如果 p < 1p > 21,抛出一个 RangeError 异常。V8.png
  9. 如果 x = 0,则
    1. mp'0' 组成的字符串。
    2. e = 0
  10. 否则 x0
    1. en 为整数,使得满足 10p-1n < 10pn × 10e-p+1 - x 的准确数学值尽可能接近零。如果 en 有两个这样的组合,选择使 n × 10e-p+1 更大的组合。
    2. m 为由 n 的十进制表示里的数 组成的字符串(没有前导零)。
    3. 如果 e < -6ep。则
      1. an 的第一个字符,令 bm 的其余 p-1 个字符/
      2. m 为串联三个字符串 a"."b 的结果。
      3. 如果 e = 0,则
        1. c = "+",令 d = "0"
      4. 否则 e0
        1. 如果 e > 0,则
          1. c = "+"
        2. 否则 e < 0
          1. c = "-"
          2. e = -e
        3. d 为由 e 的十进制表示里的数 组成的字符串(没有前导零)。
      5. m 为串联五个字符串 sm"e"cd 的结果。
  11. 如果 e = p - 1,则返回串联字符串 sm 的结果。
  12. 如果 e0,则
    1. mm 的前 e + 1 个字符,字符 '.'m 的其余 p - (e + 1) 个字符 串联的结果。
  13. 否则 e < 0
    1. m 为 字符串 "0."、- (e + 1) 个字符 '0'、字符串 m 串联的结果。
  14. 返回字符串 sm 串联的结果。

toPrecision 方法的 length 属性是 1

如果用多于一个参数调用 toPrecision 方法,则行为是未定义的(见15章)。

一个实现可以扩展 precision 的值小于 1 或大于 21toPrecision 的行为。这种情况下对这样的 precision 值,toPrecision 不一定抛出 RangeError 异常。


Number 实例的属性

Number 实例从 Number 原型对象继承属性,Number 实例的 [[Class]] 内部属性是 "Number"Number 实例还有一个 [[PrimitiveValue]] 内部属性。

[[PrimitiveValue]] 内部属性是代表 this Number 对象Number 值。

Math 对象

Math 对象是拥有一些命名属性的单一对象,其中一些属性值是函数。

Math 对象的 [[Prototype]] 内部属性值是标准内置 Object 原型对象 (15.2.4)。Math 对象的 [[Class]] 内部属性值是 "Math"

Math 对象没有 [[Construct]] 内部属性 ; Math 对象不能作为构造器被 new 运算符调用。

Math 对象没有 [[Call]] 内部属性;Math 对象不能作为函数被调用。

注: 本规范中,短语“x 的 Number 值”的技术含义定义在 8.5。Note.png


Math 对象的值属性


E

自然对数的底数 eNumber 值,约为 2.7182818284590452354V8.png

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


LN10

10 的自然对数的 Number 值,约为 2.302585092994046V8.png

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

LN2

2 的自然对数的 Number 值,约为 0.6931471805599453V8.png

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


LOG2E

自然对数的底数 e 的以 2 为底数的对数的 Number 值;约为 1.4426950408889634V8.png

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

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


LOG10E

自然对数的底数 e 的以 10 为底数的对数的 Number 值;约为 0.4342944819032518V8.png

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

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


PI

圆的周长与直径之比 πNumber 值,约为 3.1415926535897932V8.png

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


SQRT1_2

½ 的平方根的 Number 值,约为 0.7071067811865476V8.png

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

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


SQRT2

2 的平方根的 Number 值,约为 1.4142135623730951V8.png

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


Math 对象的函数属性

对以下每个 Math 对象函数的每个参数(如果有多个,以左到右的顺序)应用 ToNumber 抽象操作,然后对结果 Number 值执行计算。

下面对函数的描述中,符号 NaN-0+0-∞+∞8.5 描述的 Number 值。

注:这里没有精确规定函数 acosasinatanatan2cosexplogpowsinsqrttan 的行为,除了需要特别说明对边界情况某些参数值的结果之外。对其他参数值,这些函数指在计算常见数学函数的结果,但选择的近似算法中的某些范围是被允许的。一般意图是实现者应该可以为ECMAScript在一个给定的硬件平台上使用相同的数学库,那是在平台上对C程序员们有用的。

尽管算法的选择由实现来决定的,但它被推荐(不是由这个标准指定)使用包含在fdlibm的IEEE754算法的近似算法来实现,这个可以自由分配的数学库来自Sun公司(http://www.netlib.org/fdlibm).


abs (x)

返回 x 的绝对值。V8.png

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


acos (x)

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

  • xNaN,返回结果是 NaN
  • x 大于 1,返回结果是 NaN
  • x 小于 -1,返回结果是 NaN
  • x 正好是 1,返回结果是 +0


asin (x)

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

  • xNaN,返回结果是 NaN
  • x 大于 1,返回结果是 NaN
  • x 小于 –1,返回结果是 NaN
  • x+0,返回结果是 +0
  • x-0,返回结果是 -0


atan (x)

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

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


atan2 (y, x)

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

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


ceil (x)

返回不小于 x 的且为数学整数的最小 ( 接近 -∞ ) Number 值。如果 x 已是整数,则返回 xV8.png

  • xNaN,返回结果是 NaN
  • x+0,返回结果是 +0
  • x-0,返回结果是 -0
  • x+∞,返回结果是 +∞
  • x-∞,返回结果是 -∞
  • x 小于 0 但大于 -1,返回结果是 -0
注:Math.ceil(x) 的值与 -Math.floor(-x) 的值相同。


cos (x)

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

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


exp (x)

返回 x 的指数的依赖实现的近似值(ex 次方,e 为自然对数的底)。V8.png

  • 若 x 是 NaN, 返回结果是 NaN.
  • 若 x 是 +0, 返回结果是 1.
  • 若 x 是 -0, 返回结果是 1.
  • 若 x 是 +∞, 返回结果是 +∞.
  • 若 x 是 -∞, 返回结果是 +0.

floor (x)

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

  • xNaN,返回结果是 NaN
  • x+0,返回结果是 +0
  • x-0,返回结果是 -0
  • x+∞,返回结果是 +∞
  • x-∞,返回结果是 -∞
  • x 大于 0 但小于 1,返回结果是 +0
注:Math.floor(x) 的值与 -Math.ceil(-x) 的值相同。


log (x)

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

  • xNaN,返回结果是 NaN
  • x 小于 0,返回结果是 NaN
  • x+0-0,返回结果是 -∞
  • x1,返回结果是 +0
  • x+∞,返回结果是 +∞


max ( [ value1 [ , value2 [ , … ] ] ] )

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

  • 若 没有给定参数,返回结果是 -∞
  • 若 任何值是 NaN,返回结果是 NaN
  • 按照 11.8.5 指定方式进行值比较,确定最大值,与 11.8.5 指定方式的一个不同点是在这里 +0 被看作大于 -0

max 方法的 length 属性是 2


min ( [ value1 [ , value2 [ , … ] ] ] )

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

  • 若 没有给定参数,返回结果是 +∞
  • 若 任何值是 NaN,返回结果是 NaN
  • 按照 11.8.5 指定方式进行值比较,确定最小值,与 11.8.5 指定方式的一个不同点是在这里 +0 被看作大于 -0

min 方法的 length 属性是 2


pow (x, y)

返回 xy 次方的依赖于实现的近似值。V8.png

  • yNaN,返回结果是 NaN
  • y+0,返回结果是 1,即使 xNaN
  • y-0,返回结果是 1,即使 xNaN
  • xNaNy 是 非零,返回结果是 NaN
  • abs(x) > 1y+∞,返回结果是 +∞
  • abs(x) > 1y-∞,返回结果是 +0
  • abs(x) == 1y+∞,返回结果是 NaN
  • abs(x) == 1y-∞,返回结果是 NaN
  • abs(x) < 1y+∞,返回结果是 +0
  • abs(x) < 1y-∞,返回结果是 +∞
  • x+∞y > 0,返回结果是 +∞
  • x+∞y < 0,返回结果是 +0
  • x-∞y > 0y 是 一个奇数,返回结果是 -∞
  • x-∞y > 0y 不是 一个奇数,返回结果是 +∞
  • x-∞y < 0y 是 一个奇数,返回结果是 -0
  • x-∞y < 0y 不是 一个奇数,返回结果是 +0
  • x+0y > 0,返回结果是 +0
  • x+0y < 0,返回结果是 +∞
  • x-0y > 0y 是 一个奇数,返回结果是 -0
  • x-0y > 0y 不是 一个奇数,返回结果是 +0
  • x-0y < 0y 是 一个奇数,返回结果是 -∞
  • x-0y < 0y 不是 一个奇数,返回结果是 +∞
  • x < 0x 是有限的 且 y 是有限的 且 y 不是整数,返回结果是 NaN


random ( )

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


round (x)

返回最接近 x 且为数学整数的 Number 值。如果两个整数同等接近 x,则结果是接近 +∞Number 值 。如果 x 已是整数,则返回 xV8.png

  • xNaN,返回结果是 NaN
  • x+0,返回结果是 +0
  • x-0,返回结果是 -0
  • x+∞,返回结果是 +∞
  • x-∞,返回结果是 -∞
  • x 大于 0 但小于 0.5,返回结果是 +0
  • x 小于 0 但大于或等于 -0.5,返回结果是 -0
注: Math.round(3.5) 返回 4,但 Math.round(-3.5) 返回 -3
注: 当 x-0x 小于 0 且大于等于 -0.5 时,Math.round(x) 返回 -0,而 Math.floor(x+0.5) 返回 +0。除了这种情况之外 Math.round(x) 的返回值与 Math.floor(x+0.5) 的返回值相同。


sin (x)

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

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


sqrt (x)

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

  • xNaN,返回结果是 NaN
  • x 小于 0,返回结果是 NaN
  • x+0,返回结果是 +0
  • x-0,返回结果是 -0
  • x+∞,返回结果是 +∞


tan (x)

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

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

Date 对象


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

下面的抽象操作函数用来操作时间值(15.9.1.1 定义)。注:任何情况下,如果这些函数之一的任意参数是 NaN,则结果将是 NaN


时间值和时间范围

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

ECMAScript 中测量的时间是从协调世界时 1970 年 1 月 1 日 开始的毫秒数。在时间值中闰秒是被忽略的,假设每天正好有 86,400,000 毫秒。ECMAScript 数字值可表示的所有从-9,007,199,254,740,9919,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 表示。


天数和天内时间

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

 Day(t) = floor(t / msPerDay)

其中每天的毫秒数是

 msPerDay = 86400000 V8.png

余数叫做天内时间

 TimeWithinDay(t) = t modulo msPerDay


年数

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

 DaysInYear(y) = 365 { 如果 (y modulo 4) ≠ 0 }
                 = 366 { 如果 (y modulo 4) = 0 且 (y modulo 100) ≠ 0 }
                 = 365 { 如果 (y modulo 100) = 0 且 (y modulo 400) ≠ 0 }
                 = 366 { 如果 (y modulo 400) = 0 }

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

 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) = 满足条件 TimeFromYear(y) ≤ t 的最大整数 y (接近正无穷)

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

 InLeapYear(t) = 0 { 如果 DaysInYear(YearFromTime(t)) = 365 }
               = 1 { 如果 DaysInYear(YearFromTime(t)) = 366 }


月数

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

 MonthFromTime(t) = 0 如果 0DayWithinYear(t) < 31
                    = 1 如果 31DayWithinYear (t) < 59 + InLeapYear(t)
                    = 2 如果 59 + InLeapYear(t) ≤ DayWithinYear (t) < 90 + InLeapYear(t)
                    = 3 如果 90 + InLeapYear(t) ≤ DayWithinYear (t) < 120 + InLeapYear(t)
                    = 4 如果 120 + InLeapYear(t) ≤ DayWithinYear (t) < 151 + InLeapYear(t)
                    = 5 如果 151 + InLeapYear(t) ≤ DayWithinYear (t) < 181 + InLeapYear(t)
                    = 6 如果 181 + InLeapYear(t) ≤ DayWithinYear (t) < 212 + InLeapYear(t)
                    = 7 如果 212 + InLeapYear(t) ≤ DayWithinYear (t) < 243 + InLeapYear(t)
                    = 8 如果 243 + InLeapYear(t) ≤ DayWithinYear (t) < 273 + InLeapYear(t)
                    = 9 如果 273 + InLeapYear(t) ≤ DayWithinYear (t) < 304 + InLeapYear(t)
                    = 10 如果 304 + InLeapYear(t) ≤ DayWithinYear (t) < 334 + InLeapYear(t)
                    = 11 如果 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 日,星期四。


日期数

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

 DateFromTime(t) = DayWithinYear(t) + 1 如果 MonthFromTime(t) = 0
   = DayWithinYear(t) - 30 如果 MonthFromTime(t) = 1
   = DayWithinYear(t) - 58 - InLeapYear(t) 如果 MonthFromTime(t) = 2
   = DayWithinYear(t) - 89 - InLeapYear(t) 如果 MonthFromTime(t) = 3
   = DayWithinYear(t) - 119 - InLeapYear(t) 如果 MonthFromTime(t) = 4
   = DayWithinYear(t) - 150 - InLeapYear(t) 如果 MonthFromTime(t) = 5
   = DayWithinYear(t) - 180 - InLeapYear(t) 如果 MonthFromTime(t) = 6
   = DayWithinYear(t) - 211 - InLeapYear(t) 如果 MonthFromTime(t) = 7
   = DayWithinYear(t) - 242 - InLeapYear(t) 如果 MonthFromTime(t) = 8
   = DayWithinYear(t) - 272 - InLeapYear(t) 如果 MonthFromTime(t) = 9
   = DayWithinYear(t) - 303 - InLeapYear(t) 如果 MonthFromTime(t) = 10
   = DayWithinYear(t) - 333 - InLeapYear(t) 如果 MonthFromTime(t) = 11


星期数

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

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

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


本地时区校准

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


夏令时校准

期望一个 ECMAScript 的实现确定夏令时算法。确定夏令时校准的算法 DaylightSavingTA(t),以毫秒为单位,必须只依赖下面四个项目:

(1)自本年开始以来的时间

 t - TimeFromYear(YearFromTime(t))

(2)t 是否在闰年内

 InLeapYear(t)

(3)本年第一天的星期数

 WeekDay(TimeFromYear(YearFromTime(t))

(4)地理位置。

ECMAScript的实现不应该尝试确定精确时间是否是夏令时,如果当前的夏令时算法已经被用在了时间上也只是确定夏令时会不会一直影响。这样避免了冲突,例如考虑到本地观测全年的夏令时。 如果宿主环境提供确定夏令时的功能,ECMAScript的实现自由映射有问题的年份到一个同等的年(相同的闰日和开始的星期)来为宿主环境提供夏令时信息。唯一的限制是它应该在处理相同的年时候产生相同的结果。


本地时间

从协调世界时到本地时间的转换,定义为

 LocalTime(t) = t + LocalTZA + DaylightSavingTA(t)

从本地时间到协调世界时的转换,定义为

 UTC(t) = t - LocalTZA - DaylightSavingTA(t - LocalTZA)
注: UTC(LocalTime(t)) 不一定总是等于 t


小时、分钟、秒、毫秒

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

 HourFromTime(t) = floor(t / msPerHour) modulo HoursPerDay
 MinFromTime(t) = floor(t / msPerMinute) modulo MinutesPerHour
 SecFromTime(t) = floor(t / msPerSecond) modulo SecondsPerMinute
 msFromTime(t) = t modulo msPerSecond

其中 V8.png

 HoursPerDay = 24
 MinutesPerHour = 60
 SecondsPerMinute = 60
 msPerSecond = 1000
 msPerMinute = 60000 = msPerSecond × SecondsPerMinute
 msPerHour = 3600000 = msPerMinute × MinutesPerHour


MakeTime (hour, min, sec, ms)

MakeTime 抽象操作用它的四个参数算出一个毫秒数,参数必须是 ECMAScript 数字值。此抽象操作运行如下:V8.png

  1. 如果 hour 不是有限的或 min 不是有限的或 sec 不是有限的或 ms 不是有限的,返回 NaN
  2. hToInteger(hour)。
  3. mToInteger(min)。
  4. sToInteger(sec)。
  5. milliToInteger(ms)。
  6. th × msPerHour + m × msPerMinute + s × msPerSecond + milli,执行的四则运算根据 IEEE 754 规则(这就像使用 ECMAScript 运算符 × 和 + 一样)。
  7. 返回 t


MakeDay (year, month, date)

MakeDay 抽象操作用它的三个参数算出一个天数,参数必须是 ECMAScript 数字值。此抽象操作运行如下:V8.png

  1. 如果 year 不是有限的或 month 不是有限的或 date 不是有限的,返回 NaN
  2. yToInteger(year)。
  3. mToInteger(month)。
  4. dtToInteger(date)。
  5. ymy + floor(m / 12)。
  6. mnm modulo 12
  7. 找一个满足 YearFromTime(t) == ymMonthFromTime(t) == mnDateFromTime(t) == 1t 值;但如果这些条件是不可能的(因为有些参数超出了范围),返回 NaN
  8. 返回 Day(t) + dt - 1


MakeDate (day, time)

MakeDate 抽象操作用它的两个参数算出一个毫秒数,参数必须是 ECMAScript 数字值。此抽象操作运行如下:V8.png

  1. 如果 day 不是有限的或 time 不是有限的,返回 NaN
  2. 返回 day × msPerDay + time


TimeClip (time)

TimeClip 抽象操作用它的参数算出一个毫秒数,参数必须是 ECMAScript 数字值。此抽象操作运行如下:V8.png

  1. 如果 time 不是有限的 , 返回 NaN
  2. 如果 abs(time) > 8.64×1015, 返回 NaN
  3. 返回 ToInteger(time) 和 ToInteger(time) + (+0) 之一,这依赖于实现 ( 加正一是为了将 -0 转换成 +0 )。
注: 第3步的重点是说允许实现自行选择时间值的内部表示形式,如64位有符号整数或64位浮点数。根据不同的实现,这个内部表示可能区分也可能无法区分 -0+0


日期时间字符串格式

ECMAScript 定义了一个基于简化的 ISO 8601 扩展格式的日期时间的字符串互换格式,格式为:YYYY-MM-DDTHH:mm:ss.sssZ

其中个字段为:

YYYY 是公历中年的十进制数字。
- 在字符串中直接以“-”(连字符)出现两次。
MM 是一年中的月份,从 01(一月)到 12(十二月)。
DD 是月份中的日期,从 0131
T 在字符串中直接以“T”出现,用来表明时间元素的开始。
HH 是用两个十进制数字表示的,自 午夜0点 以来的小时数。
: 在字符串中直接以“:”(冒号)出现两次。
mm 是用两个十进制数字表示的,自小时开始以来的分钟数。
ss 是用两个十进制数字表示的,自分开始以来的秒数。
. 在字符串中直接以“.”(点)出现。
sss 是用三个十进制数字表示的,自秒开始以来的毫秒数。
Z 是时区偏移量,由(“Z”(指 UTC)或 “+”“-”)和后面跟着的时间表达式 hh:mm 组成。


这个格式包括只表示日期的形式:

 YYYY
 YYYY-MM
 YYYY-MM-DD

这个格式还包括“日期时间”形式,它由上面的只表示日期的形式之一和紧跟在后面的“T”和以下时间形式之一和可选的时区偏移量组成:

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

所有数字必须是十进制的。如果缺少 MMDD 字段,用 “01” 作为它们的值。如果缺少 mmss 字段,用 “00” 作为它们的值,对于缺少的 sss“000” 作为它的值。对于缺少的时区偏移量用 “Z”

一个格式字符串里有非法值(越界以及语法错误),意味着这个格式字符串不是有效的本节描述格式的实例。

注: 由于每天的开始和结束都在午夜,俩符号 00:0024:00 可区分这样的可以是同一时间的两个午夜。这意味着两个符号 1995-02-04T24:00 和 1995-02-05T00:00 精准的指向同一时刻。
注: 不存在用来规范像 CET,EST 这样的民间时区缩写的国际标准。有时相同的缩写甚至使用不同的时区。出于这个原因,ISO 8601 和这里的格式指定数字来表示时区。


扩展的年

ECMAScript 需要能表示6位数年份(扩展的年份)的能力;协调世界时 1970年1月1日 前后分别约 285,616 年。对于表示 0年 之前或 9999年 之后的年份,ISO 8601 允许对年的表示法进行扩展,但只能在发送和接受信息的双方有事先共同约定的情况下才能扩展。在已经简化的 ECMAScript 的格式中这样扩展的年份表示法有2个额外的数字和始终存在的前缀符号 +-0年 被认为是正的,因此用 + 符号作为前缀。


作为函数调用 Date 构造器

当把 Date 作为函数来调用,而不作为构造器,它返回一个表示当前时间(协调世界时)的字符串。

注: 函数调用 Date(…) 的结果和用相同参数调用表达式 new Date(…) 创建的对象是不同的。


Date ( [ year [, month [, date [, hours [, minutes [, seconds [, ms ] ] ] ] ] ] ] )

所有参数都是可选的;接受提供的任何参数,但被完全忽略。返回一个仿佛是用表达式 (new Date()).toString() 创建的字符串,这里的 Date 是标准内置构造器,toString 是标准内置方法 Date.prototype.toStringV8.png


Date 构造器

当把 Date 作为 new 表达式的一部分来调用,它是个构造器:它初始化新创建的对象。


new Date (year, month [, date [, hours [, minutes [, seconds [, ms ] ] ] ] ] )

当用二到七个参数调用 Date 构造器,它用 yearmonth 还有(可选的)datehoursminutessecondsms 来计算时间。

新构造对象的 [[Prototype]] 内部属性设定为原始的时间原型对象,它是 Date.prototype 的初始值。

新构造对象的 [[Class]] 内部属性设定为 "Date"

新构造对象的 [[Extensible]] 内部属性设定为 ture

新构造对象的 [[PrimitiveValue]] 内部属性按照以下步骤设定:

  1. yToNumber(year)。
  2. mToNumber(month)。
  3. 如果提供了 date,则令 dtToNumber(date);否则令 dt1
  4. 如果提供了 hours,则令 hToNumber(hours);否则令 h0
  5. 如果提供了 minutes,则令 minToNumber(minutes);否则令 min0
  6. 如果提供了 seconds,则令 sToNumber(seconds);否则令 s0
  7. 如果提供了 ms,则令 milliToNumber(ms);否则令 milli0
  8. 如果 y 不是 NaN0ToInteger(y) ≤ 99,则令 yr1900+ToInteger(y);否则令 yry
  9. finalDateMakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli))。
  10. 设定新构造对象的 [[PrimitiveValue]] 内部属性为 TimeClip(UTC(finalDate))。


new Date (value)

新构造对象的 [[Prototype]] 内部属性设定为原始的时间原型对象,它是 Date.prototype 的初始值。

新构造对象的 [[Class]] 内部属性设定为 "Date"

新构造对象的 [[Extensible]] 内部属性设定为 ture

新构造对象的 [[PrimitiveValue]] 内部属性按照以下步骤设定:

  1. vToPrimitive(value)。
  2. 如果 Type(v) 是 String,则
    1. 用与 parse 方法 (15.9.4.2) 完全相同的方式将 v 解析为一个日期时间;令 V 为这个日期时间的时间值。
  3. 否则,令 VToNumber(v)。
  4. 设定新构造对象的 [[PrimitiveValue]] 内部属性为 TimeClip(V),并返回这个值。


new Date ( )

新构造对象的 [[Prototype]] 内部属性设定为原始的时间原型对象,它是 Date.prototype 的初始值。

新构造对象的 [[Class]] 内部属性设定为 "Date"

新构造对象的 [[Extensible]] 内部属性设定为 ture

新构造对象的 [[PrimitiveValue]] 内部属性设定为表示当前时间的时间值(协调世界时)。


Date 构造器的属性

Date 构造器的 [[Prototype]] 内部属性的值是 Function 原型对象

除了内部属性和 length 属性 ( 值为 7 ) 之外,Date 构造器还有以下属性:


Date.prototype

Date.prototype 的初始值是内置的 Date 原型对象V8.png

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

Date.parse (string)

parse 函数对它的参数应用 ToString 操作并将结果字符串解释为一个日期和时间;返回一个数字值,是对应这个日期时间的 UTC 时间值。字符串可解释为本地时间,UTC 时间,或某个其他时区的时间,这取决于字符串里的内容。此函数首先尝试根据日期时间字符串格式(15.9.1.15)里的规则来解析字符串的格式。如果字符串不符合这个格式此函数可回退,用任意实现定义的试探方式或日期格式。无法识别的字符串或日期时间包含非法元素值,将导致 Date.parse 返回 NaNV8.png

在所有属性都指向它们的初始值的情况下,如果 x 是一个在特定 ECMAScript 的实现里的毫秒数为零的任意 Date 对象,则在这个实现中以下所有表达式应产生相同数字值:

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

然而,表达式

 Date.parse( x.toLocaleString())

是不需要产生与前面三个表达参数相同的数字值。通常,在给定的字符串不符合日期时间字符串格式(15.9.1.15)时,Date.parse 的产生值是依赖于实现,并且在同一实现中 toStringtoUTCString 方法不能产生不符合日期时间字符串格式的字符串。


Date.UTC (year, month [, date [, hours [, minutes [, seconds [, ms ] ] ] ] ])

当用少于两个的参数调用 UTC 函数时,它的行为是依赖于实现的。当用二到七个参数调用 UTC 函数,它从 yearmonth 和(可选的)datehoursminutessecondsms 计算出日期时间。采用以下步骤:V8.png

  1. yToNumber(year)。
  2. mToNumber(month)。
  3. 如果提供了 date,则令 dtToNumber(date);否则令 dt1
  4. 如果提供了 hours,则令 hToNumber(hours);否则令 h0
  5. 如果提供了 minutes,则令 minToNumber(minutes);否则令 min0
  6. 如果提供了 seconds,则令 sToNumber(seconds);;否则令 s0
  7. 如果提供了 ms,则令 milliToNumber(ms);否则令 milli0
  8. 如果 y 不是 NaN0ToInteger(y) ≤ 99,则令 yr1900 + ToInteger(y);否则令 yry
  9. 返回 TimeClip(MakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli)))。

UTC 函数的 length 属性是 7


注: UTC 函数与 Date 构造器的不同点有:它返回一个时间值,而不是创建 Date 对象,还有它将参数解释为 UTC,而不是本地时间。

Date.now ( )

now 函数返回一个数字值,它表示调用 now 时的 UTC 日期时间的时间值。V8.png


Date 原型对象的属性

Date 原型对象自身是一个 Date 对象(其 [[Class]]"Date"),其 [[PrimitiveValue]]NaN Ms.png

Date 原型对象的 [[Prototype]] 内部属性的值是标准内置 Object 原型对象

在以下对 Date 原型对象的函数属性的描述中,短语“this Date 对象”指调用函数时的 this 值对象。除非另外说明,这些函数不是通用的;如果 this 值不是 [[Class]] 内部属性为 "Date" 的对象,则抛出一个 TypeError 异常。短语“this 时间值”指代表 this Date 对象 的时间值的数字值,它是 this Date 对象[[PrimitiveValue]] 内部属性的值。


Date.prototype.constructor

Date.prototype.constructor 的初始值是内置 Date 构造器。V8.png


Date.prototype.toString ( )

此函数返回一个字符串值。字符串中内容是依赖于实现的,但目的是用一种方便,人类可读的形式表示当前时区的时间。V8.png

注: 对毫秒数为零的任意 DatedDate.parse(d.toString())d.valueOf() 的结果相同。见 15.9.4.2

Date.prototype.toDateString ( )

此函数返回一个字符串值。字符串中内容是依赖于实现的,但目的是用一种方便,人类可读的形式表示当前时区时间的“日期”部分。V8.png


Date.prototype.toTimeString ( )

此函数返回一个字符串值。字符串中内容是依赖于实现的,但目的是用一种方便,人类可读的形式表示当前时区时间的“时间”部分。V8.png


Date.prototype.toLocaleString ( )

这个函数返回一个 String 值。String 的内容由实现决定,但它的目的是使用一种与宿主环境的语言习惯对应的人类可读形式来方便地表述当前时区中的 Date。V8.png

注: 这个函数的第一个参数可能会在此标准的未来版本中使用到;因此建议实现不要以任何目的使用这个位置参数。


Date.prototype.toLocaleDateString ( )

这个函数返回一个 String 值。String 的内容由实现决定,但它的目的是使用一种与宿主环境的语言习惯对应的人类可读形式来方便地表述当前时区中的 Date 的日期部分。V8.png

注: 这个函数的第一个参数可能会在此标准的未来版本中使用到;因此建议实现不要以任何目的使用这个位置参数。


Date.prototype.toLocaleTimeString ( )

这个函数返回一个 String 值。String 的内容由实现决定,但它的目的是使用一种与宿主环境的语言习惯对应的人类可读形式来方便地表述当前时区中的 Date 的时间部分。V8.png

注: 这个函数的第一个参数可能会在此标准的未来版本中使用到;因此建议实现不要以任何目的使用这个位置参数。


Date.prototype.valueOf ( )

valueOf 函数返回一个数字值,它是 this 时间值V8.png


Date.prototype.getTime ( )

  1. 返回 this 时间值V8.png


Date.prototype.getFullYear ( ) Note.png

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 YearFromTime(LocalTime(t))。


Date.prototype.getUTCFullYear ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 YearFromTime(t)。


Date.prototype.getMonth ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 MonthFromTime(LocalTime(t))。


Date.prototype.getUTCMonth ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 MonthFromTime(t)。


Date.prototype.getDate ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 DateFromTime(LocalTime(t))。


Date.prototype.getUTCDate ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 DateFromTime(t)。


Date.prototype.getDay ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 WeekDay(LocalTime(t))。


Date.prototype.getUTCDay ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 WeekDay(t)。


Date.prototype.getHours ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 HourFromTime(LocalTime(t))。


Date.prototype.getUTCHours ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 HourFromTime(t)。


Date.prototype.getMinutes ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 MinFromTime(LocalTime(t))。


Date.prototype.getUTCMinutes ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 MinFromTime(t)。


Date.prototype.getSeconds ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 SecFromTime(LocalTime(t))。


Date.prototype.getUTCSeconds ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 SecFromTime(t)。


Date.prototype.getMilliseconds ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 msFromTime(LocalTime(t))。


Date.prototype.getUTCMilliseconds ( )

  1. tthis 时间值V8.png
  2. 如果 tNaN,返回 NaN
  3. 返回 msFromTime(t)。


Date.prototype.getTimezoneOffset ( )

返回本地时间和 UTC 时间之间相差的分钟数。V8.png

  1. tthis 时间值
  2. 如果 tNaN,返回 NaN
  3. 返回 ( t - LocalTime(t) ) / msPerMinute )。


Date.prototype.setTime (time)

  1. vTimeClip(ToNumber(time))。V8.png
  2. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 v
  3. 返回 v


Date.prototype.setMilliseconds (ms)

  1. tLocalTime(this 时间值) 的结果。V8.png
  2. timeMakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), ToNumber(ms))。
  3. uTimeClip(UTC(MakeDate(Day(t), time)))。
  4. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 u
  5. 返回 u


Date.prototype.setUTCMilliseconds (ms)

  1. tthis 时间值V8.png
  2. timeMakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), ToNumber(ms))。
  3. vTimeClip(MakeDate(Day(t), time))。
  4. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 v
  5. 返回 v


Date.prototype.setSeconds (sec [, ms ] )

没指定 ms 参数时的行为是,仿佛 ms 被指定为调用 getMilliseconds() 的结果一样。V8.png

  1. tLocalTime( this 时间值 ) 的结果。
  2. sToNumber(sec)。
  3. 如果没指定 ms,则令 millimsFromTime(t);否则,令 milliToNumber(ms)。
  4. dateMakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), s, milli))。
  5. uTimeClip(UTC(date))。
  6. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 u
  7. 返回 u

setSeconds 方法的 length 属性是 2


Date.prototype.setUTCSeconds (sec [, ms ] )

没指定 ms 参数时的行为是,仿佛 ms 被指定为调用 getUTCMilliseconds() 的结果一样。V8.png

  1. tthis 时间值
  2. sToNumber(sec)。
  3. 如果没指定 ms,则令 millimsFromTime(t);否则,令 milli 为 ToNumber(ms)。
  4. dateMakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), s, milli))。
  5. vTimeClip(date)。
  6. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 v
  7. 返回 v

setUTCSeconds 方法的 length 属性是 2


Date.prototype.setMinutes (min [, sec [, ms ] ] )

没指定 sec 参数时的行为是,仿佛 sec 被指定为调用 getSeconds() 的结果一样。V8.png

没指定 ms 参数时的行为是,仿佛 ms 被指定为调用 getMilliseconds() 的结果一样。

  1. tLocalTime( this 时间值 ) 的结果。
  2. mToNumber(min)。
  3. 如果没指定 sec,则令 sSecFromTime(t);否则,令 sToNumber(sec)。
  4. 如果没指定 ms,则令 millimsFromTime(t);否则,令 milliToNumber(ms)。
  5. dateMakeDate(Day(t),MakeTime(HourFromTime(t), m, s, milli))。
  6. uTimeClip(UTC(date))。
  7. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 u
  8. 返回 u

setMinutes 方法的 length 属性是 3


Date.prototype.setUTCMinutes (min [, sec [, ms ] ] )

没指定 sec 参数时的行为是,仿佛 sec 被指定为调用 getUTCSeconds() 的结果一样。V8.png

没指定 ms 参数时的行为是,仿佛 ms 被指定为调用 getUTCMilliseconds() 的结果一样。

  1. tthis 时间值
  2. mToNumber(min)。
  3. 如果没指定 sec,则令 sSecFromTime(t);否则,令 sToNumber(sec)。
  4. 如果没指定 ms,则令 millimsFromTime(t);否则,令 milliToNumber(ms)。
  5. dateMakeDate(Day(t),MakeTime(HourFromTime(t), m, s, milli))。
  6. vTimeClip(date)。
  7. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 v
  8. 返回 v

setUTCMinutes 方法的 length 属性是 3


Date.prototype.setHours (hour [, min [, sec [, ms ] ] ] )

没指定 min 参数时的行为是,仿佛 min 被指定为调用 getMinutes() 的结果一样。V8.png

没指定 sec 参数时的行为是,仿佛 sec 被指定为调用 getSeconds() 的结果一样。

没指定 ms 参数时的行为是,仿佛 ms 被指定为调用 getMilliseconds() 的结果一样。

  1. tLocalTime( this 时间值 ) 的结果。
  2. hToNumber(hour)。
  3. 如果没指定 min,则令 mMinFromTime(t);否则,令 mToNumber(min)。
  4. 如果没指定 sec,则令 sSecFromTime(t);否则,令 sToNumber(sec)。
  5. 如果没指定 ms,则令 millimsFromTime(t);否则,令 milliToNumber(ms)。
  6. dateMakeDate(Day(t), MakeTime(h, m, s, milli))。
  7. uTimeClip(UTC(date))。
  8. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 u
  9. 返回 u

setHours 方法的 length 属性是 4


Date.prototype.setUTCHours (hour [, min [, sec [, ms ] ] ] )

没指定 min 参数时的行为是,仿佛 min 被指定为调用 getUTCMinutes() 的结果一样。V8.png

没指定 sec 参数时的行为是,仿佛 sec 被指定为调用 getUTCSeconds() 的结果一样。

没指定 ms 参数时的行为是,仿佛 ms 被指定为调用 getUTCMilliseconds() 的结果一样。

  1. tthis 时间值
  2. hToNumber(hour)。
  3. 如果没指定 min,则令 mMinFromTime(t);否则,令 mToNumber(min)。
  4. 如果没指定 sec,则令 sSecFromTime(t);否则,令 sToNumber(sec)。
  5. 如果没指定 ms,则令 millimsFromTime(t);否则,令 milliToNumber(ms)。
  6. dateMakeDate(Day(t), MakeTime(h, m, s, milli))。
  7. vTimeClip(date)。
  8. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 v
  9. 返回 v

setUTCHours 方法的 length 属性是 4


Date.prototype.setDate (date)

  1. tLocalTime( this 时间值 ) 的结果。V8.png
  2. dtToNumber(date)。
  3. newDateMakeDate(MakeDay(YearFromTime(t), MonthFromTime(t), dt), TimeWithinDay(t))。
  4. uTimeClip(UTC(newDate))。
  5. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 u
  6. 返回 u


Date.prototype.setUTCDate (date)

  1. tthis 时间值V8.png
  2. dtToNumber(date)。
  3. newDateMakeDate(MakeDay(YearFromTime(t), MonthFromTime(t), dt), TimeWithinDay(t))。
  4. vTimeClip(newDate)。
  5. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 v
  6. 返回 v


Date.prototype.setMonth (month [, date ] )

没指定 date 参数时的行为是,仿佛 date 被指定为调用 getDate() 的结果一样。V8.png

  1. tLocalTime( this 时间值 ) 的结果。
  2. mToNumber(month)。
  3. 如果没指定 date,则令 dtDateFromTime(t);否则,令 dtToNumber(date)。
  4. newDateMakeDate(MakeDay(YearFromTime(t), m, dt), TimeWithinDay(t))。
  5. uTimeClip(UTC(newDate))。
  6. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 u
  7. 返回 u

setMonth 方法的 length 属性是 2


Date.prototype.setUTCMonth (month [, date ] )

没指定 date 参数时的行为是,仿佛 date 被指定为调用 getUTCDate() 的结果一样。V8.png

  1. tthis 时间值
  2. mToNumber(month)。
  3. 如果没指定 date,则令 dtDateFromTime(t);否则,令 dtToNumber(date)。
  4. newDateMakeDate(MakeDay(YearFromTime(t), m, dt), TimeWithinDay(t))。
  5. vTimeClip(newDate)。
  6. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 v
  7. 返回 v

setUTCMonth 方法的 length 属性是 2


Date.prototype.setFullYear (year [, month [, date ] ] ) Note.png

没指定 month 参数时的行为是,仿佛 month 被指定为调用 getMonth() 的结果一样。V8.png

没指定 date 参数时的行为是,仿佛 date 被指定为调用 getDate() 的结果一样。

  1. tLocalTime( this 时间值 ) 的结果;但如果 this 时间值NaN,则令 t+0
  2. yToNumber(year)。
  3. 如果没指定 month,则令 mMonthFromTime(t);否则,令 mToNumber(month)。
  4. 如果没指定 date,则令 dtDateFromTime(t);否则,令 dtToNumber(date)。
  5. newDateMakeDate(MakeDay(y, m, dt), TimeWithinDay(t))。
  6. uTimeClip(UTC(newDate))。
  7. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 u
  8. 返回 u

setFullYear 方法的 length 属性是 3


Date.prototype.setUTCFullYear (year [, month [, date ] ] )

没指定 month 参数时的行为是,仿佛 month 被指定为调用 getUTCMonth() 的结果一样。V8.png

没指定 date 参数时的行为是,仿佛 date 被指定为调用 getUTCDate() 的结果一样。

  1. tthis 时间值;但如果 this 时间值NaN,则令 t+0
  2. yToNumber(year)。
  3. 如果没指定 month,则令 mMonthFromTime(t);否则,令 mToNumber(month)。
  4. 如果没指定 date,则令 dtDateFromTime(t);否则,令 dtToNumber(date)。
  5. newDateMakeDate(MakeDay(y, m, dt), TimeWithinDay(t))。
  6. vTimeClip(newDate)。
  7. 设定 this Date 对象[[PrimitiveValue]] 内部属性为 v
  8. 返回 v

setUTCFullYear 方法的 length 属性是 3


Date.prototype.toUTCString ( ) Note.png

此函数返回一个字符串值。字符串中内容是依赖于实现的,但目的是用一种方便,人类可读的形式表示 UTC 时间。V8.png

注: 此函数的目的是为日期时间产生一个比 15.9.1.15 指定的格式更易读的字符串表示。没必要选择明确的或易于机器解析的格式。如果一个实现没有一个首选的人类可读格式,建议使用 15.9.1.15 定义的格式,但用空格而不是“T”分割日期和时间元素。


Date.prototype.toISOString ( )

此函数返回一个代表 this Date 对象表示的时间实例 的字符串。字符串的格式是 15.9.1.15 定义的日期时间字符串格式。字符串中包含所有的字段。字符串表示的时区总是 UTC,用后缀 Z 标记。如果 this 对象的时间值不是有限的数字值,抛出一个 RangeError 异常。V8.png


Date.prototype.toJSON ( key )

此函数为 JSON.stringify (15.12.3) 提供 Date 对象的一个字符串表示。V8.png

当用参数 key 调用 toJSON 方法,采用以下步骤:

  1. O 为 以 this 值为参数调用 ToObject 的结果。
  2. tvToPrimitive(O, 暗示 Number)。
  3. 如果 tv 是一个数字值且不是有限的,返回 null
  4. toISO 为以 "toISOString" 为参数调用 O[[Get]] 内部方法的结果。
  5. 如果 IsCallable(toISO) 是 false,抛出一个 TypeError 异常。
  6. O 作为以 this 值并用空参数列表调用 toISO[[Call]] 内部方法,返回结果。
注: 参数是被忽略的。Question.png
注: toJSON 函数是故意设计成通用的;它不需要其 this 值必须是一个 Date 对象。因此,它可以作为方法转移到其他类型的对象上。但转移到的对象必须有 toISOString 方法。对象可自由使用参数 key 来过滤字符串化的方式。


Date 实例的属性

Date 实例从 Date 原型对象继承属性,Date 实例的 [[Class]] 内部属性值是 "Date"Date 实例还有一个 [[PrimitiveValue]] 内部属性。

[[PrimitiveValue]] 内部属性是代表 this Date 对象 的时间值。


RegExp 对象

一个 RegExp 对象包含一个正则表达式和关联的标志。

注: 正则表达式的格式和功能是以 Perl 5 程序语言的正则表达式设施为蓝本的。


模式(Patterns)

RegExp 构造器对输入模式字符串应用以下文法。如果文法无法将字符串解释为 Pattern 的一个展开形式,则发生错误。

语法:

 Pattern :: V8.png
   Disjunction
 Disjunction :: V8.png
   Alternative
   Alternative | Disjunction V8.png
 Alternative :: 
   [empty]
   Alternative Term
 Term ::
   Assertion
   Atom
   Atom Quantifier
 Assertion ::
   ^ V8.png
   $ V8.png
   \ b V8.png
   \ B V8.png
   ( ? = Disjunction ) V8.png
   ( ? ! Disjunction ) V8.png
 Quantifier ::
   QuantifierPrefix
   QuantifierPrefix ? V8.png
 QuantifierPrefix ::
   * V8.png
   + V8.png
   ? V8.png
   { DecimalDigits } V8.png
   { DecimalDigits , } V8.png
   { DecimalDigits , DecimalDigits } V8.png
 Atom ::
   PatternCharacter
   . V8.png
   \ AtomEscape
   CharacterClass V8.png
   ( Disjunction ) V8.png
   ( ? : Disjunction ) V8.png
 PatternCharacter ::
   SourceCharacter but not one of
   ^ $ \ . * + ? ( ) [ ] { } |
 AtomEscape ::
   DecimalEscape V8.png
   CharacterEscap
   CharacterClassEscape V8.png
 CharacterEscape ::
   ControlEscape
   c ControlLetter V8.png
   HexEscapeSequence V8.png
   UnicodeEscapeSequence V8.png
   IdentityEscape V8.png
 ControlEscape :: one of
   f n r t v V8.png V8.png
 ControlLetter :: one of
   a b c d e f g h i j k l m n o p q r s t u v w x y z
   A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
 IdentityEscape ::
   SourceCharacter but not IdentifierPart
   <ZWJ>
   <ZWNJ>
 DecimalEscape ::
   DecimalIntegerLiteral [lookahead ∉ DecimalDigit]
 CharacterClassEscape :: one of
   d D s S w W V8.png
 CharacterClass :: V8.png
   [ [lookahead ∉ {^}] ClassRanges ]
   [ ^ ClassRanges ] V8.png
 ClassRanges ::
   [empty]
   NonemptyClassRanges
 NonemptyClassRanges ::
   ClassAtom
   ClassAtom NonemptyClassRangesNoDash
   ClassAtom - ClassAtom ClassRanges V8.png
 NonemptyClassRangesNoDash ::
   ClassAtom
   ClassAtomNoDash NonemptyClassRangesNoDash
   ClassAtomNoDash - ClassAtom ClassRanges
 ClassAtom ::
   -
   ClassAtomNoDash
 ClassAtomNoDash :: V8.png
   SourceCharacter but not \]- 
   \ ClassEscape
 ClassEscape ::
   DecimalEscape
   b V8.png
   CharacterEscap
   CharacterClassEscape


模式语义(Pattern Semantics)

使用下面描述的过程来将一个正则表达式模式转换为一个内部程序。实现使用比下面列出的算法跟高效的算法是被鼓励的,只要结果是相同的。内部程序用作 RegExp 对象的 [[Match]] 内部属性的值。


表示法(Notation)

后面的描述用到以下变量:

  • Input,是正则表达式模式要匹配的字符串。符号 Input[n] 表示 Input 的第 n 个字符,这里的 n 可以是 0(包括)和 InputLength(不包括)之间的。
  • InputLength,是 Input 字符串里的字符数目。
  • NcapturingParens,是在模式中左捕获括号的总数(即,Atom :: ( Disjunction ) 产生式被展开的总次数)。一个左捕获括号是匹配产生式 Atom :: ( Disjunction ) 中的 终结符 ( 的任意 ( 模式字符。
  • IgnoreCase,是 RegExp 对象的 ignoreCase 属性的设定值。
  • Multiline,是 RegExp 对象的 multiline 属性的设定值。

此外,后面的描述用到以下内部数据结构:

  • CharSet,是字符的一个数学上的集合。
  • State,是一个有序对 (endIndex, captures) ,这里 endIndex 是一个整数,captures 是有 NcapturingParens 个值的内部数组。 State 用来表示正则表达式匹配算法里的局部匹配状态。endIndex 是到目前为止模式匹配的最后一个输入字符的索引值加上一,而 captures 持有捕获括号的捕获结果。captures 的第 n 个元素是一个代表第 n 个捕获括号对捕获值的字符串,或如果第 n 个捕获括号对未能达到目的,captures 的第 n 个元素是 undefined。由于回溯,很多 State 可能在匹配过程中的任何时候被使用。
  • MatchResult,值为 State 或表示匹配失败特殊记号 failure
  • Continuation 程序,是一个内部闭包(即,一些参数已经绑定了值的内部程序),它用一个 State 参数返回一个 MatchResult 结果。 如果一个内部闭包引用的变量是绑定在创建这个闭包的函数里 , 则闭包使用在创建闭包时的这些变量值。Continuation 尝试从其 State 参数给定的中间状态开始用模式的其余部分(由闭包的已绑定参数指定)匹配输入字符串。如果匹配成功,Continuation 返回最终的 State;如果匹配失败,Continuation 返回 failure
  • Matcher 程序,是一个需要两个参数:StateContinuation,的内部闭包,它返回一个 MatchResult 结果。 Matcher 尝试从其 State 参数给定的中间状态开始用模式的一个中间子模式(由闭包的已绑定参数指定)匹配输入字符串。Continuation 参数是去匹配模式中剩余部分的闭包。用模式的子模式匹配之后获得一个新 State,之后 Matcher 用新 State 去调用 Continuation 来测试模式的剩余部分是否能匹配成功。如果匹配成功,Matcher 返回 Continuation 返回的 State;如果匹配失败,Matcher 尝试用不同的可选位置重复调用 Continuation,直到 Continuation 匹配成功或用尽所有的可选位置。
  • AssertionTester 程序,是需要一个 State 参数并返回一个布尔结果的内部闭包。 AssertionTester 测试输入字符串的当前位置是否满足一个特定条件 ( 由闭包的已绑定参数指定 ) ,如果匹配了条件,返回 true;如果不匹配,返回 false
  • EscapeValue,是一个字符或一个整数。EscapeValue 用来表示 DecimalEscape 转移序列的解释结果:一个字符 ch 在转义序列里时,它被解释为字符 ch;而一个整数 n 在转义序列里时,它被解释为对第 n 个捕获括号组的反响引用。


模式(Pattern

产生式 Pattern :: Disjunction 按照以下方式解释执行 :

  1. 解释执行 Disjunction ,获得一个 Matcher m
  2. 返回一个需要两个参数的内部闭包,一个字符串 str 和一个整数 index,执行方式如下:
    1. Input 为给定的字符串 str15.10.2 中的算法都将用到此变量。
    2. InputLengthInput 的长度。15.10.2 中的算法都将用到此变量。
    3. c 为 一个 Continuation,它始终对它的任何 State 参数都返回成功匹配的 MatchResult
    4. cap 为一个有 NcapturingParensundefined 值的内部数组,索引是从 1NcapturingParens
    5. xState(index, cap)。
    6. 调用 m(x, c),并返回结果。
注: 一个模式解释执行(“编译”)为一个内部程序值。RegExp.prototype.exec 可将这个内部程序应用于一个字符串和字符串的一个偏移位,来确定从这个偏移位开始 , 模式是否能够匹配,如果能匹配,将返回捕获括号的值。15.10.2 中的算法被设计为只在编译一个模式时可抛出一个 SyntaxError 异常;反过来说,一旦模式编译成功,应用编译生成的内部程序在字符串中寻找匹配结果时不可抛出异常(除非是宿主定义的可在任何时候出现的异常,如内存不足)。


析取(Disjunction

产生式 Disjunction :: Alternative 的解释执行,是解释执行 Alternative 来获得 Matcher 并返回这个 Matcher

产生式 Disjunction :: Alternative | Disjunction 按照以下方式解释执行:

  1. 解释执行 Alternative 来获得一个 Matcher m1
  2. 解释执行 Disjunction 来获得一个 Matcher m2
  3. 返回一个需要两个参数的内部闭包 Matcher,参数分别是一个 State x 和一个 Continuation c,此内部闭包的执行方式如下:
    1. 调用 m1(x, c) 并令 r 为其结果。
    2. 如果 r 不是 failure,返回 r
    3. 调用 m2(x, c) 并返回其结果。


注: 正则表达式运算符 | 用来分隔两个选择项。模式首先尝试去匹配左侧的 Alternative(紧跟着是正则表达式的后续匹配结果);如果失败,尝试匹配右侧的 Disjunction(紧跟着是正则表达式的后续匹配结果)。如果左侧的 Alternative,右侧的 Disjunction,还有后续匹配结果,全都有可选的匹配位置,则后续匹配结果的所有可选位置是在左侧的 Alternative 移动到下一个可选位置之前确定的。如果左侧 Alternative 的可选位置被用尽了,右侧 Disjunction 试图替代左侧 Alternative。一个模式中任何被 | 跳过的捕获括号参数 undefined 值还代替字符串。因此,如:
 /a|ab/.exec("abc")

返回结果是 "a",而不是 "ab"。此外

 /((a)|(ab))((c)|(bc))/.exec("abc")

返回的数组是

 ["abc", "a", "a", undefined, "bc", undefined, "bc"]

而不是

 ["abc", "ab", undefined, "ab", "c", "c", undefined]


选择项(Alternative

产生式 Alternative :: [empty] 解释执行返回一个 Matcher,它需要两个参数,一个 State x 和 一个 Continuation c,并返回调用 c(x) 的结果。

产生式 Alternative :: Alternative Term 按照如下方式解释执行:

  1. 解释执行 Alternative 来获得一个 Matcher m1
  2. 解释执行 Term 来获得一个 Matcher m2
  3. 返回一个内部闭包 Matcher,它需要两个参数,一个 State x 和一个 Continuation c,执行方式如下 :
    1. 创建一个 Continuation d,它需要一个 State 参数 y,返回调用 m2(yc) 的结果。
    2. 调用 m1(x, d) 并返回结果。
注: 连续的 Term 试着同时去匹配连续输入字符串的连续部分。如果左侧的 Alternative ,右侧的 Term ,还有后续匹配结果,全都有可选的匹配位置,则后续匹配结果的所有可选位置是在右侧的 Term 移动到下一个可选位置之前确定的,并且则右侧的 Term 的所有可选位置是在左侧的 Alternative 移动到下一个可选位置之前确定的。


匹配项(Term

产生式 Term :: Assertion 解释执行,返回一个需要两个参数 State xContinuation c 的内部闭包 Matcher,它的执行方式如下:

  1. 解释执行 Assertion 来获得一个 AssertionTester t
  2. 调用 t(x) 并令 r 为调用结果布尔值。
  3. 如果 rfalse,返回 failure
  4. 调用 c(x) 并返回结果。

产生式 Term :: Atom 的解释执行方式是,解释执行 Atom 来获得一个 Matcher 并返回这个 Matcher

产生式 Term :: Atom Quantifier 的解释执行方式如下 :

  1. 解释执行 Atom 来获得一个 Matcher m
  2. 解释执行 Quantifier 来获得三个结果值:一个整数 min,一个整数(或 max,和一个布尔值 greedy
  3. 如果 max 是有限的 且小于 min,则抛出一个 SyntaxError 异常。
  4. parenIndex 为整个正则表达式中在此产生式 Term 展开形式左侧出现的左匹配括号的数目。这是此产生式 Term 前面展开的 Atom :: ( Disjunction ) 产生式总数与此 Term 里面的 Atom :: ( Disjunction ) 产生式总数之和。
  5. parenCount 为在展开的 Atom 产生式里的左捕获括号数目。这是 Atom 产生式里面 Atom :: ( Disjunction ) 产生式的总数。
  6. 返回一个需要两个参数 State xContinuation c 的内部闭包 Matcher,执行方式如下:
    1. 调用 RepeatMatcher(m, min, max, greedy, x, c, parenIndex, parenCount),并返回结果。

抽象操作 RepeatMatcher 需要八个参数,一个 Matcher m,一个整数 min,一个整数(或 max,一个布尔值 greedy,一个 State x,一个 Continuation c,一个整数 parenIndex,一个整数 parenCount,执行方式如下:

  1. 如果 max 是零,则调用 c(x),并返回结果。
  2. 创建需要一个 State 参数 y 的内部 Continuation 闭包 d,执行方式如下:
    1. 如果 min 是零 且 yendIndex 等于 xendIndex,则返回 failure
    2. 如果 min 是零,则令 min2 为零;否则令 min2min-1
    3. 如果 max,则令 max2;否则令 max2max-1
    4. 调用 RepeatMatcher(m, min2, max2, greedy, y, c, parenIndex, parenCount),并返回结果。
  3. capx 的捕获内部数组的一个拷贝。
  4. 对所有满足条件 parenIndex < kkparenIndex+parenCount 的整数 k,设定 cap[k] 为 undefined
  5. exendIndex
  6. xrState 值 (e, cap)。
  7. 如果 min 不是零,则调用 m(xr, d),并返回结果。
  8. 如果 greedyfalse,则
    1. z 为调用 c(x) 的结果。
    2. 如果 z 不是 failure,返回 z
    3. 调用 m(xr, d),并返回结果。
  9. z 为调用 m(xr, d) 的结果。
  10. 如果 z 不是 failure,返回 z
  11. 调用 c(x),并返回结果。


断言(Assertion

产生式 Assertion :: ^ 解释执行返回一个 AssertionTester,它需要1个参数 State x,并按如下算法执行:

  1. 使 exendIndex
  2. e = 0,返回 true
  3. Multilinefalse,返回 false
  4. Input[e - 1] 的字符为 LineTerminator,返回 true
  5. 返回 false

产生式 Assertion :: $ 解释执行返回一个 AssertionTester,它需要1个参数 State x,并按如下算法执行:

  1. 使 exendIndex
  2. e = InputLength,返回 true
  3. Multilinefalse,返回 false
  4. Input[e] 的字符为 LineTerminator,返回 true
  5. 返回 false

产生式 Assertion :: \ b 解释执行返回一个 AssertionTester,它需要1个参数 State x,并按如下算法执行:

  1. 使 exendIndex
  2. 调用 IsWordChar(e - 1),返回 Boolean 值赋给 a
  3. 调用 IsWordChar(e),返回 Boolean 值赋给 b
  4. atruebfalse,返回 true
  5. afalsebtrue,返回 true
  6. 返回 false

产生式 Assertion :: \ B 解释执行返回一个 AssertionTester,它需要1个参数 State x,并按如下算法执行:

  1. 使 exendIndex
  2. 调用 IsWordChar(e - 1),返回 Boolean 值赋给 a
  3. 调用 IsWordChar(e),返回 Boolean 值赋给 b
  4. atruebfalse,返回 false
  5. afalsebtrue,返回 false
  6. 返回 true

产生式 Assertion :: (? = Disjunction ) 按如下算法执行:

  1. 执行 Disjunction,得到 Matcher m
  2. 返回一个需要两个参数的内部闭包 Matcher,参数分别是一个 State x 和一个 Continuation c,此内部闭包的执行方式如下:
    1. 使 d 为一个Continuation,它始终对它的任何 State 参数都返回成功匹配的 MatchResult
    2. 调用 m(x, d),令 r 为其结果。
    3. rfailure,返回 failure
    4. 使 yrState
    5. 使 caprcaptures
    6. 使 xerendIndex
    7. 使 zState (xe, cap)。
    8. 调用 c(z),返回结果。

产生式 Assertion :: (? ! Disjunction ) 按如下算法执行:

  1. 执行 Disjunction,得到 Matcher m
  2. 返回一个需要两个参数的内部闭包 Matcher,参数分别是一个 State x 和一个 Continuation c,此内部闭包的执行方式如下:
    1. 使 d 为一个 Continuation,它始终对它的任何 State 参数都返回成功匹配的 MatchResult
    2. 调用 m(x, d),令 r 为其结果。
    3. 若r为failure,返回 failure
    4. 调用 c(z),返回结果。

抽象操作 IsWordChar,拥有一个整数类型的参数 e,按如下方式执行:Note.png

  1. e == -1e == InputLength,返回 false
  2. cInput[e]。
  3. c 为 以下63个字符,返回 true
    a b c d e f g h i j k l m n o p q r s t u v w x y z
    A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
    0 1 2 3 4 5 6 7 8 9 _
  4. 返回 false


量词(Quantifier

产生式 Quantifier :: QuantifierPrefix 按如下方式执行:

  1. 执行 QuantifierPrefix 得到 2 个数 minmax(或 )。
  2. 返回 minmaxtrue

产生式 Quantifier :: QuantifierPrefix ? 按如下方式执行:

  1. 执行 QuantifierPrefix 得到 2 个数 minmax(或 )。
  2. 返回 minmaxfalse

产生式 Quantifier :: * 返回 0

产生式 Quantifier :: + 返回 1

产生式 Quantifier :: ? 返回 01

产生式 Quantifier :: { DecimalDigits } 按如下方式执行:

  1. iDecimalDigits 的数学值。
  2. 返回 ii

产生式 Quantifier :: { DecimalDigits , } 按如下方式执行:

  1. iDecimalDigits 的数学值。
  2. 返回 i

产生式 Quantifier :: { DecimalDigits , DecimalDigits } 按如下方式执行:

  1. iDecimalDigits 的数学值。
  2. jDecimalDigits 的数学值。
  3. 返回 ij


原子(Atom

产生式 Atom :: PatternCharacter 执行方式如下:

  1. chPatternCharacter 表示的字符。
  2. A 为单元素 CharSet,包含 ch
  3. 调用 CharacterSetMatcher(A, false),返回 Matcher

产生式 Atom :: . 执行方式如下

  1. A 为 除去 LineTerminator 外的所有字符。
  2. 调用 CharacterSetMatcher(A, false),返回 Matcher

产生式 Atom :: \ AtomEscape 通过执行 AtomEscape 返回 Matcher

产生式 Atom :: CharacterClass 执行方式如下:

  1. 执行 CharacterClass 得到 CharSet ABoolean invert
  2. 调用 CharacterSetMatcher(A, false),返回 Matcher

产生式 Atom :: ( Disjunction ) 执行方式如下:

  1. 执行 Disjunction 得到 Matcher
  2. parenIndex 为 在整个正则表达式中从产生式展开初始化左括号时,当前展开左捕获括号的索引。parenIndex 为在产生式的 Atom 被展开之前,Atom :: ( Disjunction ) 产生式被展开的次数,加上 Atom :: ( Disjunction ) 闭合 这个 Atom 的次数。
  3. 返回一个内部闭包 Matcher,拥有2个参数:一个 State xContinuation c,执行方式如下:
    1. 创建内容闭包 Continuation d,参数为State y,并按如下方式执行:
      1. capycapture 数组的一个拷贝。
      2. xe 为 x 的 endIndex
      3. yeyendIndex
      4. sInput 从索引 xe(包括)至 ye(不包括)范围的新创建的字符串。
      5. scap[parenIndex + 1]。
      6. zState (ye, cap)。
      7. 调用 c(z),返回其结果。
    2. 执行 m(x, d),返回其结果。

产生式 Atom :: ( ? : Disjunction ) 通过执行 Disjunction 得到并返回一个 Matcher

抽象操作 CharacterSetMatcher,拥有2个参数:一个 CharSet ABoolean invert 标志,按如下方式执行:

  1. 返回一个内部闭包 Matcher,拥有2个参数:一个 State xContinuation c,执行方式如下:
    1. exendIndex
    2. e == InputLength,返回 failure
    3. ch 为字符Input[e]。
    4. ccCanonicalize(ch) 的结果。
    5. invertfalse,如果 A 中不存在 a 使得 Canonicalize(a) == cc,返回failure
    6. inverttrue,如果 A 中存在 a 使得 Canonicalize(a) == cc,返回failure
    7. capx 的内部 captures 数组。
    8. yState (e + 1, cap)。
    9. 调用 c(y),返回结果。

抽象操作 Canonicalize,拥有一个字符参数 ch,按如下方式执行:

  1. IgnoreCasefalse,返回 ch
  2. uch 转换为大写后的结果,仿佛通过调用标准内置方法 String.prototype.toUpperCase
  3. u 不含单个字符,返回 ch
  4. cuu 的字符。
  5. ch 的单位代码值 >= 128cu 的单位代码值 <= 128,返回ch
  6. 返回 cu
注: ( Disjunction ) 的括号 用来组合 Disjunction 模式,并保存匹配结果。该结果可以通过后向引用(一个非零数,前置 \ ),在一个替换字符串中的引用,或者作为正则表达式内部匹配过程的部分结果。使用(?: Disjunction )来避免括号的捕获行为。

例如,

 /(?=(a+))/.exec("baaabac")

会匹配第一个b后的空白字符串,得到:

 ["", "aaa"]

为了说明预查不会回溯,

 /(?=(a+))a*b\1/.exec("baaabac")

得到:

 ["aba", "a"]

而不是:

 ["aaaba", "a"]
注: (?! Disjunction ) 指定一个零宽正向否定预查。为了保证匹配成功,其 Disjunction 必须首先能够匹配失败,但在匹配后续字符前,其当前位置会不变。Disjunction 能含有捕获括号,但是对这些捕获分组的后向引用只在 Disjunction 中有效。在当前模式的其他位置后向引用捕获分组都会返回 undefined。因为否定预查必须满足预查失败来保证模式成功匹配。
注: (? = Disjunction ) 指定一个零宽正向预查。为了保证匹配成功,其 Disjunction 必须首先能够匹配成功,但在匹配后续字符前,其当前位置会不变。如果 Disjunction 能在当前位置以多种方式匹配,那么只会取第一次匹配的结果。不像其他正则表达式运算符,(?= 内部不会回溯(这个特殊的行为是从 Perl 继承过来的)。在 Disjunction 含有捕获括号,模式的后续字符包括后向引用时匹配结果会有影响。

例如,

 /(.*?)a(?!(a+)b\2c)\2(.*)/.exec("baaabaac")

搜索 a,其后有 na,一个 bna\2 指定)和一个 c。第二个 \2 位于负向预查模式的外部,因此它匹配 undefined,且总是成功的。整个表达式返回一个数组:

 ["baaabaac", "ba", undefined, "abaac"]

在大小写不敏感的匹配中,所有字符都在它们参与比较之前隐式转换成大写的。然而,如果把一个字符转换成大写会产生多个字符(例如 "ß"\u00DF) 转换到 "SS"),那么字符将保持不变。如果一个字符是非 ASCII 字符,但却会因大小写转换而变成 ASCII 字符,那么在匹配中它也会保持不变。这个规定阻止了一些如 \u0131\u017F 之类的 Unicode 字符 Note.png/[a-z]/i 这样的正则表达式匹配,这样的正则表达式被故意设计成只匹配 ASCII 字符。此外,倘若从 Unicode 到 ASCII 的转换被允许,将会造成 /[^\W]/i 可以匹配 abh,但无法匹配 is


转义原子(AtomEscape

产生式 AtomEscape :: DecimalEscape 执行方式如下:

  1. 执行 DecimalEscape 得到 EscapeValue E
  2. 如果 E 为一个字符,
    1. chE 的字符。
    2. A 为包含 ch 字符的单元素字符集 CharSet
    3. 调用 CharacterSetMatcher(A, false) 返回 Matcher 结果。
  3. E 必须是一个数。令 n 为该数。
  4. 如果 n = 0n > NcapturingParens,抛出 SyntaxError 异常。
  5. 返回一个内部闭包 Matcher,拥有2个参数:一个 State xContinuation c,执行方式如下:
    1. capxcaptures 内部数组。
    2. scap[n]。
    3. 如果 sundefined,调用 c(x),返回结果
    4. exendIndex
    5. lenslength
    6. fe + len
    7. 如果 f > InputLength,返回 failure
    8. 如果存在位于 0(包括)到 len(不包括)的整数 i 使得 Canonicalize(s[i]) 等于 Canonicalize(Input[e + i]),那么返回failure
    9. yState (f, cap)。
    10. 调用 c(y),返回结果。

产生式 AtomEscape :: CharacterEscap 执行方式如下:

  1. 执行 CharacterEscap 得到一个 ch 字符。
  2. A 为包含 ch 字符的单元素字符集 CharSet
  3. 调用 CharacterSetMatcher(A, false) 返回 Matcher 结果。

产生式 AtomEscape :: CharacterClassEscape 执行方式如下:

  1. 执行 CharacterClassEscape 得到一个CharSet A
  2. 调用 CharacterSetMatcher(A, false) 返回 Matcher 结果。
注: 格式 \ 后为非零数 n 的转义序列匹配捕获分组的第 n 次匹配结果。如果正则表达式少于 n 个捕获括号,会报错。如果正则表达式大于等于 n 个捕获括号,由于没有捕获到任何东西,导致第 n 个捕获分组结果为undefined,那么后向引用总是成功的。


转义字符(CharacterEscap

产生式 CharacterEscap :: ControlEscape 执行返回一个根据 表23 定义的字符:

表23 - ControlEscape 的字符值
ControlEscape 单位代码 名称 记号
t \u0009 水平制表符 <HT>
n \u000A 换行符 <LF>
v \u000B 垂直制表符 <VT>
f \u000C 换页符 <FF>
r \u000D 回车符 <CR>

产生式 CharacterEscap :: c ControlLetter 执行过程如下:

  1. ch 为通过 ControlLetter 表示的字符
  2. ich 的单位代码值
  3. ji/32 的余数
  4. 返回 j

产生式 CharacterEscap :: HexEscapeSequence 执行 HexEscapeSequence 的字符值,返回其字符结果。

产生式 CharacterEscap :: UnicodeEscapeSequence 执行 UnicodeEscapeSequence 的字符值,返回其字符结果。

产生式 CharacterEscap :: IdentityEscape 执行返回由 IdentityEscape 表示的字符。


转义十进制(DecimalEscape

产生式 DecimalEscape :: DecimalIntegerLiteral [lookahead ∉ DecimalDigit] 按如下方式执行:

  1. iDecimalIntegerLiteral 的字符值
  2. 如果 i0,返回包含一个 <NUL> 字符(Unicode 值为 0000)的 EscapeValue
  3. 返回包含整数 iEscapeValue

DecimalIntegerLiteral 的数学值在 7.8.3 节定义。

注: 如果 \ 后面是一个数字,且首位为 0,那么,该转义序列被认为是一个后向引用。如果 n 比在整个正则表达式左捕获括号个数大,那么会出错。\0 表示 <NUL> 字符,其后不能再有数字。


转义字符类(CharacterClassEscape

产生式 CharacterClassEscape :: d 执行返回包含09之间的十元素字符集。

产生式 CharacterClassEscape :: D 执行返回不包括 CharacterClassEscape :: d 的字符集。

产生式 CharacterClassEscape :: s 执行返回包含 WhiteSpaceLineTerminator 产生式右部分字符的字符集。

产生式 CharacterClassEscape :: S 执行返回不包括 CharacterClassEscape :: s 的字符集。

产生式 CharacterClassEscape :: w 执行返回包含如下63个字符的字符集:

 a b c d e f g h i j k l m n o p q r s t u v w x y z
 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
 0 1 2 3 4 5 6 7 8 9 _

产生式 CharacterClassEscape :: W 执行返回不包括 CharacterClassEscape :: w 的字符集。


字符类(CharacterClass

产生式 CharacterClass :: [ [lookahead ∉ {^}] ClassRanges ] 通过执行 ClassRanges 获得并返回这个 CharSetBoolean false

产生式 CharacterClass :: [ ^ ClassRanges ] 通过执行 ClassRanges 获得并返回这个 CharSetBoolean true


字符范围集(ClassRanges

产生式 ClassRanges :: [empty] 执行返回一个空的 CharSet

产生式 ClassRanges :: NonemptyClassRanges 通过执行 NonemptyClassRanges 获得并返回这个 CharSet


非空字符范围集(NonemptyClassRanges

产生式 NonemptyClassRanges :: ClassAtom 通过执行 ClassAtom 获得一个 CharSet 并返回这个CharSet

产生式 NonemptyClassRanges :: ClassAtom NonemptyClassRangesNoDash 按如下方式执行:

  1. 执行 ClassAtom 得到一个 CharSet A
  2. 执行 NonemptyClassRangesNoDash 得到一个 CharSet B
  3. 返回 AB 的并集。

产生式 NonemptyClassRanges :: ClassAtom - ClassAtom ClassRanges 按如下方式执行:

  1. 执行第一个 ClassAtom 得到一个 CharSet A
  2. 执行第二个 ClassAtom 得到一个 CharSet B
  3. 执行 ClassRanges 得到一个CharSet C
  4. 调用 CharacterRange(A, B),令D为其结果 CharSet
  5. 返回 DC 的并集。

抽象操作 CharacterRange,拥有2个 CharSet 参数 AB,执行方式如下:

  1. 如果 AB 为空,抛出 SyntaxError 异常。
  2. aCharSet A 的一个字符。
  3. bCharSet B 的一个字符。
  4. ia 的单位代码值。
  5. jb 的单位代码值。
  6. 如果 i > j,抛出 SyntaxError 异常。
  7. 返回位于在 ij(包括边界)之间的所有字符的字符集。


无连接符非空字符范围集(NonemptyClassRangesNoDash

产生式 NonemptyClassRangesNoDash :: ClassAtom 执行一个 ClassAtom 获取结果 CharSet 并返回。

产生式 NonemptyClassRangesNoDash :: ClassAtomNoDash NonemptyClassRangesNoDash 的结果根据以下步骤:

  1. 执行 ClassAtomNoDash 得到一个 CharSet A
  2. 执行 NonemptyClassRangesNoDash 得到一个 CharSet B
  3. 返回 CharSet ACharSet B 的并集。

产生式 NonemptyClassRangesNoDash :: ClassAtomNoDash - ClassAtom ClassRanges 按下面的步骤执行:

  1. 执行 ClassAtomNoDash 得到一个 CharSet A
  2. 执行 ClassAtom 得到一个 CharSet B
  3. 执行 ClassRanges 得到一个 CharSet C
  4. D 为调用方法 CharacterRange(A, B) 返回的 CharSet
  5. 返回 CharSet DCharSet C 的并集。
注: ClassRanges 可以扩展到单独的 ClassAtoms/ 或 两个 ClassAtom 的范围,用横杆隔开。

后面的情况中 ClassRanges 包含从第一个 ClassAtom 与第二个 ClassAtom 之间的所有字符。

如果其中一个 ClassAtom 不描述单一字符(例如\w)或如果第一个 ClassAtom 的单位代码值大于第二个 ClassAtom,则产生一个错误。
注: 如果模式语句无视大小写,那么范围两端的特征决定这个范围包含那些字符。 因此,例如这个模式语句是 /[E-F]/i 可以匹配的字符只有 EFef,如果模式语句是 /E-f/i 就可以匹配所有大小写字母和这些特殊符号:[\]^_`
注: "-" 可以作为字符处理,也可以指定一个范围。 如果它是 ClassRange 的第一个或最后一个字符、范围规范的开始或结束限制、或直接跟上一个范围规范,那么它被作为字符处理。


字符类原子(ClassAtom

产生式 ClassAtom :: - 执行返回包含单个字符 - 的字符集。

产生式 ClassAtom :: ClassAtomNoDash 通过执行 ClassAtomNoDash 获得并返回这个 CharSet


非连接符字符类原子(ClassAtomNoDash

产生式 ClassAtomNoDash :: SourceCharacter 不包括 \]- 执行返回包含由 SourceCharacter 表示的字符的单元素字符集。

产生式 ClassAtomNoDash :: \ ClassEscape 通过执行 ClassEscape 得到并返回这个 CharSet


字符类可用转义(ClassEscape

产生式 ClassEscape :: DecimalEscape 按如下方式执行:

  1. 执行 DecimalEscape 得到 EscapeValue E
  2. 如果 E 不是一个字符,抛出 SyntaxError 异常。
  3. chE 的字符。
  4. 返回包含字符 ch 的单元素 CharSet

产生式 ClassEscape :: b 执行返回包含一个 <BS> 字符(Unicode 值 0008)的字符集。

产生式 ClassEscape :: CharacterEscap 通过执行 CharacterEscap 获得一个字符 CharSet 并返回包含该字符的单元素字符集 CharSet

产生式 ClassEscape :: CharacterClassEscape 通过执行 CharacterClassEscape 获得并返回这个CharSet

注: ClassAtom 可以使用除\b\B后向引用,以外的转义序列。在 CharacterClass 中,\b 表示退格符。而,\B后向引用会报错。同样,在一个 ClassAtom 中使用后向引用会报错。


RegExp 构造器作为函数调用


RegExp(pattern, flags)

如果 pattern 是一个对象 R,其内部属性 [[Class]]"RegExp"flagsundefined,返回 R。否则,调用内置RegExp构造器,通过表达式 new RegExp(pattern, flags) 返回由该构造器构造的对象。V8.png


RegExp 构造器

RegExp作为 new 表达式一部分调用时,它是一个构造器,用来初始化一个新创建的对象。


new RegExp(pattern, flags)

如果 pattern 是一个对象且它的 [[Class]] 内部属性为 "RegExp",则令 Rpattern。接着,如果 flagsundefined,则令 P 为构造 R 时使用的 pattern,令 F 为构造 R 时使用的 flags,否则抛出TypeError异常。对于其它情况,如果 patternundefined,则令 P 为空字符串,否则令 PToString(pattern),如果 flagsundefined,则令 F 为空字符串,否则令 FToString(flags)。

如果字符 P 不满足 Pattern 句法,那么抛出 SyntaxError 异常。否则,令新构造的对象拥有内部 [[Match]] 属性,该属性通过执行(编译)字符 P 作为在 15.10.2 节描述的 Pattern

如果 F 含有除 "g""i""m" 外的任意字符,或者 F 中包括出现多次的字符,那么,抛出SyntaxError异常。 V8.png

如果 SyntaxError 异常未抛出,那么:

S 为一个字符串,其等价于 P 表示的 PatternS 中的字符按如下描述进行转义。这样,S 可能或者不会与 P 或者 Pattern 相同;然而,由执行 S 作为一个 Pattern 的内部处理程序必须和通过构造对象的内部 [[Match]] 属性的内部处理程序完全相同。

如果 Pattern 里存在字符 / 或者 \ ,那么这些字符应该被转义,以确保由 "/"S"/" 构成的字符串的 S 值有效,而且 F 能被解析(在适当的词法上下文中)为一个与构造的正则表达式行为完全相同的 RegularExpressionLiteral 。例如,如果 P"/",那么 S 应该为 "\/""\u002F",而不是 "/",因为 F 后的 /// 会被解析为一个 SingleLineComment,而不是一个 RegularExpressionLiteral。 如果 P 为空字符串,那么该规范定义为令 S"(?:)"

这个新构造对象的如下属性为数据属性,其特性在 15.10.7 中定义。各属性的 [[Value]] 值按如下方式设置:

source 属性置为 S

global 属性置为一个 Boolean 值。当 F 含有字符 g 时,为 true,否则,为 false

IgnoreCase 属性置为一个 Boolean 值。当 F 含有字符 i 时,为 true,否则,为 false

multiline 属性置为一个 Boolean 值。当 F 含有字符 m 时,为 true,否则,为 false

lastIndex 属性置为 0

其内部 [[Prototype]] 属性置为 15.10.6 中定义的内置 RegExp 原型对象。

其内部 [[Class]] 属性置为 "RegExp"

注: 如果 PatternStringLiteral,一般的转义字符替换发生在被 RegExp 处理前。如果 Pattern 必须含有 RegExp 识别的转义字符,那么当构成 StringLiteral 的内容时,为了防止被移除 \ 被移除,在 StringLiteral 中的任何 \ 必须被转义


RegExp构造器的属性

RegExp 构造器的[[Prototype]]值为内置 Function 的原型(15.3.4)。

除了内部的一些属性和 length 属性(其值为2),RegExp 构造器还有如下属性:


RegExp.prototype

RegExp.prototype的初始值为RegExp的原型(15.10.6)。

该属性有这些特性: { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。


RegExp.Prototype的属性

RegExp 的原型的内部 [[Prototype]] 属性为 Object 的原型(15.2.4)。RegExp 的原型为其本身的一个普通的正则表达式对象;它的[[Class]]"RegExp"RegExp 的原型对象的数据式属性的初始值被设置为仿佛由内置 RegExp 构造器深生成的表达式 new RegExp() 创建的对象。

'RegExp 的原型本身没有 valueOf 属性;然而,该 valueOf 属性是继承至 Object 的原型。

在作为 RegExp 原型对象的属性的如下函数描述中,"this RegExp object" 是指函数激活时 this 对象;如果 this 值不是一个对象,或者一个其内部 [[Class]] 属性值不是 "RegExp" 的对象,那么一个 TypeError 会抛出。


RegExp.prototype.constructor

RegExp.prototype.constructor 的初始值为内置 RegExp 构造器。V8.png


RegExp.prototype.exec(string)

  1. R 为该 RegExp 对象。
  2. SToString(string)的值。V8.png
  3. lengthS 的长度。
  4. lastIndex 为以参数 "lastIndex" 调用 R 的内部方法 [[Get]] 的结果。
  5. iToInteger(lastIndex) 的值。
  6. global 为以参数 "global" 调用 R 的内部方法 [[Get]] 的结果。
  7. globalfalse,则令 i = 0
  8. matchSucceededfalse
  9. matchSucceededfalse 前重复以下。
    1. i < 0 或者 i > length,则
      1. 以参数 "lastIndex"0true 调用 R 的内部方法[[Put]]
      2. 返回 null
    2. 以参数 Si 调用 R 的内部方法[[Match]]
    3. [[Match]] 返回失败,则
      1. i = i + 1
    4. 否则
      1. r 为调用 [[Match]] 的结果 State
      2. matchSucceededtrue
  10. erendIndex 值。
  11. globaltrue,
  12. 以参数 "lastIndex"etrue 调用 R 的内部方法 [[Put]]
  13. nr 的捕获数组的长度。(这跟 15.10.2.1NcapturingParens 是同一个值)
  14. A 为如同以表达式 new Array 创建的新数组,其中Array是这个名字的内置构造器。
  15. matchIndex 为匹配到的子串在整个字符串 S 中的位置。
  16. 以参数 "index",属性描述 {[[Value]]: matchIndex, [[Writable]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 true 调用 A 的内部方法 [[DefineOwnProperty]]
  17. 以参数 "input",属性描述 {{[[Value]]: S, [[Writable]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 true 调用 A 的内部方法[[DefineOwnProperty]]
  18. 以参数"length",属性描述 {[[Value]]: n + 1} 和 true 调用 A 的内部方法[[DefineOwnProperty]]
  19. matchedSubstr 为匹配到的子串(例如:S 中从 i 位置<包含>到 e 位置<不包含>的部分 )。
  20. 以参数 "0",属性描述 {{[[Value]]: matchedSubstr, [[Writable]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 true 调用 A 的内部方法[[DefineOwnProperty]]
  21. 对每一满足 I > 0In 的整数 i
    1. captureI 为第 i 个捕获数组中的元素。
    2. 以参数 ToString(i),属性描述 {[[Value]]: captureI, [[Writable]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 true 调用 A 的内部方法 [[DefineOwnProperty]]
  22. 返回 A


RegExp.prototype.test(string)

采用如下步骤:

  1. match 为在这个 RegExp 对象上使用 string 作为参数执行 RegExp.prototype.exec 的结果。V8.png
  1. 如果 match 不为 null,返回 true;否则返回 false


RegExp.prototype.toString()

返回一个 String,由 "/"RegExp 对象的 source 属性值、"/""g"(如果 global 属性为 true),"i"(如果 IgnoreCasetrue),"m"(如果 multilinetrue)通过连接组成。V8.png

注: 如果返回的字符串包含一个 RegularExpressionLiteral,那么该 RegularExpressionLiteral 用同样的方式解释执行。


RegExp实例的属性

RegExp 实例继承至 RegExp 原型对象,其 [[Class]] 内部属性值为 "RegExp"RegExp 实例也拥有一个 [[Match]] 内部属性和一个 length 属性。

内部属性 [[Match]] 的值是正则表达式对象的 Pattern 的依赖实现的表示形式。

RegExp实例还有如下属性。


source

source 属性为构成正则表达式 Pattern 的字符串。该属性拥有这些特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。


global

global 属性是一个 Boolean 值,表示正则表达式 flags 是否有 "g"。该属性拥有这些特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。


ignoreCase

ignoreCase 属性是一个 Boolean 值,表示正则表达式 flags 是否有 "i"。该属性拥有这些特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。


multiline

multiline 属性是一个 Boolean 值,表示正则表达式 flags 是否有 "m"。该属性拥有这些特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。


lastIndex

lastIndex 属性指定从何处开始下次匹配的一个字符串类型的位置索引。当需要时该值会转换为一个整型数。该属性拥有这些特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }。

注: 不同于其他 RegExp 实例内置属性,lastIndex 是可写的。

Error对象

Error 对象的实例在运行时遇到错误的情况下会被当做异常抛出。Error 对象也可以作为用户自定义异常类的基对象。


Error构造器作为函数调用

Error 被作为函数而不是构造器调用时,它创建并初始化一个新的 Error 对象。这样函数调用 Error(…) 与同样参数的对象创建表达式 new Error(…) 是等效的。


Error (message)

新构造的对象内部属性 [[Prototype]] 会被设为原本的 Error 原型对象,也就是 Error.prototype 的初始值。(15.11.3.1)V8.png

新构造的对象内部属性 [[Class]] 会被设为 "Error"

新构造的对象内部属性 [[Extensible]] 会被设为 true

如果形参 message 不是 undefined,新构造的对象本身属性 message 则被设为 ToString(message)。


Error构造器

Error 作为 new 表达式的一部分被调用时,它是一个构造器:它初始化新创建的对象。


new Error (message)

新构造的对象内部属性 [[Prototype]] 会被设为原本的 Error 原型对象,也就是 Error.prototype 的初始值。(15.11.3.1)

新构造的对象内部属性 [[Class]] 会被设为"Error"

新构造的对象内部属性 [[Extensible]] 会被设为true

如果形参 message 不是undefined,新构造的对象本身属性 message 则被设为ToString(message)。


Error构造器的属性

Error构造器的内部属性[[Prototype]]值为Function原型对象(15.3.4)。

除内部属性和 length 属性(其值为1)以外,Error构造器还有以下属性:


Error.prototype

Error.prototype 的初始值为 Error 原型对象(15.3.4)。V8.png

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


Error 原型对象的属性

Error原型对象本身是一个Error对象(其[[Class]]"Error")。

Error原型对象的内部属性 [[Prototype]] 为标准内置的 Object 原型对象


Error.prototype.constructor

Error.prototype.constructor 初始值为内置的 Error 构造器。V8.png


Error.prototype.name

Error.prototype.name 初始值为 "Error"


Error.prototype.message

Error.prototype.message 初始值为空字符串。V8.png


Error.prototype.toString ( )

执行以下步骤

  1. Othis
  2. 如果 Type(O) 不是对象,抛出一个TypeError异常。V8.png
  3. name 为以"name"为参数调用 O[[Get]] 内置方法的结果。
  4. 如果 nameundefined, 令 name"Error";否则令 nameToString(name)。
  5. msg 为以"message"为参数调用 O[[Get]] 内置方法的结果。
  6. 如果 msgundefined,令 msg 为空字符串;否则令 msgToString(msg)。
  7. 如果 namemsg 都是空字符串,返回"Error"
  8. 如果 name 为空字符串,返回 msg
  9. 如果 msg 为空字符串,返回 name
  10. 返回拼接 name、":"、一个空格字符,以及 msg 的结果。


Error实例的属性

Error 实例从 Error 原型对象继承属性,且它们的内部属性 [[Class]] 值为"Error"Error实例没有特殊属性。


用于本标准的内部错误类型

以下原生 Error 对象之一会在运行时错误发生时被抛出。所有这些对象共享同样的结构,如 15.11.7 所述。


EvalError

本规范现在已经不再使用这个异常,这个对象保留用于跟规范之前版本的兼容性。


RangeError

表示一个数值超出了允许的范围,见 15.4.2.2, 15.4.5.1, 15.7.4.2, 15.7.4.5, 15.7.4.6, 15.7.4.7, 15.9.5.43


ReferenceError

表示一个不正确的引用值被检测到。见 8.7.1, 8.7.2, 10.2.1, 10.2.1.1.4, 10.2.1.2.4, 11.13.1


SyntaxError

表示一个解析错误发生。见 11.1.5, 11.3.1, 11.3.2, 11.4.1, 11.4.4, 11.4.5, 11.13.1, 11.13.2, 12.2.1, 12.10.1, 12.14.1, 13.1, 15.1.2.1, 15.3.2.1, 15.10.2.2, 15.10.2.5, 15.10.2.9, 15.10.2.15, 15.10.2.19, 15.10.4.1, 15.12.2


TypeError

表示一个操作数的真实类型与期望类型不符。见 8.6.2, 8.7.2, 8.10.5, 8.12.5, 8.12.7, 8.12.8, 8.12.9, 9.9, 9.10, 10.2.1, 10.2.1.1.3, 10.6, 11.2.2, 11.2.3, 11.4.1, 11.8.6, 11.8.7, 11.3.1, 13.2, 13.2.3, 15, 15.2.3.2, 15.2.3.3, 15.2.3.4, 15.2.3.5, 15.2.3.6, 15.2.3.7, 15.2.3.8, 15.2.3.9, 15.9.5.44, 15.2.3.11, 15.2.3.12, 15.2.3.13, 15.2.3.14, 15.2.4.3, 15.3.4.2, 15.3.4.3, 15.3.4.4, 15.3.4.5, 15.3.4.5.2, 15.3.4.5.3, 15.3.5, 15.3.5.3, 15.3.5.4, 15.4.4.3, 15.4.4.11, 15.4.4.16, 15.4.4.17, 11.4.1, 15.4.4.19, 15.4.4.20, 15.4.4.21, 15.4.4.22, 15.4.5.1, 15.5.4.2, 15.5.4.3, 15.6.4.2, 15.6.4.3, 15.7.4, 15.7.4.2, 15.7.4.4, 15.7.4.8, 15.9.5, 15.9.5.44, 15.10.4.1, 15.10.6, 15.11.4.4, 15.12.3


URIError

表示全局 URI 处理函数被以不符合其定义的方式使用。见 15.1.3


NativeError对象结构

当 ECMAScript 实现探测到一个运行时错误时,它抛出一个 15.11.6 所定义的 NativeError 对象的实例。每个这些对象都有如下所述结构,不同仅仅是在 name 属性中以构造器名称替换掉 NativeError,以及原型对象由实现自定义的 message 属性。

对于每个错误对象,定义中到 NativeError 的引用应当用 15.11.6 中具体的对象名替换。V8.png


NativeError构造器作为函数调用

NativeError 被作为函数而不是构造器调用时,它创建并初始化一个新的 NativeError 对象。这样函数调用 NativeError(…) 与同样参数的对象创建表达式 new NativeError(…) 是等效的。


NativeError (message)

新构造的对象内部属性 [[Prototype]] 会被设为这一错误构造器附带的原型对象。(15.11.3.1

新构造的对象内部属性 [[Class]] 会被设为 "Error"

新构造的对象内部属性 [[Extensible]] 会被设为 true

如果形参 message 不是 undefined,新构造的对象本身属性 message 则被设为ToString(message)。


NativeError构造器

NativeError 作为 new 表达式的一部分被调用时,它是一个构造器:它初始化新创建的对象。


New NativeError (message)

新构造的对象内部属性[[Prototype]]会被设为这一错误构造器附带的原型对象。(15.11.3.1)

新构造的对象内部属性[[Class]]会被设为 "Error"

新构造的对象内部属性[[Extensible]]会被设为 true

如果形参 message 不是undefined,新构造的对象本身属性 message 则被设为ToString(message)。


NativeError构造器的属性

NativeError构造器的内部属性[[Prototype]]值为Function原型对象(15.3.4)。

除内部属性和 length 属性(其值为1)以外,Error构造器还有以下属性:


NativeError.prototype

NativeError.prototype 的初始值为一个 Error(15.11.4)。

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


NativeError原型对象的属性

每个 NativeError[[Prototype]] 的初始值为一个 Error(其[[Class]]"Error")。

NativeError 原型对象的内部属性 [[Prototype]] 为标准内置的 Error 对象(15.2.4)。


NativeError.prototype.constructor

对于特定的 NativeError,其 Error.prototype.constructor 初始值为 NativeError 构造器本身。


NativeError.prototype.name

对于特定的 NativeError,Error.prototype.name 初始值为构造器的名字。


NativeError.prototype.message

对于特定的 NativeError,NativeError.prototype.message 初始值为空字符串。


NativeError 实例的属性

NativeError 实例从 NativeError 原型对象继承属性,且它们的内部属性 [[Class]] 值为 "Error"Error 实例没有特殊属性。


JSON 对象

JSON 对象是一个单一的对象,它包含两个函数,parsestringify,是用于解析和构造 JSON 文本的。JSON 数据的交换格式在 RFC4627 里进行了描述。本规范里面的 JSON 交换格式会使用 RFC4627 里所描述的,以下两点除外:

  • ECMAScript JSON 文法中的顶级 JSONText 产生式是由 JSONValue 构成,而不是 RFC4627 中限制成的 JSONObject 或者 JSONArray
  • 确认 JSON.parseJSON.stringify 的实现,它们必须准确的支持本规范描述的交换格式,而不允许对格式进行删除或扩展。这一点要区别于 RFC4627,它允许 JSON 解析器接受 non-JSON 的格式和扩展。

JSON 对象内部属性 [[Prototype]] 的值是标准内建的 Object 原型对象(15.2.4)。内部属性 [[Class]] 的值是 "JSON"。内部属性 [[Extensible]] 的值设置为 true

JSON 对象没有内部属性 [[Construct]];不能把 JSON 对象当作构造器来使用 new 操作符。

JSON 对象没有内部属性 [[Call]];不能把 JSON 对象当作函数来调用。


JSON 语法

JSON.stringify 会产生一个符合 JSON 语法的字符串。JSON.parse 接受的是一个符合 JSON 语法的字符串。


JSON 词法

类似于 ECMAScript 源文本,JSON 是由一系列符合 SourceCharacter 规则的字符构成的。JSON 词法定义的 Token 使得 JSON 文本类似于 ECMAScript 词法定义的 Token 得到的 ECMAScript 源文本。JSON 词法仅能识别由 JSONWhiteSpace 产生式得到的空白字符。在语法上,所有非终止符均不是由 "JSON" 字符开始,而是由 ECMAScript 词法产生式定义的。

语法

   JSONWhiteSpace :: Note.png
       <TAB>
       <CR>
       <LF>
       <SP>
   JSONString ::
       " JSONStringCharactersopt "
   JSONStringCharacters ::
       JSONStringCharacter JSONStringCharactersopt
   JSONStringCharacter ::
       SourceCharacter but not " or \ U+0000 or through U+001F
       \ JSONEscapeSequence
   JSONEscapeSequence ::
       JSONEscapeCharacter
       UnicodeEscapeSequence
   JSONEscapeCharacter :: 以下之一 
       " / \ b f n r t
   JSONNumber ::
       -opt DecimalIntegerLiteral JSONFractionopt ExponentPartopt
   JSONFraction ::
       . DecimalDigits
   JSONNullLiteral ::
       NullLiteral
   JSONBooleanLiteral ::
       BooleanLiteral


JSON 句法

根据 JSON 词法定义的 TokenJSON 句法定义了一个合法的 JSON 文本。语法的目标符号是 JSONText

语法

   JSONText :
       JSONValue
   JSONValue :
       JSONNullLiteral
       JSONBooleanLiteral
       JSONObject
       JSONArray
       JSONString
       JSONNumber
   JSONObject :
       { }
       { JSONMemberList }
   JSONMember :
       JSONString : JSONValue
   JSONMemberList :
       JSONMember
       JSONMemberList , JSONMember
   JSONArray :
       [ ]
       [ JSONElementList ]
   JSONElementList :
       JSONValue
       JSONElementList , JSONValue


parse ( text [ , reviver ] )

parse 函数解析一段 JSON 文本(JSON 格式字符串),生成一个 ECMAScript 值。JSON 格式是ECMAScript直接量的受限模式。JSON 对象可以被理解为 ECMAScript 对象。JSON 数组可以被理解为 ECMAScript 数组。JSON 的字符串、数字、布尔值以及 null 可以被认为是 ECMAScript 字符串、数字、布尔值以及 nullJSON 使用受限更多的空白字符集合,并且允许 Unicode 码点 U+2028U+2029直 接出现在 JSONString 直接量当中而无需使用转义序列。解析流程与 11.1.411.1.5 一样,但是由 JSON 语法限定。

可选参数 reviver 是一个接受两个参数的函数(keyvalue)。它可以过滤和转换结果。它在每个 key/value 对产生时被调用,它的返回值可以用于替代原本的值。如果它原样返回接收到的,那么结构不会被改变。如果它返回 undefined,那么属性会被从结果中删除。

  1. JTextToString(text)。V8.png
  2. 15.12.1 所述语法解析 JText。如果 JText 不能以 JSON 语法解析成 JSONText,则抛出 SyntaxError 异常。
  3. unfiltered 为按 ECMAScript 程序(但是用 JSONString 替换 StringLiteral)解析和执行 JText 的结果。注因 JText 符合JSON语法,这个结果要么是原始值类型要么是 inlineArrayLiteral 或者 ObjectLiteral 所定义的对象。
  4. IsCallable(reviver) 为 true
    1. root 为由表达式 new Object() 创建的新对象,其中 Object 是以 Object 为名的标准内置的构造器。
    2. 以空字符串和属性描述 {[[Value]]: unfiltered, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 为参数调用 root[[DefineOwnProperty]] 内置方法。
    3. 返回传入 root 和空字符串为参数调用抽象操作 Walk 的结果,抽象操作 Walk 如下文所定义。V8.png
  5. 否则,返回 unfilteredV8.png

抽象操作 Walk 是一个递归的抽象操作,它接受两个参数:一个 holder 对象和一个表示该对象的属性名的 String nameWalk 使用最开始被传入 parse 函数的 reviver 的值。

  1. val 为以参数 name 调用 holder[[Get]] 内部方法的结果。
  2. val 为对象,则
    1. val[[Class]] 内部属性为 "Array"
      1. I0
      2. len 为以参数 "length" 调用 val[[Get]] 内部方法的结果。
      3. I < len 时重复
        1. newElement 为调用抽象操作 Walk 的结果,传入 valToString(I) 为参数。
        2. newElementundefined,则
          1. ToString(I) 和 false 做参数,调用 val 的内部方法 [[Delete]]
          2. 否则,以ToString(I),属性描述 {[[Value]]: newElement, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 以及 false 做参数调用 val 的内部方法[[DefineOwnProperty]]
        3. I1
    2. 否则
      1. keys 为包含 val 所有的具有 [[Enumerable]] 特征的属性名 String 值的内部类型 List。字符串的顺序应当与内置函数 Object.keys 一致。
      2. 对每个 keys 中的字符串 P 做以下操作
        1. newElement 为调用抽象操作 Walk 的结果,传入 valP 为参数。
        2. newElementundefined,则
          1. Pfalse 做参数,调用 val 的内部方法 [[Delete]]V8.png
          2. 否则,以 P,属性描述{[[Value]]: newElement, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 做参数调用调用 val 的内部方法 [[DefineOwnProperty]]
  3. 返回传入 holder 作为 this 值以及以 nameval 构成的参数列表调用 reviver[[Call]]内部属性的结果。

实现不允许更改 JSON.parse 的实现以扩展 JSON 语法。如果一个实现想要支持更改或者扩展过的 JSON 交换格式它必须以定义一个不同的 parse 函数的方式做这件事。

注:在对象中存在同名字符串的情况下,同一 key 的值会被按照文本顺序覆盖掉。Note.png


stringify ( value [ , replacer [ , space ] ] )

stringify 函数返回一个 JSON 格式的字符串,用以表示一个ECMAScript值。它可以接受三个参数。第一个参数是必选的。value 参数是一个ECMAScript 值,它通常是对象或者数组,尽管它也可以是 StringBooleanNumber 或者是 null。可选的 replacer 参数要么是个可以修改对象和数组字符串化的方式的函数,要么是个扮演选择对象字符串化的属性的白名单这样的角色的 StringNumber 组成的数组。可选的 space 参数是一个 String 或者 Number,可以允许结果中插入空白符以改善人类可读性。 V8.png V8.png

以下为字符串化一对象的步骤:

  1. stack 为空 List
  2. indent 为空 String
  3. PropertyListReplacerFunctionundefined
  4. Type(replacer) 为 Object,则
    1. IsCallable(replacer) 为 true,则
      1. ReplacerFunctionreplacer
    2. 否则若 replacer 的内部属性 [[Class]]"Array",则
      1. PropertyList 为一空内部类型 List
      2. 对于所有名是数组下标的 replacer 的属性 v。以数组下标递增顺序枚举属性
        1. itemundefined
        2. Type(v) 为 String 则令 itemv
        3. 否则若 Type(v) 为 Number 则令 itemToString(v)。
        4. 否则若 Type(v) 为 Object 则,
          1. v[[Class]] 内部属性为 "String""Number" 则令 itemToString(v)。
        5. item 不是 undefineditem 不是 PropertyList 的元素。
          1. item 添加到 PropertyList 中。
  5. Type(space) 为 Object 则,
    1. space[[Class]] 内部属性为 "Number" 则,
      1. spaceToNumber(space)。V8.png
    2. 否则若 space[[Class]] 内部属性为 "String" 则,
      1. spaceToString(space)。V8.png
  6. Type(space) 为 Number
    1. spacemin(10, ToInteger(space))。
    2. gap 为一包含 space 个空格的 String。这将会是空 String 加入 space 小于1
  7. 否则若 Type(space) 为String
    1. space 中字符个数为 10 或者更小,设 gapspace,否则设 gap 为包含前 10space 中字符的字符串。
  8. 否则设 gap 为空 String
  9. wrapper 为一个如同以表达式 new Object() 创建的新对象,其中 Object 是这个名字的标准内置构造器。
  10. 以参数空 String,属性描述{[[Value]]: value, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 调用 wrapper[[DefineOwnProperty]]内部方法。
  11. 返回以空 Stringwrapper 调用抽象方法 Str 的结果。


抽象操作 Str(key, holder) 可以访问调用它的 stringify 方法中的 ReplacerFunction。其算法如下:V8.png

  1. value 为以 key 为参数调用 holder 的内部方法[[Get]]
  2. Type(value) 为 Object,则 Note.png V8.png
    1. toJSON 为以 "toJSON" 为参数调用 value 的内部方法 [[Get]]
    2. IsCallable(toJSON) 为 true
      1. value 为以调用 toJSON 的内部方法 [[Call]] 的结果,传入 valuethis值以及由 key 构成的参数列表。
  3. ReplacerFunction 不为 undefined,则
    1. value 为以调用 ReplacerFunction 的内部方法 [[Call]] 的结果,传入 holderthis 值以及由 keyvalue 构成的参数列表。
  4. Type(value) 为 Object 则,
    1. value[[Class]] 内部属性为 "Number" 则,
      1. valueToNumber(value)。
    2. 否则若 value[[Class]] 内部属性为 "String" 则,
      1. valueToString(value)
    3. 否则若 value[[Class]] 内部属性为 "Boolean" 则,
      1. valuevalue[[PrimitiveValue]] 内部属性值
  5. valuenull 则 返回 "null"
  6. valuetrue 则 返回 "true"
  7. valuefalse 则 返回 "false"
  8. Type(value) 为 String,则返回以value调用Quote抽象操作的结果。
  9. Type(value) 为 Number
    1. value 是有限的数字则 返回 ToString(value)。
    2. 否则,返回 "null"
  10. Type(value) 为 ObjectIsCallable(value) 为 false
    1. value[[Class]]内部属性为 "Array"
      1. 返回以 value 为参数调用抽象方法 JA 的结果。
    2. 否则,返回以 value 为参数调用抽象方法 JO 的结果。
  11. 返回 undefined


抽象操作 Quote(value) 将一个 String 值封装在双引号中,并且对其中的字符转义。V8.png

  1. product 为双引号字符。
  2. value 中的每一个字符 C
    1. C 为双引号字符或者反斜杠字符
      1. productproduct 和反斜杠连接的结果。
      2. productproductC 的连接。
    2. 否则若 C 为退格符、换页符、换行符、回车符或制表符
      1. productproduct 与反斜杠字符的连接。
      2. abbrev 为如下表所示 C 对应的字符:
        退格符 "b"
        换页符 "f"
        换行符 "n"
        回车符 "r"
        制表符 "t"
      3. productproductabbrev 的连接。
    3. 否则若 C 为代码值小于空白字符 Note.png 的控制字符。
      1. productproduct 与反斜杠字符的连接。
      2. productproduct"u" 的连接。
      3. hex 为转换 C 代码值按十六进制转换到四位字符串的结果。
      4. productproducthex 的连接。
    4. 否则
      1. productproductC 的连接。
  3. productproduct 与双引号字符的连接。
  4. 返回 product


抽象操作 JO(value) 序列化一个对象,它可以访问调用它的方法中的 stackindentgapPropertyListReplacerFunction 以及 space Bug.pngV8.png

  1. stack 包含 value,则抛出一个TypeError,因为对象结构中存在循环。 Question.png
  2. value 添加到 stackQuestion.png
  3. stepbackindent
  4. indentindentgap 的连接。
  5. PropertyList 不为 undefined
    1. KPropertyList
  6. 否则
    1. Kvalue 上所有 [[Enumerable]] 特性为 true 的自身属性名构成的内部字符串列表。其顺序应该和 Object.keys 标准内置函数得到的顺序相同。
  7. partial 为空 List
  8. 对于 K 的每一个元素 P
    1. strP 为以 Pvalue 为参数调用抽象操作 Str 的结果。
    2. strP 没有被定义
      1. member 为以 P 为参数调用抽象操作P的结果。
      2. membermember 与冒号字符的连接。
      3. gap 不为空 String
        1. membermember 与空格字符 Bug.png 的连接。
      4. membermemberstrP 的连接。
      5. member 添加到 partial
  9. partialempty,则
    1. final"{}"
  10. 否则
    1. gap 为空 String
      1. properties 为一个连接所有 partial 中的字符串而成的字符串,键值对之间用逗号分隔。第一个字符串之前和最后一个字符串之后没有逗号。
      2. final 为连接 "{"properties、和 "}" 的结果。
    2. 否则 gap 不是空 String
      1. separator 为连接 逗号字符,换行字符以及 indent 而成的字符串。
      2. properties 为一个连接所有 partial 中的字符串而成的字符串,键值对之间用 separator 分隔。第一个字符串之前和最后一个字符串之后没有 separator
      3. final 为连接 "{"、换行符、indentproperties、换行符、stepback"}" 的结果。
  11. 移除 stack 中的最后一个元素。 Question.png
  12. indentstepback
  13. 返回 final


抽象操作 JA(value) 序列化一个数组。它可以访问调用它的 stringify 方法中的 stackindentgapPropertyListReplacerFunction 以及 space Bug.png。数组的表示中仅包扩零到 array.length - 1的区间。命名的属性将会被从字符串化操作中排除。数组字符串化成开头的左方括号,逗号分隔的元素,以及结束的右方括号。V8.png

  1. stack 包含 value,则抛出一个TypeError,因为对象结构中存在循环。 Question.png
  2. value 添加到 stackQuestion.png
  3. stepbackindent
  4. indentindentgap 的连接。
  5. partial 为空 List
  6. len 为以 "length" 为参数调用 value 的内部方法 [[Get]]
  7. index0
  8. index < len 时重复以下
    1. strP 为传入 ToString(index) 与 value 作为参数调用抽象方法 Str 的结果。
    2. strPundefined
      1. 添加 nullpartial
    3. 否则
      1. 添加 strPpartial
    4. 使 index 增加1
  9. partial 为空,则
    1. final"[]"
  10. 否则
    1. gap 为空 String
      1. properties 为为一个连接所有 partial 中的字符串而成的字符串,键值对之间用逗号分隔。第一个字符串之前和最后一个字符串之后没有逗号。
      2. final 为连接 "["properties"]" 的结果。
    2. 否则
      1. separator 为逗号字符,换行字符以及 indent 而成的字符串。
      2. properties 为一个连接所有 partial 中的字符串而成的字符串,键值对之间用 separator 分隔。第一个字符串之前和最后一个字符串之后没有 separator
      3. final 为连接 "["、换行符、indentproperties、换行符、stepback"]" 的结果。
  11. 移除 stack 中的最后一个元素。 Question.png
  12. indentstepback
  13. 返回 final
注: JSON 结构允许任何深度的嵌套,但是不能够循环引用。若 value 是或者包含了一个循环结构,则 stringify 函数必须抛出一个 TypeError 异常。以下是一个不能够被字符串化的值的例子:
a = [];
a[0] = a;
my_text = JSON.stringify(a); // This must throw an TypeError.
注:符号式简单值按以下方式表示:
  1. null 值在 JSON 文本中表示为 String null
  2. undefined 值不出现。
  3. true 值在 JSON 文本中表示为 String true
  4. false 值在 JSON 文本中表示为 String false
注: 字符串值用双引号括起。字符 "\ 会被转义成带 \ 前缀的。控制字符用转义序列 \uHHHH 替换,或者使用简略形式 \b(退格符)、\f(换页符)、\n(换行符)、\r(回车符)、\t(制表符)。
注: 有穷的数字按照调用 ToString(number) 字符串化。NaN 和不论正负的 Infinity 都表示为字符串 null
注: 没有 JSON 表示的值(如 undefined 和函数)不会产生字符串。而是会产生 undefined 值。在数组中这些值表示为字符串 null。在对象中不能表示的值会导致属性被排除在字符串化过程之外。
注: 对象表示为开头的左大括号跟着零个或者多个属性,以逗号分隔,以右大括号结束。属性是用用来表示 key 或者属性名的引号引起的字符串,冒号然后是字符串化的属性值。数组表示为开头的左方括号,后跟零个或者多个值,以逗号分隔,以右方括号结束。