Warning:
This wiki has been archived and is now read-only.
View source for ES5/标准 ECMAScript 内置对象

Jump to: navigation, search
You do not have permission to edit this page, for the following reason:
The action you have requested is limited to users in one of the groups: Users, 106.
You can view and copy the source of this page.
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15}}

ECMAScript 代码运行时会有一些可用的内置对象。一是作为执行程序[[ES5/execution#lexical-environment|词法环境]]的一部分的[[#the-global-object|全局对象]]。其他的可通过全局对象的初始属性访问。

除非另外指明，如果内置对象拥有 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部属性，那么它的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性是 "'''Function'''"，如果没有 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部属性，那么它的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性是 "'''Object'''"。除非另外指明，内置对象的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性的初始值是 '''true'''。

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

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

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

{{note| 实现为了给内置函数集合增添一些额外功能而添加新函数是被鼓励的，而不是为现有函数增加新参数。}}

所有内置函数和内置构造器都有作为其 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内置属性值的 '''Function''' 原型对象，它的初始值是 [[#x15.3.4|Function.prototype]] 表达式的值。

除非另外指定，每一个内置原型对象都有作为其 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性的 '''Object''' 原型对象，它的初始值是表达式 [[#x15.2.4|Object.prototype]] 的值，Object 自己的原型对象例外。{{extra note||Object的原型对象的[[Prototype]]内置属性必须为null，否则将产生原型链递归引用的问题。}}

除非另外指明了特定函数的描述，否则本章描述的内置函数中不存在不是构造器而要实现 [[ES5/types#Construct|<nowiki>[[Construct]]</nowiki>]] 内部方法的内置函数。除非另外指明了特定函数的描述，否则本章描述的内置函数都没有 '''prototype''' 属性。 {{extra note||注意这里说的“内置函数”指的是decodeURI、parseInt等之类的函数，不指内置构造器作为函数方式调用的情况。这里说的是prototype属性，不是[[Prototype]]内置属性。}}

本章通常描述构造器的 “作为函数调用” 和 “用 '''new''' 表达式调用” 有不同行为。“作为函数调用” 的行为对应于调用构造器的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法，“用 '''new''' 表达式调用”的行为对应于调用构造器的 [[ES5/types#Construct|<nowiki>[[Construct]]</nowiki>]] 内部方法。

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

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

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


== {{anchor|x15.1}}全局对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.1}}

唯一的全局对象在控制进入任何[[ES5/execution#execution-contexts|执行环境]]前被创建。

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

全局对象没有 [[ES5/types#Construct|<nowiki>[[Construct]]</nowiki>]] 内部属性 ; 全局对象不可能当做构造器用 '''new''' 运算符调用。

全局对象没有 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部属性，全局对象不可能当做函数来调用。

全局对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 和 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性值是依赖于实现的。

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


=== {{anchor|x15.1.1}}全局对象的值属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.1}}

===={{anchor|x15.1.1.1}}NaN====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.1.1}}

'''NaN''' 的值是 '''NaN'''（见 [[ES5/types#x8.5|8.5]]）。这个属性拥有特性 <nowiki>{ [[Writable]]: </nowiki>'''false'''<nowiki>, [[Enumerable]]: </nowiki>'''false'''<nowiki>, [[Configurable]]: </nowiki>'''false'''<nowiki> }</nowiki>。{{v8|https://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13151#190|Setup Property Descriptor}}

==== {{anchor|x15.1.1.2}}Infinity ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.1.2}}

'''Infinity''' 的值是 '''+∞'''（见 [[ES5/types#x8.5|8.5]]）。这个属性拥有特性 <nowiki>{ [[Writable]]: </nowiki>'''false'''<nowiki>, [[Enumerable]]: </nowiki>'''false'''<nowiki>, [[Configurable]]: </nowiki>'''false'''<nowiki> }</nowiki>。
{{v8|https://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13151#193|Setup Property Descriptor}}

==== {{anchor|x15.1.1.3}}undefined ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.1.3}}

'''undefined''' 的值是 '''undefined'''（见 [[ES5/types#x8.1|8.1]]）。这个属性拥有特性 <<nowiki>{ [[Writable]]: </nowiki>'''false'''<nowiki>, [[Enumerable]]: </nowiki>'''false'''<nowiki>, [[Configurable]]: </nowiki>'''false'''<nowiki> }</nowiki>。
{{v8|https://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13151#196|Setup Property Descriptor}}


=== {{anchor|x15.1.2}}全局对象的函数属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.2}}

==== {{anchor|x15.1.2.1}}eval (x) ====
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.1/15.1.2/15.1.2.1}}

当用一个参数 <var>x</var> 调用 '''eval''' 函数，采用如下步骤：

# 如果 [[ES5/types#Type|Type]](<var>x</var>) 不是 '''String'''，返回 <var>x</var>。
# 令 <var>prog</var> 为 ECMAScript 代码，它是将 <var>x</var> 作为一个程序解析的结果。如果解析失败，抛出一个 '''SyntaxError''' 异常 ( 见 [[ES5#x16|16 章]] )。
# 令 <var>evalCtx</var> 为给 '''eval''' 代码 <var>prog</var> 建立的新执行环境 ([[ES5/execution#x10.4.2|10.4.2]])。{{v8|https://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r{{=}}13151#11095|Switch Context}}{{v8|https://code.google.com/p/v8/source/browse/trunk/src/parser.cc?r{{=}}13151#1064|Create New Scope}}
# 令 <var>result</var> 为解释执行程序 <var>prog</var> 的结果。
# 退出执行环境 <var>evalCtx</var>，恢复到之前的执行环境。
# 如果 <var>result</var>.'''type''' 是 '''normal''' 并且其完结类型值是 <var>V</var>，则返回 <var>V</var> 值。
# 如果 <var>result</var>.'''type''' 是 '''normal''' 并且其完结类型值是 '''empty'''，则返回 '''undefined''' 值。
# 否则，<var>result</var>.'''type''' 必定是 '''throw'''。将 <var>result</var>.'''value''' 作为异常抛出。

===== {{anchor|x15.1.2.1.1}}直接调用 Eval =====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.2.1.1}}

一个 '''eval''' 函数的直接调用是表示为符合以下两个条件的 [[ES5/expressions#CallExpression|CallExpression]]：

解释执行 [[ES5/expressions#CallExpression|CallExpression]] 中的 [[ES5/expressions#MemberExpression|MemberExpression]] 的结果是个[[ES5/types#x8.7|引用]]，这个引用拥有一个[[ES5/execution#x10.2.1|环境记录项]]作为其基值，并且这个引用的名称是 '''"eval"'''。{{extra note||名称都必须匹配，eval放入其它变量后再调用就不能称为直接调用。}}

以这个[[ES5/types#x8.7|引用]]作为参数调用 [[ES5/types#GetValue|GetValue]] 抽象操作的结果是 [[#x15.1.2.1|15.1.2.1]] 定义的标准内置函数。

==== {{anchor|x15.1.2.2}}{{anchor|parseInt}}parseInt (string, radix) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.2.2}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.1/15.1.2/15.1.2.2}}

'''parseInt''' 函数产生一个根据 <var>radix</var> 来解释 <var>string</var> 得到的整数值。{{extra note||并不总是整数值，也有可能是NaN。}} <var>string</var> 开头的空白会被忽略。如果 <var>radix</var> 是 '''undefined''' 或 '''0'''，则将 <var>radix</var> 当作 '''10''' 处理 {{o partial|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.1/15.1.2/15.1.2.2/S15.1.2.2_A5.1_T1.js|Opera 与 Firefox 仍支持八进位的数字，请参考测试案例（这个链接）和提到八进位数值字面量的规范附录（下个链接）。}}{{moz partial|http://www.w3.org/html/ig/zh/wiki/ES5/annexB#numeric-literals|Opera 与 Firefox 仍支持八进位的数字，请参考测试案例（上个链接）和提到八进位数值字面量的规范附录（这个链接）}}，除非数字是以字符对 '''0x''' 或 '''0X''' 开头，在这种情形下将 <var>radix</var> 当作是 '''16'''。如果传入的 <var>radix</var> 参数直接就是 '''16'''，那么在数字前面加上 '''0x''' 或 '''0X''' 也无妨。{{extra note||如果传入的radix是除了16以外的其它值，而string是以0x开头的，那可能无法得到想要的结果。}}

当调用 '''parseInt''' 函数时，采用以下步骤：

# 令 <var>inputString</var> 为 [[ES5/conversion#ToString|ToString]](<var>string</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13151#134||TO_STRING_INLINE}}
# 令 <var>S</var> 为一个新创建的子字符串，它由 <var>inputString</var> 的第一个非 [[ES5/conversion#x9.3.1|StrWhiteSpaceChar]] 字符和它后面跟着的所有字符组成。( 换句话说，删掉前面的空白。) 如果 <var>inputString</var> 不包含任何这样的字符，则令 <var>S</var> 为空字符串。
# 令 <var>sign</var> 为 '''1'''。
# 如果 <var>S</var> 不为空并且 <var>S</var> 的第一个字符是减号 '''-'''，则令 <var>sign</var> 为 '''−1'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/conversions-inl.h?r{{=}}13151#255||Sign-Detection}}
# 如果 <var>S</var> 不是空并且 <var>S</var> 的第一个字符加号 '''+''' 或减号 '''-'''，则删除 S 的第一个字符。
# 令 <var>R</var> = [[ES5/conversion#ToInteger|ToInteger]](<var>radix</var>)。
# 令 <var>stripPrefix</var> 为 '''true'''。
# 如果 <var>R</var> ≠ '''0'''，则 
## 如果 <var>R</var> < '''2''' 或 <var>R</var> > '''36'''，则返回 '''NaN'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/conversions-inl.h?r{{=}}13151#297||Radix-Range-Test}}
## 如果 <var>R</var> ≠ '''16'''，令 <var>stripPrefix</var> 为 '''false'''。
# 否则，<var>R</var> = '''0'''
## 令 <var>R</var> = '''10'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/conversions-inl.h?r{{=}}13151#271||Predict-Radix-as-10}}
# 如果 <var>stripPrefix</var> 是 '''true'''，则 
## 如果 <var>S</var> 长度大于 '''2''' 并且 <var>S</var> 的头两个字符是 “'''0x'''” 或 “'''0X'''”，则删除 <var>S</var> 的头两个字符并且令 <var>R</var> = '''16'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/conversions-inl.h?r{{=}}13151#288||0x-prefix}}
# 如果 <var>S</var> 包含任何不是 '''<var>R</var>进制''' 数位的字符 {{extra note||比如十进制中出现字母、16进制中出现大于F的字母。}}，则令 <var>Z</var> 为 <var>S</var> 中这样的字符之前的所有字符组成的子字符串；否则令 <var>Z</var> 为 <var>S</var> {{extra note||换言之就是在最左边尽可能多的取有效字符，比如十六进制的 "0xFEXC" 会得到 "0xFE"，因为 "X" 不是16进制的有效数位}}。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/conversions-inl.h?r{{=}}13151#393||Parse-Break}}
# 如果 <var>Z</var> 是空，返回 '''NaN'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/conversions-inl.h?r{{=}}13151#421||Return-JunkStringValue}}
# 令 <var>mathInt</var> 为 <var>Z</var> 的 '''<var>R</var>进制''' 表示的数学值，用字母 '''A-Z''' 和 '''a-z''' 来表示 '''10''' 到 '''35''' 之间的值。( 但如果 <var>R</var> 是 '''10''' 并且 <var>Z</var> 包含多余 '''20''' 位的值，可以替换 '''20''' 位后的每个数字为 '''0'''，这是实现可选的功能；如果 <var>R</var> 不是 '''2'''、'''4'''、'''8'''、'''10'''、'''16'''、'''32'''，则 <var>mathInt</var> 可以是 <var>Z</var> 的 '''<var>R</var>进制''' 表示的依赖于实现的近似值。)
# 令 <var>number</var> 为 <var>mathInt</var> 的 '''Number''' 值。
# 返回 <var>sign</var> × <var>number</var>。 {{v8|http://code.google.com/p/v8/source/browse/trunk/src/conversions-inl.h?r{{=}}13151#424||Return-Value}}

{{note|'''parseInt''' 可以只把 '''string''' 的开头部分解释为整数值；它会忽略所有不能解释为整数记法的一部分的字符，并且没有指示会给出任何这些忽略的字符。}}

==== {{anchor|x15.1.2.3}}parseFloat (string) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.2.3}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.1/15.1.2/15.1.2.3}}

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

当调用 '''parseFloat''' 函数，采用以下步骤：

# 令 <var>inputString</var> 为 [[ES5/conversion#ToString|ToString]](<var>string</var>)。
# 令 <var>trimmedString</var> 为一个新创建的子字符串，它由 <var>inputString</var> 的非 [[ES5/conversion#x9.3.1|StrWhiteSpaceChar]] 字符的最左边字符和它右边跟着的所有字符组成。( 换句话说，删掉前面的空白。) 如果 <var>inputString</var> 不包含任何这样的字符，则令 <var>trimmedString</var> 为空字符串。
# 如果 <var>trimmedString</var> 或 <var>trimmedString</var> 的任何前缀都不满足 [[ES5/conversion#ToNumber-StringNumericLiteral|StrDecimalLiteral]] 的语法，返回 '''NaN'''。
# 令 <var>numberString</var> 为满足 [[ES5/conversion#ToNumber-StringNumericLiteral|StrDecimalLiteral]] 语法的 <var>trimmedString</var> 的最长前缀，可能是 <var>numberString</var> 自身。
# 返回 <var>numberString</var> 数学值的 '''Number''' 值。

{{note| '''parseFloat''' 可以只把 ''string'' 的开头部分解释为数值；它会忽略所有不能解释为数值字面量记法的一部分的字符，并且没有指示会给出任何这些忽略的字符。}}

==== {{anchor|x15.1.2.4}}isNaN (number) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.2.4}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.1/15.1.2/15.1.2.4}}

如果指定参数为 '''NaN'''，则返回 '''true'''，否则返回 '''false'''。

# 如果 [[ES5/conversion#ToString|ToString]](number) 是 '''NaN'''，返回 '''true'''。{{v8|https://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13151#107||Convert to Number}}
# 否则 ，返回 '''false'''。

{{note| 一个用 ECMAScript 代码来测试值 '''X''' 是否是 '''NaN''' 的方式是使用表达式 '''<nowiki>X !== X</nowiki>'''。仅当 '''X''' 是 '''NaN''' 时结果才是 '''true'''。}}

==== {{anchor|x15.1.2.5}}isFinite (number) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.2.5}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.1/15.1.2/15.1.2.5}}

如果指定参数为 '''NaN''' 或 '''+∞'''或'''−∞'''，则返回 '''false'''，否则返回 '''true'''。

# 如果 [[ES5/conversion#ToNumber|ToNumber]](<var>number</var>) 是 '''NaN''' 或 '''+∞''' 或 '''−∞'''，返回 '''false'''。{{v8|https://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13151#114||Convert to Number}}
# 否则，返回 '''true'''。

=== {{anchor|x15.1.3}}处理 URI 的函数属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.3}}


统一资源标识符，或叫做 URI，是用来标识互联网上的资源（例如，网页或文件）和怎样访问这些资源的传输协议（例如，HTTP 或 FTP）的字符串。除了 [[#x15.1.3.1|15.1.3.1]], [[#x15.1.3.2|15.1.3.2]], [[#x15.1.3.3|15.1.3.3]]，[[#x15.1.3.4|15.1.3.4]] 说明的用来编码和解码 URI 的函数之外 ECMAScript 语言自身不提供任何使用 URL 的支持。

{{note| 许多 ECMAScript 实现提供额外的函数，方法来操作网页；这些函数超出了本标准的范围。}}

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

''Scheme'' : ''First'' / ''Second'' ; ''Third'' ? ''Fourth''

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

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

  <b id="uri">uri</b> :::
    ''{{toanchor|uriCharacters}}''<sub>opt</sub>

  <b id="uriCharacters">uriCharacters</b> :::
    ''{{toanchor|uriCharacter}}'' ''{{toanchor|uriCharacters}}''<sub>opt</sub>

  <b id="uriCharacter">uriCharacter</b> :::
    ''{{toanchor|uriReserved}}''
    ''{{toanchor|uriUnescaped}}''
    ''{{toanchor|uriEscaped}}''

  <b id="uriReserved">uriReserved</b> ::: '''one of'''
    '''; / ? : @ & = + $ ,'''

  <b id="uriUnescaped">uriUnescaped</b> :::
    ''{{toanchor|uriAlpha}}''
    ''[[ES5/lexical#DecimalDigit|DecimalDigit]]''
    ''{{toanchor|uriMark}}''

  <b id="uriEscaped">uriEscaped</b> :::
    '''%''' [[ES5/lexical#HexDigit|HexDigit]] [[ES5/lexical#HexDigit|HexDigit]]

  <b id="uriAlpha">uriAlpha</b> ::: '''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'''

  <b id="uriMark">uriMark</b> ::: '''one of'''
    '''- _ . ! ~ * ' ( )'''

{{note| 以上语法是基于 RFC 2396 的，并且较新的 RFC 3986 引入的更改没有反应在这里。}}

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

{{anchor|Encode}}描述编码和转义过程的抽象操作 '''Encode''' 需要两个字符串参数 <var>string</var> 和 <var>unescapedSet</var>。

# 令 <var>strLen</var> 为 <var>string</var> 的字符个数。
# 令 <var>R</var> 为空字符串。
# 令 <var>k</var> 为 '''0'''。
# 重复 
## 如果 <var>k</var> 等于 <var>strLen</var>，返回 <var>R</var>。
## 令 <var>C</var> 为 <var>string</var> 中位置为 <var>k</var> 的字符。
## 如果 <var>C</var> 在 <var>unescapedSet</var> 里，则 
### 令 <var>S</var> 为一个只包含字符 <var>C</var> 的字符串。
### 令 <var>R</var> 为之前 <var>R</var> 的值和 <var>S</var> 连接得到的一个新字符串值。
## 否则，<var>C</var> 不在 <var>unescapedSet</var> 里 
### 如果 <var>C</var> 的代码单元值不小于 '''0xDC00''' 并且不大于 '''0xDFFF'''，则抛出一个 '''URIError''' 异常。{{extra note||这个范围是Unicode中的低位替代符（Low Surrogates），不存在以这个字符开头的UTF-16完整字符。}}
### 如果 <var>C</var> 的代码单元值小于 '''0xD800''' 或大于 '''0xDBFF'''，则 {{extra note||这个范围是Unicode中的高位替代符（High Surrogates），这个范围之外的有效UTF-16字符，其代码单元值与Unicode是相同的。}}
#### 令 <var>V</var> 为 <var>C</var> 的代码单元值。
### 否则 {{extra note||这部分是处理以高位替代符（High Surrogates）开头的UTF-16，这类UTF-16字符由四个字节组成。}}
#### <var>k</var> 递增 '''1'''。
#### 如果 <var>k</var> 等于 <var>strLen</var>，抛出一个 '''URIError''' 异常。 {{extra note||标准的UTF-16中高位替代符不能是结束字符。}}
#### 令 <var>kChar</var> 为 <var>string</var> 的 <var>k</var> 位置的字符的代码单元值。
#### 如果 <var>kChar</var> 小于 '''0xDC00''' 或大于 '''0xDFFF'''，则抛出一个 '''URIError''' 异常。{{extra note||标准的UTF-16中高位替代符的后一个字符必须是低位替代符。}}
#### 令 <var>V</var> 为 (((<var>C</var>的代码单元值 ) – '''0xD800''') * '''0x400''' + (<var>kChar</var> – '''0xDC00''') + '''0x10000''')。{{extra note||将高低位替代符合并计算成Unicode字符值，这里的乘0x400改成左移10位可能更容易理解。}}
### 令 <var>Octets</var> 为 <var>V</var> 执行 UTF-8 转换的结果字节数组，令 <var>L</var> 为这个字节数组的长度。
### 令 <var>j</var> 为 '''0'''。
### 只要 <var>j</var> &lt; <var>L</var>，就重复 
#### 令 <var>jOctet</var> 为 <var>Octets</var> 的 <var>j</var> 位置的值。
#### 令 <var>S</var> 为一个包含三个字符“%<var>XY</var>”的字符串，这里 <var>XY</var> 是编码 <var>jOctet</var> 值的两个大写16进制数字。
#### 令 <var>R</var> 为之前 <var>R</var> 的值和 <var>S</var> 连接得到的一个新字符串值。
#### <var>j</var> 递增 '''1'''。
## <var>k</var> 递增 '''1'''。


{{anchor|Decode}}描述反转义和解码过程的抽象操作 '''Decode''' 需要两个字符串参数 <var>string</var> 和 <var>reservedSet</var>。

# 令 <var>strLen</var> 为 <var>string</var> 的字符个数。
# 令 <var>R</var> 为空字符串。
# 令 <var>k</var> 为 '''0'''。
# 重复 
## 如果 <var>k</var> 等于 <var>strLen</var>，返回 <var>R</var>。
## 令 <var>C</var> 为 <var>string</var> 的 <var>k</var> 位置的字符。
## 如果 <var>C</var> 不是‘'''%'''’，则 
### 令 <var>S</var> 为只包含字符 <var>C</var> 的字符串。
## 否则，<var>C</var> 是‘'''%'''’
### 令 <var>start</var> 为 <var>k</var>。
### 如果 <var>k</var> + '''2''' 大于或等于 <var>strLen</var>，抛出一个 '''URIError''' 异常。 {{extra note||%号后面至少要有两个字符。}}
### 如果 <var>string</var> 的 (<var>k</var> + '''1''') 和 (<var>k</var> + '''2''') 位置的字符没有表示为16进制数字，则抛出一个 '''URIError''' 异常。{{extra note||%号后面的两个字符必须是16进制数字。}}
### 令 <var>B</var> 为 (<var>k</var> + '''1''') 和 (<var>k</var> + '''2''') 位置的两个16进制数字表示的8位值。
### <var>k</var> 递增 '''2'''.
### 如果 <var>B</var> 的最高有效位是 '''0'''，则 {{extra note||意味着这个UTF-8字符只有一个字节。}}
#### 令 <var>C</var> 为代码单元值是 <var>B</var> 的字符。
#### 如果 <var>C</var> 不在 <var>reservedSet</var> 里，则 
##### 令 <var>S</var> 为只包含字符 <var>C</var> 的字符串。
#### 否则，<var>C</var> 在 <var>reservedSet</var> 里 
##### 令 <var>S</var> 为 <var>string</var> 的从位置 <var>start</var> 到位置 <var>k</var> 的子字符串。
### 否则，<var>B</var> 的最高有效位是 '''1''' {{extra note||意味着这个UTF-8字符大于一个字节。}}
#### 令 <var>n</var> 为满足 (<var>B</var> &lt;&lt; <var>n</var>) & '''0x80''' 等于 '''0''' 的最小非负数。{{extra note||不断地左移位，直到第8位为0，这时的n就是这个UTF-8字符的字节数。}}
#### 如果 <var>n</var> 等于 '''1''' 或 <var>n</var> 大于 '''4'''，抛出一个 '''URIError''' 异常。{{extra note||不存在以二进制10开头的的UTF-8字符，一个UTF-8字符最多为4个字节。}}
#### 令 <var>Octets</var> 为一个长度为 <var>n</var> 的字节数组。
#### 将 <var>B</var> 放到 <var>Octets</var> 的 '''0''' 位置。
#### 如果 <var>k</var> + ('''3''' * (<var>n</var> – '''1''')) 大于或等于 <var>strLen</var>，抛出一个 '''URIError''' 异常。{{extra note||string在k位置之后的部分不足以组成这个完整的UTF-8字符时抛出异常。}}
#### 令 <var>j</var> 为 '''1'''。
#### 重复，直到 <var>j</var> &lt; <var>n</var>
##### <var>k</var> 递增 '''1'''。
##### 如果 <var>string</var> 的 <var>k</var> 位置的字符不是‘%’，抛出一个 '''URIError''' 异常。
##### 如果 <var>string</var> 的 (<var>k</var> + '''1''') 和 (<var>k</var> + '''2''') 位置的字符没有表示为16进制数字，抛出一个 '''URIError''' 异常。
##### 令 <var>B</var> 为 <var>string</var> 的 (<var>k</var> + ''1''') 和 (<var>k</var> + '''2''') 位置的两个16进制数字表示的8位值。
##### 如果 <var>B</var> 的两个最高有效位不是二进制的 '''10'''，抛出一个 '''URIError''' 异常。{{extra note||UTF-8字符的后续字节都必须以二进制的10开头。}}
##### <var>k</var> 递增 '''2'''。
##### 将 <var>B</var> 放到 <var>Octets</var> 的 <var>j</var> 位置。
##### <var>j</var> 递增 '''1'''。
#### 令 <var>V</var> 为给 <var>Octets</var> 执行 UTF-8 转换得到的值，这是从一个字节数组到一个21位值的转换过程。{{extra note||Unicode字符的上限是0x10FFFF，它的二进制是21位。}}如果 <var>Octets</var> 不包含有效的 UTF-8 编码的 Unicode 代码点，则抛出一个 '''URIError''' 异常。
#### 如果 <var>V</var> 小于 '''0x10000'''，则 {{extra note||这个范围的Unicode和UTF-16拥有相同的值。}}
##### 令 <var>C</var> 为代码单元值是 <var>V</var> 的字符。
##### 如果 <var>C</var> 不在 <var>reservedSet</var> 里，则 
###### 令 <var>S</var> 为只包含字符 <var>C</var> 的字符串。
##### 否则，<var>C</var> 在 <var>reservedSet</var> 里 
###### 令 <var>S</var> 为 <var>string</var> 的从位置 <var>start</var> 到位置 <var>k</var> 的子字符串。
#### 否则，<var>V</var> ≥ '''0x10000''' {{extra note||这个范围的Unicode值在UTF-16上必须用4个字节才能表示。前两个字节是高位替代符，后两个字节为低位替代符。}}
##### 令 <var>L</var> 为 (((<var>V</var> – '''0x10000''') & '''0x3FF''') + '''0xDC00''')。
##### 令 <var>H</var> 为 ((((<var>V</var> – '''0x10000''') >> '''10''') & '''0x3FF''') + '''0xD800''')。
##### 令 <var>S</var> 为代码单元值是 <var>H</var> 和 <var>L</var> 的两个字符组成的字符串。
# 令 <var>R</var> 为之前的 <var>R</var> 和 <var>S</var> 连接成的新字符串。
#k 递增 '''1'''。

{{note| 统一资源标识符的语法由 RFC 2396 给出，这里并没有反应更新的替换了 RFC 2396 的 RFC 3986。RFC 3629 给出了实现 UTF-8 的正式描述。}}

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



{| border="1" cellpadding="5" style="border-collapse:collapse;" align="center"
|+ '''表21 — UTF-8 Encodings'''
|- style="background:#EEE;"
! 单位代码值
! 表现
! 第一字节
! 第二字节
! 第三字节
! 第四字节
|-
| 0x0000 - 0x007F
| 00000000 0zzzzzzz
| 0zzzzzzz
| 
| 
| 
|-
| 0x0080 - 0x07FF
| 00000yyy yyzzzzzz
| 110yyyyy
| 10zzzzzz
| 
| 
|-
| 0x0800 - 0xD7FF
| xxxxyyyy yyzzzzzz
| 1110xxxx
| 10yyyyyy
| 10zzzzzz
| 
|-
| 0xD800 - 0xDBFF<br/>挨着<br/>0xDC00 - 0xDFFF
| 110110vv vvwwwwxx<br/>挨着<br/>110111yy yyzzzzzz
| 11110uuu
| 10uuwwww
| 10xxyyyy
| 10zzzzzz
|-
| 0xD800 - 0xDBFF<br/>不挨着<br/>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位值中。这就是替代符对的解码方式。 {{extra note||替代符对是由两个双字节的UTF-16替代符组成，也可以将他整体视为一个四字节的UTF-16字符。UTF-32实际上就是Unicode值，Unicode的最大值是0x10FFFF，所以它实际上只有21位会被用到。将替代符对转换到UTF-32的表示法就是上表中给出的方法。四字节的UTF-16对应的UTF-8也是四字节的，UTF-8的这四个字节去掉用于格式的位，剩余21位可以存储字符编码。UTF-32编码到UTF-8就是将其包含的所有位放入UTF-8的这21个位中。}}

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


==== {{anchor|decodeURI}}{{anchor|x15.1.3.1}}decodeURI (encodedURI) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.3.1}}

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

当以一个参数 <var>encodedURI</var> 调用 '''decodeURI''' 函数，采用如下步骤：

# 令 <var>uriString</var> 为 [[ES5/conversion#ToString|ToString]](<var>encodedURI</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/uri.js?r{{=}}13156#299|ToString}}
# 令 <var>reservedURISet</var> 为一个包含 {{toanchor|uriReserved}} 中的所有字符组成的字符串连接上 "'''#'''" 组成的字符串。
# 返回调用 [[#Decode|Decode]](<var>uriString</var>, <var>reservedURISet</var>) 的结果。

{{note| "'''#'''" 字符不会从转义序列中解码，即使它不是 URI 保留字符。}}


==== {{anchor|decodeURIComponent}}{{anchor|x15.1.3.2}}decodeURIComponent (encodedURIComponent) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.3.2}}

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

当以一个参数 <var>encodedURIComponent</var> 调用 '''decodeURIComponent''' 函数，采用如下步骤：

# 令 <var>componentString</var> 为 [[ES5/conversion#ToString|ToString]](<var>encodedURIComponent</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/uri.js?r{{=}}13156#307|ToString}}
# 令 <var>reservedURIComponentSet</var> 为一个空字符串。
# 返回调用 [[#Decode|Decode]](<var>componentString</var>, <var>reservedURIComponentSet</var>) 的结果。


==== {{anchor|encodeURI }}{{anchor|x15.1.3.3}}encodeURI (uri) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.3.3}}

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

当以一个参数 <var>uri</var> 调用 '''encodeURI''' 函数，采用如下步骤：

# 令 <var>uriString</var> 为 [[ES5/conversion#ToString|ToString]](<var>uri</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/uri.js?r{{=}}13156#349|ToString}}
# 令 <var>unescapedURISet</var> 为一个包含 {{toanchor|uriReserved}} 和 {{toanchor|uriUnescaped}} 中所有字符组成的字符串连接上 "'''#'''" 组成的字符串。
# 返回调用 [[#Encode|Encode]](<var>uriString</var>, <var>unescapedURISet</var>) 的结果。

{{note| 字符 "'''#'''" 不会被编码为一个转义序列，即使它不是 URI 保留字符或非转义字符。}}


==== {{anchor|encodeURIComponent}}{{anchor|x15.1.3.4}}encodeURIComponent (uriComponent) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.3.4}}

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

当以一个参数 <var>uriComponent</var> 调用 '''encodeURIComponent''' 函数，采用如下步骤：

# 令 <var>componentString</var> 为 [[ES5/conversion#ToString|ToString]](<var>uriComponent</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/uri.js?r{{=}}13156#372|ToString}}
# 令 <var>unescapedURIComponentSet</var> 为一个包含 {{toanchor|uriUnescaped}} 中所有字符组成的字符串。
# 返回调用 [[#Encode|Encode]](<var>componentString</var>, <var>unescapedURIComponentSet</var>) 的结果。

=== 全局对象的构造器属性 {{anchor|x15.1.4}}===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4}}

====Object ( . . . ){{anchor|x15.1.4.1}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.1}}


见 [[#.E4.BD.9C.E4.B8.BA.E5.87.BD.E6.95.B0.E8.B0.83.E7.94.A8Object.E6.9E.84.E9.80.A0.E5.99.A8|15.2.1]] 和 [[#Object.E6.9E.84.E9.80.A0.E5.99.A8|15.2.2]].

====Function ( . . . ){{anchor|x15.1.4.2}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.2}}


见 [[#Object.prototype|15.3.1]] 和 [[#Object.getPrototypeOf_.28_O_.29|15.3.2]]

====Array ( . . . ){{anchor|x15.1.4.3}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.3}}


见 [[#.E4.BD.9C.E4.B8.BA.E5.87.BD.E6.95.B0.E8.B0.83.E7.94.A8Array.E6.9E.84.E9.80.A0.E5.99.A8|15.4.1]] 和 [[#Array.E6.9E.84.E9.80.A0.E5.99.A8|15.4.2]].

====String ( . . . ){{anchor|x15.1.4.4}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.4}}


见 [[#.E4.BD.9C.E4.B8.BA.E5.87.BD.E6.95.B0.E8.B0.83.E7.94.A8String.E6.9E.84.E9.80.A0.E5.99.A8|15.5.1]] 和 [[#String.E6.9E.84.E9.80.A0.E5.99.A8|15.5.2]].

====Boolean ( . . . ){{anchor|x15.1.4.5}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.5}}


见 [[#.E4.BD.9C.E4.B8.BA.E5.87.BD.E6.95.B0.E8.B0.83.E7.94.A8.E5.B8.83.E5.B0.94.E6.9E.84.E9.80.A0.E5.99.A8|15.6.1]] 和 [[#.E5.B8.83.E5.B0.94.E6.9E.84.E9.80.A0.E5.99.A8|15.6.2]].

====Number ( . . . ){{anchor|x15.1.4.6}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.6}}


见 [[#.E4.BD.9C.E4.B8.BA.E5.87.BD.E6.95.B0.E8.B0.83.E7.94.A8.E7.9A.84Number.E6.9E.84.E9.80.A0.E5.99.A8|15.7.1]] 和 [[#Number.E6.9E.84.E9.80.A0.E5.99.A8|15.7.2]].

====Date ( . . . ){{anchor|x15.1.4.7}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.7}}


见 [[#.E4.BD.9C.E4.B8.BA.E5.87.BD.E6.95.B0.E8.B0.83.E7.94.A8Date.E6.9E.84.E9.80.A0.E5.99.A8|15.9.2]].

====RegExp ( . . . ){{anchor|x15.1.4.8}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.8}}


见 [[#The_RegExp_Constructor_Called_as_a_Function|15.10.3]] 和 [[#The_RegExp_Constructor|15.10.4]].

====Error ( . . . ){{anchor|x15.1.4.9}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.9}}


见 [[#The_Error_Constructor_Called_as_a_Function|15.11.1]] 和 [[#The_Error_Constructor|15.11.2]].

====EvalError ( . . . ){{anchor|x15.1.4.10}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.10}}


见 15.11.6.1.

====RangeError ( . . . ){{anchor|x15.1.4.11}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.11}}


见 [[#RangeError|15.11.6.2]].

====ReferenceError ( . . . ){{anchor|x15.1.4.12}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.12}}


见 [[#ReferenceError|15.11.6.3]].

====SyntaxError ( . . . ){{anchor|x15.1.4.13}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.13}}


见 [[#SyntaxError|15.11.6.4]].

====TypeError ( . . . ){{anchor|x15.1.4.14}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.14}}


见 [[#TypeError|15.11.6.5]].

====URIError ( . . . ){{anchor|x15.1.4.15}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.4.15}}


见 [[#URIError|15.11.6.6]].

=== 全局对象的其他属性 {{anchor|x15.1.5}}===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.5}}

====Math{{anchor|x15.1.5.1}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.5.1}}


见 [[#Math.E5.AF.B9.E8.B1.A1|15.8]].

====JSON{{anchor|x15.1.5.2}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.1.5.2}}


见 [[#The_JSON_Object|15.12]].

== {{anchor|x15.2}}Object 对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.2}}


=== {{anchor|x15.2.1}}作为函数调用 Object 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.1}}

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


==== {{anchor|x15.2.1.1}}Object ( [ value ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.1.1}}

当以一个参数 <var>value</var> 或者无参数调用 '''Object''' 函数，采用如下步骤：
# 如果 <var>value</var> 是 '''null'''、'''undefined''' 或未指定，则创建并返回一个新 '''Object''' 对象，这个对象与仿佛用相同参数调用标准内置的 '''Object''' 构造器 ([[#x15.2.2.1|15.2.2.1]]) 的结果一样。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1286|Create New Object}}
# 返回 [[ES5/conversion#ToObject|ToObject]](<var>value</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1287|ToObject}}


==={{anchor|x15.2.2}}Object 构造器===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.2}}

当 '''Object''' 是 '''new''' 表达式调用的一部分时，它是一个构造器，可创建一个对象。


===={{anchor|x15.2.2.1}}new Object ( [ value ] )====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.2.1}}

当以一个参数 <var>value</var> 或者无参数调用 '''Object''' 构造器，采用如下步骤：
# 如果提供了 <var>value</var>，则 
## 如果 [[ES5/types#Type|Type]](<var>value</var>) 是 '''Object'''，则 
### 如果 <var>value</var> 是个原生 ECMAScript 对象，不创建新对象，简单的返回 <var>value</var>。
### 如果 <var>value</var> 是宿主对象，则采取动作和返回依赖实现的结果的方式可以使依赖于宿主对象的。
## 如果 [[ES5/types#Type|Type]](<var>value</var>) 是 '''String'''，返回 [[ES5/conversion#ToObject|ToObject]](<var>value</var>)。
## 如果 [[ES5/types#Type|Type]](<var>value</var>) 是 '''Boolean'''，返回 [[ES5/conversion#ToObject|ToObject]](<var>value</var>)。
## 如果 [[ES5/types#Type|Type]](<var>value</var>) 是 '''Number'''，返回 [[ES5/conversion#ToObject|ToObject]](<var>value</var>)。
# 断言：未提供参数 <var>value</var> 或其类型是 '''Null''' 或 '''Undefined'''。
# 令 <var>obj</var> 为一个新创建的原生 ECMAScript 对象。
# 设定 <var>obj</var> 的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性为标准内置的 '''Object''' 的 '''prototype''' 对象 ([[#x15.2.4|15.2.4]])。
# 设定 <var>obj</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性为 '''"Object"'''。
# 设定 <var>obj</var> 的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性为 '''true'''。
# 设定 <var>obj</var> 的 [[ES5/types#x8.12|8.12]] 指定的所有内部方法 
# 返回 <var>obj</var>。


=== {{anchor|x15.2.3}}Object 构造器的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3}}

'''Object''' 构造器的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性值是标准内置 '''Function''' 的 '''prototype''' 对象。

除了内部属性和 '''length''' 属性（其值是 '''1'''）之外，'''Object''' 构造器拥有以下属性：


==== {{anchor|x15.2.3.1}}Object.prototype ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.1}}

'''Object.prototype''' 的初始值是标准内置 '''Object''' 的 '''prototype''' 对象（[[#x15.2.4|15.2.4]]）。

这个属性包含特性 <nowiki>{[[Writable]]: </nowiki>'''false'''<nowiki>, [[Enumerable]]: </nowiki>'''false'''<nowiki>, [[Configurable]]: </nowiki>'''false''' <nowiki>}</nowiki>


==== {{anchor|x15.2.3.2}}Object.getPrototypeOf ( O ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.2}}

当以参数 <var>O</var> 调用 '''getPrototypeOf''' 函数，采用如下步骤：

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#949|MakeTypeError}}
# 返回 <var>O</var> 的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性的值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r{{=}}13156#948|Return Prototype}}


==== {{anchor|x15.2.3.3}}Object.getOwnPropertyDescriptor ( O, P ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.3}}

当调用 '''getOwnPropertyDescriptor''' 函数，采用如下步骤：

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#958|MakeTypeError}}
# 令 <var>name</var> 为 [[ES5/conversion#ToString|ToString]](<var>P</var>)。
# 令 <var>desc</var> 为以参数 <var>name</var> 调用 <var>O</var> 的 [[ES5/types#GetOwnProperty|<nowiki>[[GetOwnProperty]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#961|GetOwnProperty}}
# 返回调用 [[ES5/types#FromPropertyDescriptor|FromPropertyDescriptor]](<var>desc</var>) 的结果。


==== {{anchor|x15.2.3.4}}Object.getOwnPropertyNames ( O ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.4}}

当调用 '''getOwnPropertyNames''' 函数，采用如下步骤：{{extra note||<nowiki>它与keys的区别在于它可以获取到[[enumerable]]为false的属性。</nowiki>}}

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#989|Convert to Number}}
# 令 <var>array</var> 为仿佛是用表达式 '''new Array ()''' 创建新对象的结果，这里的 '''Array''' 是标准内置构造器名。 
# 令 <var>n</var> 为 '''0'''。
# 对 <var>O</var> 的每个自身属性 <var>P</var>
## 令 <var>name</var> 为值是 <var>P</var> 的名称的字符串。
## 以 [[ES5/conversion#ToString|ToString]](<var>n</var>) 和属性描述 <nowiki>{[[Value]]: </nowiki><var>name</var><nowiki>, [[Writable]]: </nowiki>'''true'''<nowiki>, [[Enumerable]]: </nowiki>'''true'''<nowiki>, [[Configurable]]: </nowiki>'''true'''<nowiki>}</nowiki> 和 '''false''' 为参数调用 <var>array</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1031|ToString PropertyNames}}
## <var>n</var> 递增 '''1'''。
# 返回 <var>array</var>。

{{note| 如果 '''''O''''' 是一个字符串实例，'''第4步''' 处理的自身属性集合包含 15.5.5.2 定义的隐藏属性，他们对应对象的 '''<nowiki>[[PrimitiveValue]]</nowiki>''' 字符串中相应位置的字符。}}


==== {{anchor|x15.2.3.5}}Object.create ( O [, Properties] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.5}}

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

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object''' 或 '''Null'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1050|MakeTypeError}}
# 令 <var>obj</var> 为仿佛是用表达式 '''new Object()''' 创建新对象的结果，这里的 '''Object''' 是标准内置构造器名。 {{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1052|new $Object}}
# 设定 <var>obj</var> 的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性为 <var>O</var>。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1053|Set Prototype}}
# 如果传入了 <var>Properties</var> 参数并且不是 '''undefined'''，则仿佛是用 <var>obj</var> 和 <var>Properties</var> 当作参数调用标准内置函数 '''Object.defineProperties''' 一样给 <var>obj</var> 添加自身属性。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1054|ObjectDefineProperties}}
# 返回 <var>obj</var>。


==== {{anchor|x15.2.3.6}}Object.defineProperty ( O, P, Attributes ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.6}}

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

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1062|MakeTypeError}}
# 令 <var>name</var> 为 [[ES5/conversion#ToString|ToString]](<var>P</var>)。
# 令 <var>desc</var> 为以 <var>Attributes</var> 作为参数调用 [[ES5/types#ToPropertyDescriptor|ToPropertyDescriptor]] 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1093|ToPropertyDescriptor}}
# 以 <var>name</var>、<var>desc</var>、<var>true</var> 作为参数调用 <var>O</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法 .{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1094|DefineOwnProperty}}
# 返回 <var>O</var>。


==== {{anchor|x15.2.3.7}}Object.defineProperties ( O, Properties ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.7}}

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

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1114|MakeTypeError}}
# 令 <var>props</var> 为 [[ES5/conversion#ToObject|ToObject]](<var>Properties</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1116||ToObject}}
# 令 <var>names</var> 为一个内部列表，它包含 <var>props</var> 的每个可遍历自身属性的名称。
# 令 <var>descriptors</var> 为一个空的内部列表。
# 对 <var>names</var> 的每个元素 <var>P</var>，按照列表顺序 ,
## 令 <var>descObj</var> 为以 <var>P</var> 作为参数调用 <var>props</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
## 令 <var>desc</var> 为以 <var>descObj</var> 作为参数调用 [[ES5/types#ToPropertyDescriptor|ToPropertyDescriptor]] 的结果。
## 将 <var>desc</var> 插入 <var>descriptors</var> 的尾部。
# 对 <var>descriptors</var> 的每个元素 <var>desc</var>，按照列表顺序 ,
## 以参数 <var>P</var>、<var>desc</var>、'''true''' 调用 <var>O</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1123|DefineOwnProperty}}
# 返回 <var>O</var>

如果一个实现为 [[ES5/statements#x12.6.4|for-in 语句]] 的定义了特定的枚举顺序，那么在这个算法的 '''第3步''' 中的列表元素'''必须'''也用相同的顺序排列。


==== {{anchor|x15.2.3.8}}Object.seal ( O ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.8}}

当调用 <var>seal</var> 函数，采用如下步骤：

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1161|MakeTypeError}}
# 对 <var>O</var> 的每个命名自身属性名 <var>P</var>,
## 令 <var>desc</var> 为以参数 <var>P</var> 调用 <var>O</var> 的 [[ES5/types#GetOwnProperty|<nowiki>[[GetOwnProperty]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1169|GetOwnProperty}}
## 如果 <var>desc</var>.[[ES5/types#Configurable|<nowiki>[[Configurable]]</nowiki>]] 是 '''true'''，设定 <var>desc</var>.[[ES5/types#Configurable|<nowiki>[[Configurable]]</nowiki>]] 为 '''false'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1171|Set Configurable false}}
## 以 <var>P</var>、<var>desc</var>、'''true''' 为参数调用 <var>O</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
# 设定 <var>O</var> 的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性为 '''false'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1175|PreventExtensions}}
# 返回 <var>O</var>。


===={{anchor|x15.2.3.9}}Object.freeze ( O )====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.9}}

当调用 '''freeze''' 函数，采用如下步骤：

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1183|MakeTypeError}}
# 对 <var>O</var> 的每个命名自身属性名 <var>P</var>,
## 令 <var>desc</var> 为以参数 <var>P</var> 调用 <var>O</var> 的 [[ES5/types#GetOwnProperty|<nowiki>[[GetOwnProperty]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1191|GetOwnProperty}}
## 如果 [[ES5/types#IsDataDescriptor|IsDataDescriptor]](<var>desc</var>) 是 '''true'''，则 
### 如果 <var>desc</var>.[[ES5/types#Writable|<nowiki>[[Writable]]</nowiki>]] 是 '''true'''，设定 <var>desc</var>。[[ES5/types#Writable|<nowiki>[[Writable]]</nowiki>]] 为 '''false'''.{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1193|Set Writable false}}
## 如果 <var>desc</var>.[[ES5/types#Configurable|<nowiki>[[Configurable]]</nowiki>]] 是 '''true'''，设定 <var>desc</var>。[[ES5/types#Configurable|<nowiki>[[Configurable]]</nowiki>]] 为 '''false'''。
## 以 <var>P</var>、<var>desc</var>、'''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
# 设定 <var>O</var> 的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性为 '''false'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1198|PreventExtensions}}
# 返回 <var>O</var>。


==== {{anchor|x15.2.3.10}}Object.preventExtensions ( O ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.10}}

当调用 '''preventExtensions''' 函数，采用如下步骤：

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常 .{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1206|MakeTypeError}}
# 设定 <var>O</var> 的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性为 '''false'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/objects.cc?r{{=}}13156#4476||set_is_extensible}}
# 返回 <var>O</var>。


==== {{anchor|x15.2.3.11}}Object.isSealed ( O ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.11}}

当以参数 <var>O</var> 调用 '''isSealed''' 函数，采用如下步骤：

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1219|MakeTypeError}}
# 对 <var>O</var> 的每个命名自身属性名 <var>P</var>，
## 令 <var>desc</var> 为以参数 <var>P</var> 调用 <var>O</var> 的 [[ES5/types#GetOwnProperty|<nowiki>[[GetOwnProperty]]</nowiki>]] 内部方法的结果 .{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1227|GetOwnProperty}}
## 如果 <var>desc</var>.[[ES5/types#Configurable|<nowiki>[[Configurable]]</nowiki>]] 是 '''true'''，则返回 '''false'''。
# 如果 <var>O</var> 的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性是 '''false'''，则返回 '''true'''。
# 否则，返回 '''false'''。


==== {{anchor|x15.2.3.12}}Object.isFrozen ( O ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.12}}

当以参数 <var>O</var> 调用 '''isFrozen''' 函数，采用如下步骤：

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1240|MakeTypeError}}
# 对 <var>O</var> 的每个命名自身属性名 <var>P</var>,
## 令 <var>desc</var> 为以参数 <var>P</var> 调用 <var>O</var> 的 [[ES5/types#GetOwnProperty|<nowiki>[[GetOwnProperty]]</nowiki>]] 内部方法的结果 .
## 如果 [[ES5/types#IsDataDescriptor|IsDataDescriptor]](desc) 是 '''true'''，则 
### 如果 <var>desc</var>.[[ES5/types#Writable|<nowiki>[[Writable]]</nowiki>]] 是 '''true'''，则返回 '''false'''。
## 如果 <var>desc</var>.[[ES5/types#Configurable|<nowiki>[[Configurable]]</nowiki>]] 是 '''true'''，则返回 '''false'''。
# 如果 <var>O</var> 的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性是 '''false'''，则返回 '''true'''。
# 否则，返回 '''false'''。


==== {{anchor|x15.2.3.13}}Object.isExtensible ( O ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.13}}

当以参数 <var>O</var> 调用 '''isExtensible''' 函数，采用如下步骤：

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#1262|MakeTypeError}}
# 返回 <var>O</var> 的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性布尔值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r{{=}}13156#1163|map.is_extensible}}{{v8|http://code.google.com/p/v8/source/browse/trunk/src/objects-inl.h?r{{=}}13156#3325|Map_is_extensible}}


===={{anchor|x15.2.3.14}}Object.keys ( O )====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.3.14}}

当以参数 <var>O</var> 调用 '''keys''' 函数，采用如下步骤：

# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#345|MakeTypeError}}
# 令 <var>n</var> 为 <var>O</var> 的可遍历自身属性的个数 
# 令 <var>array</var> 为仿佛是用表达式 '''new Array()''' 创建新对象的结果，这里的 '''Array''' 是标准内置构造器名。 
# 令 <var>index</var> 为 '''0'''。
# 对 <var>O</var> 的每个可遍历自身属性名 <var>P</var>，{{extra note||只有遍历自身的，不会遍历原型上的。而for-in会遍历到原型。}}
## 以 [[ES5/conversion#ToString|ToString]](<var>index</var>)，属性描述 <nowiki>{[[Value]]: P, [[Writable]]: </nowiki>'''true'''<nowiki>, [[Enumerable]]: </nowiki>'''true'''<nowiki>, [[Configurable]]: </nowiki>'''true'''<nowiki>}</nowiki>，和 '''false''' 作为参数调用 array 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
## <var>index</var> 递增 '''1'''。
# 返回 <var>array</var>。

如果一个实现为 [[ES5/statements#x12.6.4|for-in 语句]] 的定义了特定的枚举顺序，那么在这个算法的 '''第5步''' 中的'''必须'''使用相同的枚举顺序。


=== {{anchor|x15.2.4}}Object 的 prototype 对象的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.4}}

'''Object''' 的 '''prototype''' 对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性的值是 '''null''' {{extra note||如果不是null就会产生原型链无限递归的问题}}，[[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性的值是 '''"Object"'''，[[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性的初始值是 '''true'''。


==== {{anchor|x15.2.4.1}}Object.prototype.constructor ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.4.1}}

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


==== {{anchor|x15.2.4.2}}Object.prototype.toString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.4.2}}

当调用 '''toString''' 方法，采用如下步骤：{{extra note|| ES3中没有定义严格模式，调用函数时如果this为null或undefined会使用global，那么Object.prototype.toString.call(null)就会得到与ES5不同的结果。}}

# 如果 '''this''' 的值是 '''undefined'''，返回 '''"[object Undefined]"'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#235|Undefined}}
# 如果 '''this''' 的值是 '''null'''，返回 '''"[object Null]"'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#237||Null}}
# 令 <var>O</var> 为以 '''this''' 作为参数调用 [[ES5/conversion#ToObject|ToObject]] 的结果。
# 令 <var>class</var> 为 <var>O</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性的值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#238|Class}}
# 返回三个字符串 '''"[object "'''、<var>class</var> 和 '''"]"''' 连起来的字符串。


==== {{anchor|x15.2.4.3}}Object.prototype.toLocaleString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.4.3}}

当调用 '''toLocaleString''' 方法，采用如下步骤：

# 令 <var>O</var> 为以 '''this''' 作为参数调用 [[ES5/conversion#ToObject|ToObject]] 的结果。
# 令 <var>toString</var> 为以 '''"toString"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果.
# 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>toString</var>) 是 '''false'''，抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#245|MakeTypeError}}
# 返回以 <var>O</var> 作为 '''this''' 值，无参数调用 <var>toString</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法的结果。

{{note| 这个函数给所有 '''Object''' 对象提供一个通用的 '''toLocaleString''' 接口，即使并不是所有的都使用它。目前，'''Array'''、'''Number'''、'''Date''' 都提供了它们自身的语言环境敏感的 '''toLocaleString''' 方法。}}

{{note| 这个函数的第一个参数可能会在此标准的未来版本中使用到；因此建议实现不要用这个位置参数来做其他事情。}}


==== {{anchor|x15.2.4.4}}Object.prototype.valueOf ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.4.4}}

当调用 '''valueOf''' 方法，采用如下步骤：

# 令 <var>O</var> 为以 '''this''' 作为参数调用 [[ES5/conversion#ToObject|ToObject]] 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13156#254|MakeTypeError}}
# 如果 <var>O</var> 是以一个宿主对象 ([[#15.2.2.1|15.2.2.1]]) 为参数调用 '''Object''' 构造器的结果，则 
## 返回 <var>O</var> 或返回先前传递给构造器的原宿主对象。返回的具体结果是由实现定义的。
# 返回 <var>O</var>。


==== {{anchor|x15.2.4.5}}Object.prototype.hasOwnProperty (V) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.4.5}}

当以参数 <var>V</var> 调用 '''hasOwnProperty''' 方法，采用如下步骤：

# 令 <var>P</var> 为 [[ES5/conversion#ToString|ToString]](<var>V</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r{{=}}13156#4592|Convert to String}}
# 令 <var>O</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToObject|ToObject]] 的结果。
# 令 <var>desc</var> 为以 <var>P</var> 为参数调用 <var>O</var> 的 [[ES5/types#GetOwnProperty|<nowiki>[[GetOwnProperty]]</nowiki>]] 内部方法的结果。
# 如果 <var>desc</var> 是 '''undefined'''，返回 '''false'''。
# 返回 '''true'''。

{{note| 不像 <nowiki>[[HasProperty]]</nowiki>(8.12.6)，这个方法不考虑原形链中的对象。}}

{{note| '''第1步''' 和 '''第2步''' 选择这样的顺序是为了确保，即使 '''this''' 值是 '''undefined''' 或 '''null'''，本规范之前版本中任何会在 '''第1步''' 抛出的异常，都会继续在本规范中抛出。{{extra note||在第1步和第2步都会抛出异常时优先抛出第一步的异常。}}}}


==== {{anchor|x15.2.4.6}}Object.prototype.isPrototypeOf (V) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.4.6}}

当以参数 <var>V</var> 调用 '''isPrototypeOf''' 方法，采用如下步骤：

# 如果 <var>V</var> 不是个对象，返回 '''false'''。
# 令 <var>O</var> 为以 '''this''' 作为参数调用 [[ES5/conversion#ToObject|ToObject]] 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r{{=}}13156#959|ToObject}}
# 重复 
## 令 <var>V</var> 为 <var>V</var> 的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性的值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r{{=}}13156#962|GetPrototype}}
## 如果 <var>V</var> 是 '''null'''，返回 '''false'''
## 如果 <var>O</var> 和 <var>V</var> 指向同一个对象，返回 '''true'''。

{{note| '''第1步''' 和 '''第2步''' 选择这样的顺序是为了，当 '''''V''''' 不是对象并且 '''this''' 值是 '''undefined''' 或 '''null''' 时能够保持本规范之前版本指定的行为。}}


==== {{anchor|x15.2.4.7}}Object.prototype.propertyIsEnumerable (V) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.4.7}}

当以参数 <var>V</var> 调用 '''propertyIsEnumerable''' 方法，采用如下步骤：

# 令 <var>P</var> 为 [[ES5/conversion#ToString|ToString]](<var>V</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r{{=}}13156#4656|ToString}}
# 令 <var>O</var> 为以 '''this''' 作为参数调用 [[ES5/conversion#ToObject|ToObject]] 的结果。
# 令 <var>desc</var> 为以 <var>P</var> 作为参数调用 <var>O</var> 的 [[ES5/types#GetOwnProperty|<nowiki>[[GetOwnProperty]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r{{=}}13156#4658|GetLocalPropertyAttribute}}
# 如果 <var>desc</var> 是 '''undefined'''，返回 '''false'''。
# 返回 <var>desc</var>.[[ES5/types#Enumerable|<nowiki>[[Enumerable]]</nowiki>]] 的值。

{{note| 这个方法不考虑原型链中的对象。}}

{{note| '''第1步''' 和 '''第2步''' 选择这样的顺序是为了确保，即使 '''this''' 值是 '''undefined''' 或 '''null'''，本规范之前版本中任何会在 '''第1步''' 抛出的异常，都会继续在本规范中抛出。{{extra note||在第1步和第2步都会抛出异常时优先抛出第一步的异常。}}}}


=== {{anchor|x15.2.5}}Object 的实例的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.2.5}}

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

== {{anchor|x15.3}}Function 对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.3}}


=== {{anchor|x15.3.1}}作为函数调用 Function 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.1}}

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


==== {{anchor|x15.3.1.1}}Function (p1, p2, … , pn, body) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.1.1}}

当以 <var>p1</var>、<var>p2</var>、…、<var>pn</var> 和 <var>body</var> 作为参数调用 '''Function''' 函数（这里的 <var>n</var> 可以是 '''0'''，也就是说没有“<var>p</var>”参数，这时还可以不提供 <var>body</var>），采用如下步骤：
# 创建并返回一个新函数对象，它仿佛是用相同参数给标准内置构造器 '''Function''' ([[#x15.3.2.1|15.3.2.1]]). 用一个 '''new''' 表达式创建的。


=== {{anchor|x15.3.2}}Function 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.2}}

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


==== {{anchor|x15.3.2.1}}new Function (p1, p2, … , pn, body) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.2.1}}

最后一个参数指定为函数的 <var>body</var>（可执行代码）；之前的任何参数都指定为形式参数。

当以 <var>p1</var>、<var>p2</var>、…、<var>pn</var> 和 <var>body</var> 作为参数调用 '''Function''' 构造器（这里的 <var>n</var> 可以是 '''0'''，也就是说没有“<var>p</var>”参数，这时还可以不提供 <var>body</var>），采用如下步骤：

# 令 <var>argCount</var> 为传给这个函数调用的参数总数。
# 令 <var>P</var> 为空字符串。
# 如果 <var>argCount</var> = '''0'''，令 <var>body</var> 为空字符串。
# 否则如果 <var>argCount</var> = '''1'''，令 <var>body</var> 为那个参数。
# 否则，<var>argCount</var> > '''1'''
## 令 <var>firstArg</var> 为第一个参数。
## 令 <var>P</var> 为 [[ES5/conversion#ToString|ToString]]( <var>firstArg</var> )。
## 令 <var>k</var> 为 '''2'''。
## 只要 <var>k</var> < <var>argCount</var> 就重复 
### 令 <var>nextArg</var> 为第 <var>k</var> 个参数。
### 令 <var>P</var> 为之前的 <var>P</var> 值，字符串 '''","'''（一个逗号），[[ES5/conversion#ToString|ToString]]( <var>nextArg</var> ) 串联的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13175#1678||Join String}}
### <var>k</var> 递增 '''1'''。
## 令 <var>body</var> 为第 <var>k</var> 个参数。
# 令 <var>body</var> 为 [[ES5/conversion#ToString|ToString]]( <var>body</var> )。
# 如果 <var>P</var> 不可解析为一个 [[ES5/functions#FormalParameterList|FormalParameterList]]，则抛出一个 '''SyntaxError''' 异常。{{extra note||<nowiki>如果参数中存在不合法的变量名就会出现这种情况。例如：&#13;new Function("0","");</nowiki>}} {{extra note||<nowiki>参数列表是允许注释的，例如：&#13;new Function("a/*注释*/","");</nowiki>}} {{v8 partial||<nowiki>v8中不单独对这个字符串检测FormalParameterList，而是直接把它用于生成函数。但是由于v8在函数模板的第二行包含一个注释，导致了这个字符串有可能不是FormalParameterList，例如：&#13;new Function("/*","");&#13;这个代码在v8中是不会抛出异常的。</nowiki>}}
# 如果 <var>body</var> 不可解析为 [[ES5/functions#FunctionBody|FunctionBody]]，则抛出一个 '''SyntaxError''' 异常。{{extra note||<nowiki>如果函数体中存在语法错误就在这里抛出异常。例如：&#13;new Function("%");</nowiki>}} {{v8 partial|http://www.w3.org/html/ig/zh/wiki/ES5/errors|<nowiki>不会抛出某些早期错误。例如：&#13;new Function("0=1");&#13;这个代码在v8中不报错。</nowiki>}}
# 如果 <var>body</var> 是严格模式代码 ( 见 [[ES5/execution#x10.1.1|10.1.1]])，则令 <var>strict</var> 为 '''true'''，否则令 <var>strict</var> 为 '''false'''。
# 如果 <var>strict</var> 是 '''true'''，适用 [[ES5/functions#x13.1|13.1]] 指定抛出的任何异常。
# 返回一个新创建的函数对象，它是依照 [[ES5/functions#x13.2|13.2]] 专递 <var>P</var> 作为 [[ES5/functions#FormalParameterList|FormalParameterList]]、<var>body</var> 作为 [[ES5/functions#FunctionBody|FunctionBody]]、[[ES5/execution#x10.2.3|全局环境]]作为 [[ES5/types#Scope|Scope]] 参数、<var>strict</var> 作为严格模式标志。

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

{{note| 为每个形参指定一个参数是允许的，但没必要。例如以下三个表达式产生相同的结果：}}

  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")


=== {{anchor|x15.3.3}}Function 构造器的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.3}}

'''Function''' 构造器自身是个函数对象，它的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 是 '''"Function"'''。'''Function''' 构造器的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性值是标准内置 '''Function''' 的 '''prototype''' 对象 ([[#x15.3.4|15.3.4]])。

'''Function''' 构造器的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性值是 '''true'''.

Function 构造器有如下属性 :


==== {{anchor|x15.3.3.1}}Function.prototype ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.3.1}}

'''Function.prototype''' 的初始值是标准内置 '''Function''' 的 '''prototype''' 对象 ([[#x15.3.4|15.3.4]])。

此属性拥有特性 <nowiki>{ [[Writable]]:</nowiki> '''false'''<nowiki>, [[Enumerable]]:</nowiki> '''false'''<nowiki>, [[Configurable]]:</nowiki> '''false''' <nowiki>}</nowiki>。


==== {{anchor|x15.3.3.2}}Function.length ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.3.2}}

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


=== {{anchor|x15.3.4}}Function 的 prototype 对象的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.4}}

'''Function''' 的 '''prototype''' 对象自身是一个函数对象 ( 它的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 是 '''"Function"''')，调用这个函数对象时，接受任何参数并返回 '''undefined'''。 {{extra note||注意这个对象具有[[Call]]内置方法，所以它是可调用的。}}

'''Function''' 的 '''prototype''' 对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性值是标准内置 '''Object''' 的 '''prototype''' 对象 ([[#x15.2.4|15.2.4]])。'''Function''' 的 '''prototype''' 对象的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性的初始值是 '''true'''。

'''Function''' 的 '''prototype''' 对象自身没有 '''valueOf''' 属性 ; 但是，它从 '''Object''' 的 '''prototype''' 对象继承了 '''valueOf''' 属性。

'''Function''' 的 '''prototype''' 对象的 '''length''' 属性是 '''0'''。


===={{anchor|x15.3.4.1}}Function.prototype.constructor====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.4.1}}

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


===={{anchor|x15.3.4.2}}Function.prototype.toString ( )====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.4.2}}

此函数的返回值的表示是依赖于实现的。这个表示包含 [[ES5/functions#FunctionDeclaration|FunctionDeclaration]] 的语法。特别注意，怎样在这个字符串表示中使用和放置空白、行终止符、分号，是依赖于实现的。 {{extra note||还可以包含注释。}} {{ie partial||<nowiki>由于IE中支持条件编译语句，而function关键之之外 的东西不会被包含在toString的返回值中，导致了这个toString语句的结果可能不是FunctionDeclaration的语法。例如：&#13;(/*@cc_on function@*/(){}).toString()</nowiki>}}

这个 '''toString''' 不是通用的；如果它的 '''this''' 值不是一个函数对象，它会抛出一个 '''TypeError''' 异常。因此，它不能当做方法来转移到其他类型的对象中。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13175#1583|Throw TypeError}}


===={{anchor|x15.3.4.3}}Function.prototype.apply (thisArg, argArray)====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.4.3}}

当以 <var>thisArg</var> 和 <var>argArray</var> 为参数在一个 <var>func</var> 对象上调用 '''apply''' 方法，采用如下步骤：

# 如果 [[ES5/conversion#IsCallable|IsCallable]]( <var>func</var> ) 是 '''false'''，则抛出一个 '''TypeError''' 异常。
# 如果 <var>argArray</var> 是 '''null''' 或 '''undefined'''，则 
## 返回提供 <var>thisArg</var> 作为 '''this''' 值并以空参数列表调用 <var>func</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法的结果。
# 如果 [[ES5/types#Type|Type]]( <var>argArray</var> ) 不是 '''Object'''，则抛出一个 '''TypeError''' 异常。
# 令 <var>len</var> 为以 '''"length"''' 作为参数调用 <var>argArray</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 令 <var>n</var> 为 [[ES5/conversion#to-uint32|ToUint32]]( <var>len</var> )。
# 令 <var>argList</var> 为一个空列表。
# 令 <var>index</var> 为 '''0'''。
# 只要 <var>index</var> < <var>n</var> 就重复 
## 令 <var>indexName</var> 为 [[ES5/conversion#ToString|ToString]]( <var>index</var> )。
## 令 <var>nextArg</var> 为以 <var>indexName</var> 作为参数调用 <var>argArray</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
## 将 <var>nextArg</var> 作为最后一个元素插入到 <var>argList</var> 里。
## 设定 <var>index</var> 为 <var>index</var> + '''1'''。
# 提供 <var>thisArg</var> 作为 '''this''' 值并以 <var>argList</var> 作为参数列表，调用 <var>func</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法，返回结果。

'''apply''' 方法的 '''length''' 属性是 '''2'''。

{{note| 在外面传入的 '''''thisArg''''' 值会修改并成为 '''this''' 值。'''''thisArg''''' 是 '''undefined''' 或 '''null''' 时它会被替换成全局对象，所有其他值会被应用 '''ToObject''' 并将结果作为 '''this''' 值，这是第三版引入的更改。}}


==== {{anchor|x15.3.4.4}}Function.prototype.call (thisArg [ , arg1 [ , arg2, … ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.4.4}}

当以 <var>thisArg</var> 和可选的 <var>arg1</var>、<var>arg2</var> 等等作为参数在一个 <var>func</var> 对象上调用 '''call''' 方法，采用如下步骤：

# 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>func</var>) 是 '''false'''，则抛出一个 '''TypeError''' 异常。
# 令 <var>argList</var> 为一个空列表。
# 如果调用这个方法的参数多余一个，则从 <var>arg1</var> 开始以从左到右的顺序将每个参数插入为 <var>argList</var> 的最后一个元素。
# 提供 <var>thisArg</var> 作为 '''this''' 值并以 <var>argList</var> 作为参数列表，调用 <var>func</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法，返回结果。

'''call''' 方法的 '''length''' 属性是 '''1'''。

{{note| 在外面传入的 '''''thisArg''''' 值会修改并成为 '''this''' 值。'''''thisArg''''' 是 '''undefined''' 或 '''null''' 时它会被替换成全局对象，所有其他值会被应用 '''ToObject''' 并将结果作为 '''this''' 值，这是第三版引入的更改。}}

==== {{anchor|x15.3.4.5}}Function.prototype.bind (thisArg [, arg1 [, arg2, …]]) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.4.5}}

'''bind''' 方法需要一个或更多参数，<var>thisArg</var> 和（可选的）<var>arg1</var>、<var>arg2</var>，等，执行如下步骤返回一个新函数对象：

# 令 <var>Target</var> 为 '''this''' 值 .
# 如果 [[ES5/conversion#IsCallable|IsCallable]]( <var>Target</var> ) 是 '''false'''，抛出一个 '''TypeError''' 异常 .{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13175#1612|Throw TypeError}}
# 令 <var>A</var> 为一个（可能为空的）新内部列表，它包含按顺序的 <var>thisArg</var> 后面的所有参数（<var>arg1</var>、<var>arg2</var>，等）。
# 令 <var>F</var> 为一个新原生 ECMAScript 对象。
# 依照 [[ES5/types#x8.12|8.12]] 指定，设定 <var>F</var> 的除了 '''<nowiki>[[Get]]</nowiki>''' 之外的所有内部方法。
# 依照 [[ES5/builtins#x15.3.5.4|15.3.5.4]] 指定，设定 <var>F</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部属性。
# 设定 <var>F</var> 的 [[ES5/types#TargetFunction|<nowiki>[[TargetFunction]]</nowiki>]] 内部属性为 <var>Target</var>。
# 设定 <var>F</var> 的 [[ES5/types#BoundThis|<nowiki>[[BoundThis]]</nowiki>]] 内部属性为 <var>thisArg</var> 的值。
# 设定 <var>F</var> 的 [[ES5/types#BoundArgs|<nowiki>[[BoundArgs]]</nowiki>]] 内部属性为 <var>A</var>。
# 设定 <var>F</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性为 '''"Function"'''。
# 设定 <var>F</var> 的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性为 [[#x15.3.3.1|15.3.3.1]] 指定的标准内置 '''Function''' 的 '''prototype''' 对象。
# 依照 [[#x15.3.4.5.1|15.3.4.5.1]] 描述，设定 <var>F</var> 的 '''<nowiki>[[Call]]</nowiki>''' 内置属性。
# 依照 [[#x15.3.4.5.2|15.3.4.5.2]] 描述，设定 <var>F</var> 的 '''<nowiki>[[Construct]]</nowiki>''' 内置属性。
# 依照 [[#x15.3.4.5.3|15.3.4.5.3]] 描述，设定 <var>F</var> 的 '''<nowiki>[[HasInstance]]</nowiki>''' 内置属性。
# 如果 <var>Target</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性是 '''"Function"'''，则 
## 令 <var>L</var> 为 <var>Target</var> 的 '''length''' 属性减 <var>A</var> 的长度。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13175#1652|Throw TypeError}}
## 设定 <var>F</var> 的 '''length''' 自身属性为 '''0''' 和 <var>L</var> 中更大的值。
# 否则设定 <var>F</var> 的 '''length''' 自身属性为 '''0'''.
# 设定 <var>F</var> 的 '''length''' 自身属性的特性为 [[#x15.3.5.1|15.3.5.1]] 指定的值。
# 设定 <var>F</var> 的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性为 '''true'''。
# 令 <var>thrower</var> 为 [[ES5/functions#ThrowTypeError|<nowiki>[[ThrowTypeError]]</nowiki>]] 函数对象 ([[ES5/functions#ThrowTypeError|13.2.3]])。
# 以 '''"caller"''', 属性描述符 <nowiki>{[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]:</nowiki> '''false'''<nowiki>, [[Configurable]]:</nowiki> '''false'''<nowiki>},</nowiki> 和 '''false''' 作为参数调用 F 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
# 以 '''"arguments"''', 属性描述符 <nowiki>{[[Get]]: </nowiki><var>thrower</var><nowiki>, [[Set]]: </nowiki><var>thrower</var><nowiki>, [[Enumerable]]:</nowiki> '''false'''<nowiki>, [[Configurable]]:</nowiki> '''false'''<nowiki>}</nowiki>, 和 '''false''' 作为参数调用 F 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
# 返回 <var>F</var>.

'''bind''' 方法的 '''length''' 属性是 '''1'''。

{{note|'''Function.prototype.bind''' 创建的函数对象不包含 '''prototype''' 属性或 '''<nowiki>[[Code]]</nowiki>'''、'''<nowiki>[[FormalParameters]]</nowiki>'''、'''<nowiki>[[Scope]]</nowiki>''' 内部属性。}}


===== {{anchor|x15.3.4.5.1}}<nowiki>[[Call]]</nowiki> =====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.4.5.1}}

当调用一个用 '''bind''' 函数创建的函数对象 <var>F</var> 的 '''<nowiki>[[Call]]</nowiki>''' 内部方法，传入一个 '''this''' 值和一个参数列表 <var>ExtraArgs</var>，采用如下步骤：

# 令 <var>boundArgs</var> 为 <var>F</var> 的 [[ES5/types#BoundArgs|<nowiki>[[BoundArgs]]</nowiki>]] 内部属性值。
# 令 <var>boundThis</var> 为 <var>F</var> 的 [[ES5/types#BoundThis|<nowiki>[[BoundThis]]</nowiki>]] 内部属性值。
# 令 <var>target</var> 为 <var>F</var> 的 [[ES5/types#TargetFunction|<nowiki>[[TargetFunction]]</nowiki>]] 内部属性值。
# 令 <var>args</var> 为一个新列表，它包含与列表 <var>boundArgs</var> 相同顺序相同值，后面跟着与 <var>ExtraArgs</var> 是相同顺序相同值。
# 提供 <var>boundThis</var> 作为 '''this''' 值，提供 <var>args</var> 为参数调用 <var>target</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法，返回结果。


===== {{anchor|x15.3.4.5.2}}<nowiki>[[Construct]]</nowiki> =====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.4.5.2}}

当调用一个用 '''bind''' 函数创建的函数对象 <var>F</var> 的 '''<nowiki>[[Construct]]</nowiki>''' 内部方法，传入一个参数列表 <var>ExtraArgs</var>，采用如下步骤：

# 令 <var>target</var> 为 <var>F</var> 的 [[ES5/types#TargetFunction|<nowiki>[[TargetFunction]]</nowiki>]] 内部属性值。
# 如果 <var>target</var> 不包含 [[ES5/types#Construct|<nowiki>[[Construct]]</nowiki>]] 内部方法，抛出一个 '''TypeError''' 异常。
# 令 <var>boundArgs</var> 为 <var>F</var> 的 [[ES5/types#BoundArgs|<nowiki>[[BoundArgs]]</nowiki>]] 内部属性值。
# 令 <var>args</var> 为一个新列表，它包含与列表 <var>boundArgs</var> 相同顺序相同值，后面跟着与 <var>ExtraArgs</var> 是相同顺序相同值。
# 提供 <var>args</var> 为参数调用 <var>target</var> 的 [[ES5/types#Construct|<nowiki>[[Construct]]</nowiki>]] 内部方法，返回结果。


===== {{anchor|x15.3.4.5.3}}<nowiki>[[HasInstance]]</nowiki> (V) =====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.4.5.3}}

当调用一个用 '''bind''' 函数创建的函数对象 <var>F</var> 的 '''<nowiki>[[HasInstance]]</nowiki>''' 内部方法，并以 <var>V</var> 作为参数，采用如下步骤：

# 令 <var>target</var> 为 <var>F</var> 的 [[ES5/types#TargetFunction|<nowiki>[[TargetFunction]]</nowiki>]] 内部属性值。
# 如果 <var>target</var> 不包含 [[ES5/types#HasInstance|<nowiki>[[HasInstance]]</nowiki>]] 内部方法，抛出一个 '''TypeError''' 异常。
# 提供 <var>V</var> 为参数调用 <var>target</var> 的 [[ES5/types#HasInstance|<nowiki>[[HasInstance]]</nowiki>]] 内部方法，返回结果。


=== {{anchor|x15.3.5}}Function 的实例的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.5}}

除了必要的内部属性之外，每个函数实例还有一个 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性并且在大多数情况下使用不同版本的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部属性。函数实例根据怎样创建的（见 [[ES5/types#x8.6.2|8.6.2]]、[[ES5/functions#x13.2|13.2]]、[[#|15]]、[[#x15.3.4.5|15.3.4.5]]）可能还有一个 [[ES5/types#HasInstance|<nowiki>[[HasInstance]]</nowiki>]] 内部属性、一个 [[ES5/types#Scope|<nowiki>[[Scope]]</nowiki>]] 内部属性、一个 [[ES5/types#Construct|<nowiki>[[Construct]]</nowiki>]] 内部属性、一个 [[ES5/types#FormalParameters|<nowiki>[[FormalParameters]]</nowiki>]] 内部属性、一个 [[ES5/types#Code|<nowiki>[[Code]]</nowiki>]] 内部属性、一个 [[ES5/types#TargetFunction|<nowiki>[[TargetFunction]]</nowiki>]] 内部属性、一个 [[ES5/types#BoundThis|<nowiki>[[BoundThis]]</nowiki>]] 内部属性、一个 [[ES5/types#BoundArgs|<nowiki>[[BoundArgs]]</nowiki>]] 内部属性。

[[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性的值是 '''"Function"'''。

对应于严格模式函数 ([[ES5/functions#x13.2|13.2]]) 的函数实例和用 '''Function.prototype.bind''' 方法 ([[#x15.3.4.5|15.3.4.5]]) 创建的函数实例有名为“'''caller'''”和 “'''arguments'''”的属性时，抛出一个 '''TypeError''' 异常。一个 ECMAScript 实现不得为在严格模式函数代码里访问这些属性关联任何依赖实现的特定行为。 {{v8|https://github.com/v8/v8/blob/3.22/src/bootstrapper.cc#L644|}}


==== {{anchor|x15.3.5.1}}length ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.5.1}}

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


==== {{anchor|x15.3.5.2}}prototype ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.5.2}}

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

{{note| 用 '''Function.prototype.bind''' 创建的函数对象没有 '''prototype''' 属性。}}


===={{anchor|x15.3.5.3}}<nowiki>[[HasInstance]]</nowiki> (V)====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.5.3}}

设 <var>F</var> 是个函数对象。
当以 <var>V</var> 作为参数调用 <var>F</var> 的 '''<nowiki>[[HasInstance]]</nowiki>''' 内部方法，采用如下步骤：

# 如果 <var>V</var> 不是个对象，返回 '''false'''。
# 令 <var>O</var> 为用属性名 '''"prototype"''' 调用 <var>F</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是 '''Object'''，抛出一个 '''TypeError''' 异常。
# 重复 
## 令 <var>V</var> 为 <var>V</var> 的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性值。
## 如果 <var>V</var> 是 '''null'''，返回 '''false'''。
## 如果 <var>O</var> 和 <var>V</var> 指向相同对象，返回 '''true'''。

{{note| 用 '''Function.prototype.bind''' 创建的函数对象拥有的不同的 '''<nowiki>[[HasInstance]]</nowiki>''' 实现，在 15.3.4.5.3 中定义。}}


==== {{anchor|x15.3.5.4}}<nowiki>[[Get]]</nowiki> (P) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.3.5.4}}

函数对象与其他原生 EMACScript 对象 ([[ES5/types#x8.12.3|8.12.3]]) 用不同的 '''<nowiki>[[Get]]</nowiki>''' 内部方法。

设 <var>F</var> 是一个函数对象，当以属性名 <var>P</var> 调用 <var>F</var> 的 '''<nowiki>[[Get]]</nowiki>''' 内部方法，采用如下步骤：

# 令 <var>v</var> 为传入 <var>P</var> 作为属性名参数调用 <var>F</var> 的默认 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法 ([[ES5/types#8.12.3|8.12.3]]) 的结果。
# 如果 <var>P</var> 是 '''"caller"''' 并且 <var>v</var> 是个严格模式函数对象，抛出一个 '''TypeError''' 异常。
# 返回 <var>v</var>。

{{note| 用 '''Function.prototype.bind''' 创建的函数对象使用默认的 '''<nowiki>[[Get]]</nowiki>''' 内部方法。}}

== {{anchor|x15.4}}Array 对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.4}}

数组对象会给予一些特定种类的属性名特殊待遇。对一个属性名 <var>P</var>（字符串形式），当且仅当 [[ES5/conversion#to-string|ToString]]([[ES5/conversion#to-uint32|ToUint32]](<var>P</var>)) 等于 <var>P</var> 并且 [[ES5/conversion#to-uint32|ToUint32]](<var>P</var>) 不等于 '''2<sup>32</sup> - 1''' 时，它是个''数组索引''。一个属性名是数组索引的属性还叫做''元素 ''。所有数组对象都有一个 '''length''' 属性，其值始终是一个小于 '''2<sup>32</sup>''' 的非负整数。'''length''' 属性值在数值上比任何名为数组索引的属性名称还要大；每当创建或更改一个数组对象的属性，都要调整其他属性以保持上面那个条件不变。具体来说，每当添加一个名为数组索引的属性时，如果需要就更改 '''length''' 属性为在数值上比这个数组索引大 '''1''' 的值；每当更改 '''length''' 属性，所有属性名是数组索引并且其值不小于新 '''length''' 的属性会被自动删除。{{extra note||无法删除的元素会阻length的进一步缩小，但一些引擎尚未实现。}} 这个限制只应用于数组对象的自身属性，并且从原型中继承的 '''length''' 或数组索引不影响这个限制。

对一个对象 <var>O</var>，如果以下算法返回 '''true'''，那么就叫这个对象为 <b title="sparse">稀疏</b> 的：

# 令 <var>len</var> 为以 '''"length"''' 作为参数调用 O 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 对每个范围在 '''0''' ≤ <var>i</var> &lt; [[ES5/conversion#to-uint32|ToUint32]](<var>len</var>) 的整数 <var>i</var>
## 令 <var>elem</var> 为以 [[ES5/conversion#to-string|ToString]](<var>i</var>) 作为参数调用 <var>O</var> 的 [[ES5/types#GetOwnProperty|<nowiki>[[GetOwnProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>elem</var> 是 '''undefined'''，返回 '''true'''。
# 返回 '''false'''。


=== {{anchor|x15.4.1}}作为函数调用 Array 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.1}}

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


==== {{anchor|x15.4.1.1}}Array ( [ item1 [ , item2 [ , … ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.1.1}}

当调用 '''Array''' 函数，采用如下步骤：

# 创建并返回一个新函数对象，它仿佛是用相同参数给标准内置构造器 '''Array''' 用一个 '''new''' 表达式创建的 ([[ES5/builtins#x15.4.2|15.4.2]])。


=== {{anchor|x15.4.2}}Array 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.2}}

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


==== {{anchor|x15.4.2.1}}new Array ( [ item0 [ , item1 [ , … ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.2.1}}

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

新构造对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性要设定为原始的数组原型对象，他是 Array.prototype([[ES5/builtins#x15.4.3.1|15.4.3.1]]) 的初始值。

新构造对象的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性要设定为 '''"Array"'''。

新构造对象的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性要设定为 '''true'''。

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

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


==== {{anchor|x15.4.2.2}}new Array (len) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.2.2}}

新构造对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性要设定为原始的数组原型对象，他是 Array.prototype([[ES5/builtins#x15.4.3.1|15.4.3.1]]) 的初始值。新构造对象的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性要设定为 '''"Array"'''。新构造对象的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性要设定为 '''true'''。

如果参数 <var>len</var> 是个[[ES5/types#Number|Number值]] 并且 [[ES5/conversion#to-uint32|ToUint32]](<var>len</var>) 等于 <var>len</var>，则新构造对象的 '''length''' 属性要设定为 [[ES5/conversion#to-uint32|ToUint32]](<var>len</var>)。如果参数 <var>len</var> 是个数字值并且 [[ES5/conversion#to-uint32|ToUint32]](<var>len</var>) 不等于 <var>len</var>，则抛出一个 '''RangeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/api.cc?r{{=}}13175#5222|Set Length}}

如果参数 <var>len</var> 不是[[ES5/types#Number|Number值]]，则新构造对象的 '''length''' 属性要设定为 '''0'''，并且新构造对象的 '''0''' 属性要设定为 <var>len</var>，设定它的特性为 { &#91;[Writable]]: '''true''', &#91;[Enumerable]]: '''true''', &#91;[Configurable]]: '''true''' }。


=== {{anchor|x15.4.3}}Array 构造器的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.3}}

'''Array''' 构造器的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性值是函数原型对象 ([[ES5/builtins#x15.3.4|15.3.4]])。

'''Array''' 构造器除了有一些内部属性和 '''length''' 属性（其值是 '''1'''）之外，还有如下属性：


==== {{anchor|x15.4.3.1}}Array.prototype ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.3.1}}

'''Array.prototype''' 的初始值是数组原型对象 ([[ES5/builtins#x15.4.4|15.4.4]])。

此属性拥有特性 { &#91;[Writable]]: '''false''', &#91;[Enumerable]]: '''false''', &#91;[Configurable]]: '''false''' }。

==== {{anchor|x15.4.3.2}}Array.isArray ( arg ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.3.2}}


'''isArray''' 函数需要一个参数 arg，如果参数是个对象并且 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性是 '''"Array"'''，返回布尔值 '''true'''；否则它返回 '''false'''。采用如下步骤：

# 如果 [[ES5/types|Type]](arg) 不是 '''Object'''，返回 '''false'''。
# 如果 arg 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性值是 '''"Array"'''，则返回 '''true'''。
# 返回 '''false'''。

=== {{anchor|x15.4.4}}数组原型对象的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4}}


数组原型对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性值是标准内置 [[ES5/builtins#x15.2|Object]] 原型对象 ([[ES5/builtins#x15.2.4|15.2.4]])。

数组原型对象自身是个数组；它的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 是 '''"Array"'''，它拥有一个 '''length''' 属性（初始值是 '''+0'''）和 [[ES5/builtins#x15.4.5.1|15.4.5.1]] 描述的特殊的 [[ES5/builtins#x15.4.5.1|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。

在以下的对数组原型对象的属性函数的描述中，短语'''“this 对象”'''指的是调用这个函数时的 '''this''' 值对象。允许 '''this''' 是 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性值不是 '''"Array"''' 的对象。

{{note| 数组原型对象自身没有 '''valueOf''' 属性；但它从标准内置 '''Object''' 原型对象继承 '''valueOf''' 属性。}}


==== {{anchor|x15.4.4.1}}Array.prototype.constructor ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.1}}

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


==== {{anchor|x15.4.4.2}}Array.prototype.toString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.2}}

当调用 '''toString''' 方法，采用如下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L349|v8在实现上加了一些性能优化}}

# 令 <var>array</var> 为用 '''this''' 值调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>func</var> 为以 '''"join"''' 作为参数调用 <var>array</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>func</var>) 是 '''false'''，则令 <var>func</var> 为标准内置方法 '''Object.prototype.toString''' ([[ES5/builtins#x15.2.4.2|15.2.4.2]])。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#199|Default String}}
# 提供 <var>array</var> 作为 '''this''' 值并以空参数列表调用 <var>func</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法，返回结果。

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


==== {{anchor|x15.4.4.3}}Array.prototype.toLocaleString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.3}}

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

结果是按照一下方式计算的：{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L369|为了节省一些代码和Join共用组合分隔符的函数，动态传入转换函数，这不影响到结果}}

# 令 <var>array</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>arrayLen</var> 为以 '''"length"''' 作为参数调用 <var>array</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>arrayLen</var>)。
# 令 <var>separator</var> 为宿主环境的当前语言环境对应的列表分隔符字符串（这是实现定义的方式得到的）。{{extra note||Chrome和Firefox中这个分隔符是半角逗号，IE中这个分隔符是半角逗号后面加个空格。}}
# 如果 <var>len</var> 是零，返回空字符串。
# 令 <var>firstElement</var> 为以 '''"0"''' 作为参数调用 <var>array</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 如果 <var>firstElement</var> 是 '''undefined''' 或 '''null'''，则 
## 令 <var>R</var> 为空字符串。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#205|Return Empty String}}
# 否则 
## 令 <var>elementObj</var> 为 [[ES5/conversion#to-object|ToObject]](<var>firstElement</var>).
## 令 <var>func</var> 为以 '''"toLocaleString"''' 作为参数调用 <var>elementObj</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
## 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>func</var>) 是 '''false'''，抛出一个 '''TypeError''' 异常。
## 令 <var>R</var> 为提供 <var>elementObj</var> 作为 '''this''' 值并以空参数列表调用 <var>func</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法的结果。
# 令 <var>k</var> 为 '''1'''。
# 只要 <var>k</var> &lt; <var>len</var> 就重复 
## 令 <var>S</var> 为串联 <var>R</var> 和 <var>separator</var> 产生的字符串。
## 令 <var>nextElement</var> 为以 [[ES5/conversion#ToString|ToString]](<var>k</var>) 作为参数调用 <var>array</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
## 如果 <var>nextElement</var> 是 '''undefined''' 或 '''null'''，则 
### 令 <var>R</var> 为空字符串。
## 否则 
### 令 <var>elementObj</var> 为 [[ES5/conversion#to-object|ToObject]](<var>nextElement</var>).
### 令 <var>func</var> 为以 '''"toLocaleString"''' 作为参数调用 <var>elementObj</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>func</var>) 是 '''false'''，抛出一个 '''TypeError''' 异常。
### 令 <var>R</var> 为提供 <var>elementObj</var> 作为 '''this''' 值并以空参数列表调用 <var>func</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法的结果。
## 令 <var>R</var> 为串联 <var>S</var> 和 <var>R</var> 产生的字符串。
## <var>k</var> 递增 '''1'''。
# 返回 <var>R</var>

{{note|此函数的第一个参数可能会在本标准的未来版本中用到；建议实现不要以任何其他用途使用这个参数位置。}}

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

==== {{anchor|x15.4.4.4}}Array.prototype.concat ( [ item1 [ , item2 [ , … ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.4}}

当以零个或更多个参数 <var>item1</var>、<var>item2</var>，等，调用 '''concat''' 方法时，会返回一个数组。 返回的数组包含 调用对象的数组元素{{extra note||如果调用对象的类型是Array，则返回的数组会包含这个调用对象的数组元素。否则调用对象本身将是返回数组的首个元素。}} 和随后顺序每个参数的数组元素{{extra note||遍历每个参数，如果遍历到的参数的类型是Array则把它的每个元素取出来放入需要返回的数组，否则把它自身放入需要返回的数组。}}。

采用如下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L483|普通实现}} {{v8|https://github.com/v8/v8/blob/3.21/src/builtins.cc#L1065|快速版}}

# 令 <var>O</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#478|ToObject}}
# 令 <var>A</var> 为仿佛是用表达式 '''new Array()''' 创建的新数组，这里的 '''Array''' 是标准内置构造器名。
# 令 <var>n</var> 为 '''0'''。
# 令 <var>items</var> 为一个内部列表，他的第一个元素是 '''O'''，之后的元素是调用时传给这个函数的各参数（以从左到右的顺序）。
# 只要 <var>items</var> 不是空就重复 
## 删除 <var>items</var> 的第一个元素，并令 <var>E</var> 为这个元素值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#481|Replace First Element}}
## 如果 <var>E</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性是 '''"Array"'''，则 
### 令 <var>k</var> 为 '''0'''。
### 令 <var>len</var> 为以 '''"length"''' 为参数调用 <var>E</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 只要 <var>k</var> < <var>len</var> 就重复 
#### 令 <var>P</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>).
#### 令 <var>exists</var> 为以 <var>P</var> 作为参数调用 <var>E</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
#### 如果 <var>exists</var> 是 '''true'''，则 
##### 令 <var>subElement</var> 为以 <var>P</var> 作为参数调用 <var>E</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
##### 以 [[ES5/conversion#ToString|ToString]](<var>n</var>)、属性描述符 { &#91;[Writable]]: '''true''', &#91;[Enumerable]]: '''true''', &#91;[Configurable]]: '''true''' } 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
#### <var>n</var> 递增 '''1'''。
#### <var>k</var> 递增 '''1'''。
## 否则，<var>E</var> 不是数组 
### 以 [[ES5/conversion#ToString|ToString]](n)、属性描述符 { &#91;[Value]]: E, &#91;[Writable]]: '''true''', &#91;[Enumerable]]: '''true''', &#91;[Configurable]]: '''false''' } 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
### <var>n</var> 递增 '''1'''。
# 返回 <var>A</var>。

'''concat''' 方法的 '''length''' 属性是 '''1'''。

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


==== {{anchor|x15.4.4.5}}Array.prototype.join (separator) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.5}}

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

'''join''' 方法需要一个参数 <var>separator</var>，执行以下步骤 :{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L378|}}

# 令 <var>O</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>lenVal</var> 为以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenVal</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#416|Set Length}}
# 如果 <var>separator</var> 是 '''undefined'''，令 <var>separator</var> 为单字符字符串 '''","'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#418|Default Comma}}
# 令 <var>sep</var> 为 [[ES5/conversion#ToString|ToString]](<var>separator</var>)。
# 如果 <var>len</var> 是零，返回空字符串。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#120|Return Empty String}}
# 令 <var>element0</var> 为以 '''"0"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 如果 <var>element0</var> 是 '''undefined''' 或 '''null''', 令 <var>R</var> 为空字符串；否则，令 <var>R</var> 为 [[ES5/conversion#ToString|ToString]](<var>element0</var>)。
# 令 <var>k</var> 为 '''1'''.
# 只要 <var>k</var> &lt; <var>len</var> 就重复 
## 令 <var>S</var> 为串联 <var>R</var> 和 <var>sep</var> 产生的字符串值。 {{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L160|串联字符串是性能开销巨大的操作，所以v8没有这么实现，而是使用一个数组临时存放各字符串，最后再一次性合并}}
## 令 <var>element</var> 为以 [[ES5/conversion#ToString|ToString]](<var>k</var>) 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
## 如果 <var>element</var> 是 '''undefined''' 或 '''null'''，令 <var>next</var> 为空字符串；否则，令 <var>next</var> 为 [[ES5/conversion#ToString|ToString]](<var>element</var>)。
## 令 <var>R</var> 为串联 <var>S</var> 和 <var>next</var> 产生的字符串值。
## <var>k</var> 递增 '''1'''。
# 返回 <var>R</var>。

'''join''' 方法的 '''length''' 属性是 '''1'''。

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


==== Array.prototype.pop ( ){{anchor|x15.4.4.6}}{{anchor|Array.prototype.pop}} ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.6}}
{{test262|http://hg.ecmascript.org/tests/test262/file/tip/test/suite/ch15/15.4/15.4.4/15.4.4.6}}

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

# 令 <var>O</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果{{v8 partial|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13276#430|并没有用 ToObject 所以在：<nowiki>Object.defineProperty(Number.prototype, "length", {get: function(){ Object.defineProperty(this, "length", {set: function(x){ print("I should be called"); } }); return 0; }}); Array.prototype.pop.call(1);</nowiki> 之类的副作用不会残留在 O 上（<nowiki>Array.prototype.pop.call(Object(1));</nowiki> 的副作用就会残留）。很多的 Array.prototype 方法也有类似的问题。}}。
# 令 <var>lenVal</var> 为以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenVal</var>)。
# 如果 <var>len</var> 是零
## 以 '''"length"'''、'''0''' 和 '''true'''{{v8 partial|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13276#430|在这里 V8 并没有用 '''true'''，测试案例：<nowiki>var x = {length: 0}; Object.freeze(x); void function(){ "use strict"; Array.prototype.pop.call(x); }();</nowiki>。很多用到 <nowiki>[[Put]]</nowiki> 且第三个参数是 true 的 Array.prototype 方法都有类似的问题。}}{{moz partial||同上}} 作为参数调用 ''O'' 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。{{extra note||这步的目的是，如果调用对象的length不是有效的Uint32则调用完这个方法后就将其设置为0}}
## 返回 '''undefined'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13276#441||ArrayPop-ReturnUndefined}}
# 否则，<var>len</var> &gt; '''0'''
## 令 <var>indx</var> 为 [[ES5/conversion#to-string|ToString]](<var>len</var> - '''1''')。
## 令 <var>element</var> 为以 <var>indx</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
## 以 <var>indx</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13276#445||ArrayPop-Delete}}
## 以 '''"length"'''、<var>indx</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法{{bug|https://bugs.ecmascript.org/show_bug.cgi?id{{=}}163|indx 在这里是一个字符串，并不正确。这在 ES6 已经更正了。}}。
## 返回 <var>element</var>。

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


==== {{anchor|x15.4.4.7}}Array.prototype.push ( [ item1 [ , item2 [ , … ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.7}}

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

当以零或更多个参数 <var>item1</var>、<var>item2</var>，等，调用 '''push''' 方法，采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L461|}}

# 令 <var>O</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。
# 令 <var>lenVal</var> 为以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#459|This.Length}}
# 令 <var>n</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenVal</var>)。
# 令 <var>items</var> 为一个内部列表，它的元素是调用这个函数时传入的参数（从左到右的顺序）。
# 只要 <var>items</var> 不是空就重复 
## 删除 <var>items</var> 的第一个元素，并令 <var>E</var> 为这个元素的值。
## 以 [[ES5/conversion#ToString|ToString]](<var>n</var>)、<var>E</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。{{v8 partial||<nowiki>//v8中写入元素不会检测[[CanPut]]&#13;var o=[],a={__proto__:o,length:0};&#13;Object.defineProperty(o,0,{});&#13;Array.prototype.push.call(a,0);</nowiki>}}
## <var>n</var> 递增 '''1'''。
# 以 '''"length"'''、<var>n</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
# 返回 <var>n</var>。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#465||Return Length}}

'''push''' 方法的 '''length''' 属性是 '''1'''。

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


==== {{anchor|x15.4.4.8}}Array.prototype.reverse ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.8}}

重新排列数组元素，以翻转它们的顺序。对象会被当做调用的结果返回。{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L461|v8中会对稀疏数组特殊考虑}}

# 令 <var>O</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>lenVal</var> 为以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenVal</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#540|This.Length}}
# 令 <var>middle</var> 为 [[ES5/notation#x5.2|floor]](<var>len</var> / '''2''')。
# 令 <var>lower</var> 为 '''0'''。
# 只要 <var>lower</var> ≠ <var>middle</var> 就重复 
## 令 <var>upper</var> 为 <var>len</var> - <var>lower</var> - '''1'''。
## 令 <var>upperP</var> 为 [[ES5/conversion#ToString|ToString]](<var>upper</var>)。
## 令 <var>lowerP</var> 为 [[ES5/conversion#ToString|ToString]](<var>lower</var>)。
## 令 <var>lowerValue</var> 为以 <var>lowerP</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
## 令 <var>upperValue</var> 为以 <var>upperP</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
## 令 <var>lowerExists</var> 为以 <var>lowerP</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 令 <var>upperExists</var> 为以 <var>upperP</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>lowerExists</var> 是 '''true''' 并且 <var>upperExists</var> 是 '''true'''，则 
### 以 <var>lowerP</var>、<var>upperValue</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
### 以 <var>upperP</var>、<var>lowerValue</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
## 否则如果 <var>lowerExists</var> 是 '''false''' 并且 <var>upperExists</var> 是 '''true'''，则 
### 以 <var>lowerP</var>、<var>upperValue</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
### 以 <var>upperP</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法。{{v8 partial|https://github.com/v8/v8/blob/3.21/src/array.js#L567|不是调用内置的[[Delete]]，而是普通的delete，遇到不可删除元素不会抛出异常}}
## 否则如果 <var>lowerExists</var> 是 '''true''' 并且 <var>upperExists</var> 是 '''false'''，则 
### 以 <var>lowerP</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法。 {{v8 partial|https://github.com/v8/v8/blob/3.21/src/array.js#L573|不是调用内置的[[Delete]]，而是普通的delete，遇到不可删除元素不会抛出异常}}
### 以 <var>upperP</var>、<var>lowerValue</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
## 否则，<var>lowerExists</var> 和 <var>upperExists</var> 都是 '''false'''
### 不需要做任何事情。
## <var>lower</var> 递增 '''1'''。
# 返回 <var>O</var>。

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


==== {{anchor|x15.4.4.9}}Array.prototype.shift ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.9}}

删除并返回数组的第一个元素。{{v8 partial|https://github.com/v8/v8/blob/3.21/src/array.js#L597|v8中对于字典模式的数组实现shift的方式是颠覆性的，并且存在调用shift方法后丢失所有元素属性描述的BUG。}} {{v8|https://github.com/v8/v8/blob/3.21/src/builtins.cc#L607|v8数组在快速模式下的数组可以正常工作}}

# 令 <var>O</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>lenVal</var> 为以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenVal</var>)。
# 如果 <var>len</var> 是零 , 则 
## 以 '''"length"'''、'''0''' 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
## 返回 '''undefined'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#580|Return Undefined}}
# 令 <var>first</var> 为以 '''"0"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 令 <var>k</var> 为 '''1'''。
# 只要 <var>k</var> < <var>len</var> 就重复 
## 令 <var>from</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
## 令 <var>to</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var> - '''1''')。
## 令 <var>fromPresent</var> 为以 <var>from</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>fromPresent</var> 是 '''true''', 则 
### 令 <var>fromVal</var> 为以 <var>from</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 以 <var>to</var>、<var>fromVal</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
## 否则，<var>fromPresent</var> 是 '''false'''
### 以 <var>to</var> 和 '''ture''' 作为参数调用 <var>O</var> 的 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法。
## <var>k</var> 递增 '''1'''。
# 以 [[ES5/conversion#ToString|ToString]](<var>len</var> - '''1''') 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法。
# 以 '''"length"'''、(<var>len</var> - '''1''') 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#591|Set Length}}
# 返回 <var>first</var>。

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


==== {{anchor|x15.4.4.10}}Array.prototype.slice (start, end) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.10}}

'''slice''' 方法需要 <var>start</var> 和 <var>end</var> 两个参数，返回一个数组，这个数组包含从下标为 <var>start</var> 的元素到下标为 <var>end</var>（不含 '''end'''）的元素（或如果 <var>end</var> 是 '''undefined''' 就到数组末尾）。如果 <var>start</var> 为负，它会被当做是 '''length''' + <var>start</var>，这里的 '''length''' 是数组长度。如果 <var>end</var> 为负，它会被当做是 '''length''' + <var>end</var>，这里的 '''length''' 是数组长度。采用如下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L674|v8会对稀疏数组的slice做优化}}

# 令 <var>O</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>A</var> 为仿佛用表达式 '''new Array()''' 创建的新数组，这里的 '''Array''' 是标准内置构造器名。
# 令 <var>lenVal</var> 为以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#628|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenVal</var>)。
# 令 <var>relativeStart</var> 为 [[ES5/conversion#to-integer|ToInteger]](<var>start</var>)。
# 如果 <var>relativeStart</var> 为负，令 <var>k</var> 为 [[ES5/builtins#x15.8.2.11|max]]((<var>len</var> + <var>relativeStart</var>), '''0''')；否则令 <var>k</var> 为 [[ES5/builtins#x15.8.2.12|min]](<var>relativeStart</var>, <var>len</var>)。
# 如果 <var>end</var> 是 '''undefined'''，令 <var>relativeEnd</var> 为 <var>len</var>；否则令 <var>relativeEnd</var> 为 [[ES5/conversion#to-integer|ToInteger]](<var>end</var>)。
# 如果 <var>relativeEnd</var> 为负，令 <var>final</var> 为 [[ES5/builtins#x15.8.2.11|max]]((<var>len</var> + <var>relativeEnd</var>), '''0''')；否则令 <var>final</var> 为 [[ES5/builtins#x15.8.2.12|min]](<var>relativeEnd</var>, <var>len</var>)。
# 令 <var>n</var> 为 '''0'''。
# 只要 <var>k</var> < <var>final</var> 就重复 
## 令 <var>Pk</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
## 令 <var>kPresent</var> 为 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>kPresent</var> 是 '''true''', 则 
### 令 <var>kValue</var> 为以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 以 [[ES5/conversion#ToString|ToString]](<var>n</var>)、属性描述符 {&#91;[Value]]: <var>kValue</var>, &#91;[Writable]]: '''true''', &#91;[Enumerable]]: '''true''', &#91;[Configurable]]: '''true'''} 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
## <var>k</var> 递增 '''1'''。
## <var>n</var> 递增 '''1'''。
# 返回 <var>A</var>。

'''slice''' 方法的 '''length''' 属性是 '''2'''。

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


==== {{anchor|x15.4.4.11}}Array.prototype.sort (comparefn) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.11}}

给 '''this''' 数组的元素排序。排序不一定是稳定的（相等的元素们不一定按照他们原来的顺序排列）。如果 <var>comparefn</var> 不是 '''undefined'''，它就必须是个函数，这个函数接受两个参数 <var>x</var> 和 <var>y</var>，如果 <var>x</var> &lt; <var>y</var> 返回一个负值，如果 <var>x</var> = <var>y</var> 返回零，如果 <var>x</var> &gt; <var>y</var> 返回一个正值。{{question||不是“负值”、“零”和“正值”，应该是“小于零”、“等于零”、“大于零”，否则对零值的正负问题无法解释。}}

令 <var>obj</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。

以 '''"length"''' 作为参数调用 <var>obj</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法，将结果作为参数调用 Uint32{{question||此处难道不是ToUint32吗？}}，令 <var>len</var> 为返回的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1000|This.Length}}

如果 <var>comparefn</var> 不是 '''undefined''' 并且不是对 '''this''' 数组的元素保持一致的比较函数（见下面），那么这种情况下 '''sort''' 的行为是由实现来定义的。

令 <var>proto</var> 为 <var>obj</var> 的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性。如果 <var>proto</var> 不是 '''null''' 并且存在一个整数 <var>j</var> 满足下面列出的全部条件，那么这种情况下 '''sort''' 的行为是实现定义的：

* <var>obj</var> 是稀疏的（[[ES5/builtins#x15.4|15.4]]）
* '''0''' ≤ <var>j</var> < <var>len</var>
* 以 [[ES5/conversion#ToString|ToString]](<var>j</var>) 作为参数调用 <var>proto</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果是 '''true'''

如果 <var>obj</var> 是稀疏的并且以下任何条件为真，那么这种情况下 '''sort''' 的行为也是实现定义的：

* <var>obj</var> 的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性是 '''false'''。
* 任何名为小于 <var>len</var> 的非负整数的数组索引属性中，有 [[ES5/types#Configurable|<nowiki>[[Configurable]]</nowiki>]] 特性是 '''false''' 的数据属性。

任何名为小于 <var>len</var> 的非负整数的数组索引属性中，有[[ES5/types#accessor-property-descriptor|访问器属性]]，或有 [[ES5/types#Writable|<nowiki>[[Writable]]</nowiki>]] 特性是 '''false''' 的数据属性，那么这种情况下 '''sort''' 的行为也是实现定义的。

否则，采用如下步骤。{{extra note||这里是排序的主过程，并没有规定排序算法，但规定了只提供[[Get]]、[[Put]]、[[Delete]]和SortCompare，作为排序算法的接口方法。}}

# 根据实现定义的排序算法，通过调用若干次 <var>obj</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]]、[[ES5/types#Put|<nowiki>[[Put]]</nowiki>]]、[[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法和 {{toanchor|SortCompare}} 的有机组合来完成排序。这里对每个 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]]、[[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 或 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 调用的第一个参数是小于 <var>len</var> 的非负整数，{{toanchor|SortCompare}} 调用的参数是前面调用 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。调用 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 和 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法时，<var>throw</var> 参数是 '''true'''。如果 <var>obj</var> 不是稀疏的，则必须不调用 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]]。
# 返回 <var>obj</var>。

返回的对象必须拥有下面两个性质。{{extra note||这部分是对成功排序的定义。}}

* 必须有这样的数学排列 <var>π</var>，它是由比 <var>len</var> 小的非负整数组成，对于每个比 <var>len</var> 小的非负整数 <var>j</var>，如果属性 <var>old</var>[<var>j</var>] 存在 , 则 <var>new</var>[<var>π</var>(<var>j</var>)] 有与 <var>old</var>[<var>j</var>] 相同的值，如果属性 <var>old</var>[<var>j</var>] 不存在，则 <var>new</var>[<var>π</var>(<var>j</var>)] 也不存在。
* 对于都比 <var>len</var> 小的所有非负整数 <var>j</var> 和 <var>k</var>，如果 {{toanchor|SortCompare}}(<var>j</var>, <var>k</var>) &lt;  <var>0</var>, 则 <var>π</var>(<var>j</var>) &lt; <var>π</var>(<var>k</var>).

这里的符号 <var>old</var>[<var>j</var>] 用来指：假定在执行这个函数之前以 <var>j</var> 作为参数调用 <var>obj</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果，符号 <var>new</var>[<var>j</var>] 用来指：假定在执行这个函数后以 <var>j</var> 作为参数调用 <var>obj</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。

如果对于集合 <var>S</var> 里的任何值 <var>a</var>、<var>b</var>、<var>c</var>（可以是相同值），都满足以下所有条件，那么函数 <var>comparefn</var> 是在集合 <var>S</var> 上保持一致的比较函数（以下，符号 <var>a</var> '''&lt;'''<sub>CF</sub> <var>b</var> 表示 <var>comparefn</var>(<var>a</var>, <var>b</var>) &lt; '''0'''；符号 <var>a</var> '''='''<sub>CF</sub> <var>b</var> 表示 <var>comparefn</var>(<var>a</var>, <var>b</var>) = '''0'''（'''不论正负'''）； 符号 <var>a</var> '''&gt;'''<sub>CF</sub> <var>b</var> 表示 <var>comparefn</var>(<var>a</var>, <var>b</var>) &gt; '''0'''）： 

* 当用指定值 <var>a</var> 和 <var>b</var> 作为两个参数调用 <var>comparefn</var>(<var>a</var>, <var>b</var>)，总是返回相同值 <var>v</var>。此外 [[ES5/types#Type|Type]](<var>v</var>) 是 '''Number''', 并且 <var>v</var> 不是 '''NaN'''。注意，这意味着对于给定的 <var>a</var> 和 <var>b</var>，<var>a</var> '''&lt;'''<sub>CF</sub> <var>b</var>、<var>a</var> '''='''<sub>CF</sub> <var>b</var>、<var>a</var> '''&gt;'''<sub>CF</sub> <var>b</var> 中正好有一个为真。
* 调用 <var>comparefn</var>(<var>a</var>, <var>b</var>) 不改变 '''this''' 对象。
* <var>a</var> '''='''<sub>CF</sub> <var>a</var>（自反性）
* 如果 <var>a</var> '''='''<sub>CF</sub> <var>b</var>, 则 <var>b</var> '''='''<sub>CF</sub> <var>a</var>（对称性）
* 如果 <var>a</var> '''='''<sub>CF</sub> <var>b</var> 并且 <var>b</var> '''='''<sub>CF</sub> <var>c</var>，则 <var>a</var> '''='''<sub>CF</sub> <var>c</var>（'''='''<sub>CF</sub> 传递）
* 如果 <var>a</var> '''&lt;'''<sub>CF</sub> <var>b</var> 并且 <var>b</var> '''&lt;'''<sub>CF</sub> <var>c</var>, 则 <var>a</var> '''&lt;'''<sub>CF</sub> <var>c</var>（'''&lt;'''<sub>CF</sub> 传递）
* 如果 <var>a</var> '''&gt;'''<sub>CF</sub> <var>b</var> 并且 <var>b</var> '''&gt;'''<sub>CF</sub> <var>c</var>，则 <var>a</var> '''&gt;'''<sub>CF</sub> <var>c</var>（'''&gt;'''<sub>CF</sub> 传递）

{{note| 这些条件是确保 '''comparefn''' 划分集合 '''''S''''' 为等价类并且是完全排序等价类的充分必要条件。}}

{{anchor|SortCompare}}当用两个参数 <var>j</var> 和 <var>k</var> 调用抽象操作 '''SortCompare'''，采用如下步骤：{{question||实际上这个算法并不需要强调正零，正负零都表示相等。}}

# 令 <var>jString</var> 为 [[ES5/conversion#ToString|ToString]](<var>j</var>)。
# 令 <var>kString</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
# 令 <var>hasj</var> 为 以 <var>jString</var> 作为参数调用 <var>obj</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
# 令 <var>hask</var> 为 以 <var>kString</var> 作为参数调用 <var>obj</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
# 如果 <var>hasj</var> 和 <var>hask</var> 都是 '''false'''，则返回 '''+0'''。
# 如果 <var>hasj</var> 是 '''false'''，则返回 '''1'''。
# 如果 <var>hask</var> 是 '''false'''，则返回 '''-1'''。
# 令 <var>x</var> 为 以 <var>jString</var> 作为参数调用 <var>obj</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 令 <var>y</var> 为 以 <var>kString</var> 作为参数调用 <var>obj</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 如果 <var>x</var> 和 <var>y</var> 都是 '''undefined'''，返回 '''+0'''。
# 如果 <var>x</var> 是 '''undefined'''，返回 '''1'''。
# 如果 <var>y</var> 是 '''undefined'''，返回 '''−1'''。
# 如果 参数 <var>comparefn</var> 不是 '''undefined''', 则 
## 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>comparefn</var>) 是 '''false'''，抛出一个 '''TypeError''' 异常。
## 传入 '''undefined''' 作为 '''this''' 值，以 <var>x</var> 和 <var>y</var> 作为参数调用 <var>comparefn</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法，返回结果。
# 令 <var>xString</var> 为 [[ES5/conversion#ToString|ToString]](<var>x</var>)。
# 令 <var>yString</var> 为 [[ES5/conversion#ToString|ToString]](<var>y</var>)。
# 如果 <var>xString</var> &lt; <var>yString</var>，返回 '''−1'''。
# 如果 <var>xString</var> &gt; <var>yString</var>，返回 '''1'''。
# 返回 '''+0'''。

{{note| 因为不存在的属性值总是比 '''undefined''' 属性值大，并且 '''undefined''' 属性值总是比任何其他值大，所以 '''undefined''' 属性值总是排在结果的末尾，后面跟着不存在的属性值。}}

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


==== {{anchor|x15.4.4.12}}Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , … ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.12}}

当以两个或更多参数 <var>start</var>、<var>deleteCount</var> 和（可选的）<var>item1</var>、<var>item2</var>, 等，调用 '''splice''' 方法，从数组索引 <var>start</var> 开始的 <var>deleteCount</var> 个数组元素会被替换为参数 <var>item1</var>、<var>item2</var>, 等。返回一个包含参数元素（如果有）的数组。采用以下步骤：{{v8 partial|https://github.com/v8/v8/blob/3.21/src/array.js#L791|v8中对于字典模式的数组实现splice的方式是颠覆性的，并且存在调用splice方法后丢失所有元素属性描述的BUG。}}

# 令 <var>O</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>A</var> 为 仿佛用表达式 '''new Array()''' 创建的新数组，这里的 '''Array''' 是标准内置构造器名。
# 令 <var>lenVal</var> 为 以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#675|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenVal</var>)。
# 令 <var>relativeStart</var> 为 [[ES5/conversion#to-integer|ToInteger]](<var>start</var>)。
# 如果 <var>relativeStart</var> 为负，令 <var>actualStart</var> 为 [[ES5/builtins#x15.8.2.11|max]]((<var>len</var> + <var>relativeStart</var>),'''0'''); 否则令 <var>actualStart</var> 为 [[ES5/builtins#x15.8.2.12|min]](<var>relativeStart</var>, <var>len</var>)。
# 令 <var>actualDeleteCount</var> 为 [[ES5/builtins#x15.8.2.12|min]]([[ES5/builtins#x15.8.2.11|max]]([[ES5/conversion#to-integer|ToInteger]](<var>deleteCount</var>),'''0'''),<var>len</var> - <var>actualStart</var>)。
# 令 <var>k</var> 为 '''0'''。
# 只要 <var>k</var> &lt; <var>actualDeleteCount</var> 就重复 {{extra note||把需要删除的内容复制到新数组A中}}
## 令 <var>from</var> 为 [[ES5/conversion#ToString|ToString]](<var>actualStart</var> + <var>k</var>)。
## 令 <var>fromPresent</var> 为 以 <var>from</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>fromPresent</var> 是 '''true'''，则 
### 令 <var>fromValue</var> 为 以 <var>from</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 以 [[ES5/conversion#ToString|ToString]](<var>k</var>), 属性描述符 {&#91;[Value]]: <var>fromValue</var>, &#91;[Writable]]: '''true''', &#91;[Enumerable]]: '''true''', &#91;[Configurable]]: '''true'''}, 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
## <var>k</var> 递增 '''1'''.
# 令 <var>items</var> 为一个内部列表，它的元素是实际参数列表中 <var>item1</var> 开始的参数（从左到右的顺序）。如果没传入这些项目，则列表是空的。
# 令 <var>itemCount</var> 为 <var>items</var> 的元素个数。
# 如果 <var>itemCount</var> &lt; <var>actualDeleteCount</var>，则 {{extra note||如果需要插入的元素数量小于删除掉的元素数量，那就需要把删除部分右边的元素向左边移动，以防止插入元素后还空出多余的元素。}}
## 令 <var>k</var> 为 <var>actualStart</var>。
## 只要 <var>k</var> &lt; (<var>len</var> - <var>actualDeleteCount</var>) 就重复 
### 令 <var>from</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var> + <var>actualDeleteCount</var>)。
### 令 <var>to</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var> + <var>itemCount</var>)。
### 令 <var>fromPresent</var> 为 以 <var>from</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
### 如果 <var>fromPresent</var> 是 '''true'''，则 
#### 令 <var>fromValue</var> 为 以 <var>from</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
#### 以 <var>to</var>、<var>fromValue</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
### 否则，<var>fromPresent</var> 是 '''false'''
#### 以 <var>to</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法。
### <var>k</var> 递增 '''1'''。
## 令 <var>k</var> 为 <var>len</var>。
## 只要 <var>k</var> &gt; (<var>len</var> - <var>actualDeleteCount</var> + <var>itemCount</var>) 就重复 
### 以 [[ES5/conversion#ToString|ToString]](<var>k</var> - '''1''') 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法。
### <var>k</var> 递减 '''1'''.
# 否则如果 <var>itemCount</var> &gt; <var>actualDeleteCount</var>，则 {{extra note||如果需要插入的元素数量大于删除掉的元素数量，那就需要把删除部分右边的元素向右边移动，腾出足够的空间以待插入元素。}}
## 令 <var>k</var> 为 (<var>len</var> - <var>actualDeleteCount</var>)。
## 只要 <var>k</var> &gt; <var>actualStart</var> 就重复 
### 令 <var>from</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var> + <var>actualDeleteCount</var> - '''1''')。
### 令 <var>to</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var> + <var>itemCount</var> - '''1''')
### 令 <var>fromPresent</var> 为 以 <var>from</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
### 如果 <var>fromPresent</var> 是 '''true''', 则 
#### 令 <var>fromValue</var> 为 以 <var>from</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
#### 以 <var>to</var>、<var>fromValue</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
### 否则，<var>fromPresent</var> 是 '''false'''
#### 以 <var>to</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法。
### <var>k</var> 递减 '''1'''。
# 令 <var>k</var> 为 <var>actualStart</var>。
# 只要 <var>items</var> 不是空 就重复 {{extra note||把需要插入的元素复制到相应的位置。}}
## 删除 <var>items</var> 的第一个元素，并令 <var>E</var> 为这个元素值。
## 以 [[ES5/conversion#ToString|ToString]](<var>k</var>)、<var>E</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
## <var>k</var> 递增 '''1'''。
# 以 '''"length"'''、(<var>len</var> - <var>actualDeleteCount</var> + <var>itemCount</var>) 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
# 返回 <var>A</var>。

'''splice''' 方法的 '''length''' 属性是 '''2'''。

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


==== {{anchor|x15.4.4.13}}Array.prototype.unshift ( [ item1 [ , item2 [ , … ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.13}}

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

当以零或更多个参数 <var>item1</var>、<var>item2</var>，等，调用 '''unshift''' 方法，采用如下步骤：{{v8 partial|https://github.com/v8/v8/blob/3.21/src/array.js#L646|v8中对于字典模式的数组实现unshift的方式是颠覆性的，并且存在调用unshift方法后丢失所有元素属性描述的BUG。}}

# 令 <var>O</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>lenVal</var> 为 以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#603|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenVal</var>)。
# 令 <var>argCount</var> 为 实际参数的个数。
# 令 <var>k</var> 为 <var>len</var>。
# 只要 <var>k</var> > '''0'''，就重复 {{extra note||把所有元素向右移动足够的位置，以腾空最左边的空间来存放需要插入的元素。}}
## 令 <var>from</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var> - '''1''')。
## 令 <var>to</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var> + <var>argCount</var> - '''1''')。
## 令 <var>fromPresent</var> 为 以 <var>from</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>fromPresent</var> 是 '''true'''，则 
### 令 <var>fromValue</var> 为 以 <var>from</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 以 <var>to</var>、<var>fromValue</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
## 否则，<var>fromPresent</var> 是 <var>false</var>
### 以 <var>to</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法。
## <var>k</var> 递减 '''1'''。
# 令 <var>j</var> 为 '''0'''。
# 令 <var>items</var> 为一个内部列表，它的元素是调用这个函数时传入的实际参数（从左到右的顺序）。
# 只要 <var>items</var> 不是空，就重复  {{extra note||把插入的元素按顺序复制到左边腾出的位置上。}}
## 删除 <var>items</var> 的第一个元素，并令 <var>E</var> 为这个元素值 .
## 以 [[ES5/conversion#ToString|ToString]](<var>j</var>)、<var>E</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
## <var>j</var> 递增 '''1'''。
# 以 '''"length"'''、<var>len</var> + <var>argCount</var> 和 '''true''' 作为参数调用 <var>O</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
# 返回 <var>len</var> + <var>argCount</var>。

'''unshift''' 方法的 '''length''' 属性是 '''1'''。

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


==== {{anchor|x15.4.4.14}}Array.prototype.indexOf ( searchElement [ , fromIndex ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.14}}

'''indexOf''' 按照索引的升序比较 <var>searchElement</var> 和数组里的元素们，它使用内部的严格相等比较算法（[[ES5/expressions#x11.9.6|11.9.6]]），如果找到一个或更多这样的位置，返回这些位置中第一个索引；否则返回 '''-1'''。{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L1363|v8的实现对稀疏数组做了优化}}

可选的第二个参数 <var>fromIndex</var> 默认是 '''0'''（即搜索整个数组）。如果它大于或等于数组长度，返回 '''-1'''，即不会搜索数组。如果它是负的，就把它当作从数组末尾到计算后的 <var>fromIndex</var> 的偏移量。如果计算后的索引小于 '''0'''，就搜索整个数组。 {{extra note||如果fromIndex大于或等于数组长度，整个函数就直接返回-1，这意味着它不搜索就直接说找不到。如果是fromInex是负的，就表示从倒数第fromInex个元素开始找。}}

当用一个或两个参数调用 '''indexOf''' 方法，采用以下步骤：

# 令 <var>O</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>lenValue</var> 为 以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1271|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenValue</var>)。
# 如果 <var>len</var> 是 '''0'''，返回 '''-1'''。
# 如果 传入了参数 <var>fromIndex</var>，则令 <var>n</var> 为 [[ES5/conversion#to-integer|ToInteger]](<var>fromIndex</var>)；否则令 <var>n</var> 为 '''0'''。
# 如果 <var>n</var> ≥ <var>len</var>，返回 '''-1'''。
# 如果 <var>n</var> ≥ '''0'''，则 
## 令 <var>k</var> 为 <var>n</var>。
# 否则，<var>n</var> < '''0'''
## 令 <var>k</var> 为 <var>len</var> - [[ES5/notation#abs|abs]](<var>n</var>)。 {{question||为什么不直接用加法？}}
## 如果 <var>k</var> 小于 '''0'''，则令 <var>k</var> 为 '''0'''。
# 只要 <var>k</var> < <var>len</var>，就重复 
## 令 <var>kPresent</var> 为 以 [[ES5/conversion#ToString|ToString]](<var>k</var>) 为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>kPresent</var> 是 '''true'''，则 
### 令 <var>elementK</var> 为 以 [[ES5/conversion#ToString|ToString]](<var>k</var>) 为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 令 <var>same</var> 为 对 <var>searchElement</var> 和 <var>elementK</var> 执行[[ES5/expressions#x11.9.6|严格相等比较算法]]的结果。
### 如果 <var>same</var> 是 '''true'''，返回 <var>k</var>。
## <var>k</var> 递增 '''1'''。
# 返回 '''-1'''。

'''indexOf''' 方法的 '''length''' 属性是 '''1'''。

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


==== {{anchor|x15.4.4.15}}Array.prototype.lastIndexOf ( searchElement [ , fromIndex ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.15}}

'''lastIndexOf''' 按照索引的降序比较 <var>searchElement</var> 和数组里的元素们，它使用内部的严格相等比较算法 ([[ES5/expressions#x11.9.6|11.9.6]])，如果找到一个或更多这样的位置，返回这些位置中最后一个索引；否则返回 '''-1'''。{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L1422|v8的实现对稀疏数组做了优化}}

可选的第二个参数 <var>fromIndex</var> 默认是数组的长度减一（即搜索整个数组）。如果它大于或等于数组长度，将会搜索整个数组。如果它是负的，就把它当作从数组末尾到计算后的 <var>fromIndex</var> 的偏移量。如果计算后的索引小于 '''0'''，返回 '''-1'''。{{extra note||fromIndex的含义和indexOf中是完全一样的，不同的是lastIndexOf中它的默认值是length-1}}

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

# 令 <var>O</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>lenValue</var> 为 以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1333|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenValue</var>)。
# 如果 <var>len</var> 是 '''0'''，返回 '''-1'''。
# 如果 传入了参数 <var>fromIndex</var>，则令 <var>n</var> 为 [[ES5/conversion#to-integer|ToInteger]](<var>fromIndex</var>); 否则令 <var>n</var> 为 <var>len</var>。
# 如果 <var>n</var> ≥ '''0'''，则令 <var>k</var> 为 [[ES5/builtins#x15.8.2.12|min]](<var>n</var>, <var>len</var> - '''1''')。
# 否则，<var>n</var> < '''0'''
## 令 <var>k</var> 为 <var>len</var> - [[ES5/notation#abs|abs]](<var>n</var>)。{{question||为什么不直接用加法？}}
# 只要 <var>k</var> ≥ '''0''' 就重复 
## 令 <var>kPresent</var> 为 以 [[ES5/conversion#ToString|ToString]](<var>k</var>) 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>kPresent</var> 是 '''true'''，则 
### 令 <var>elementK</var> 为 以 [[ES5/conversion#ToString|ToString]](<var>k</var>) 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 令 <var>same</var> 为 对 <var>searchElement</var> 和 <var>elementK</var> 执行[[ES5/expressions#x11.9.6|严格相等比较算法]]的结果。
### 如果 <var>same</var> 是 '''true'''，返回 <var>k</var>。
## <var>k</var> 递减 '''1'''。
# 返回 '''-1'''。

'''lastIndexOf''' 方法的 '''length''' 属性是 '''1'''。

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


==== {{anchor|x15.4.4.16}}Array.prototype.every ( callbackfn [ , thisArg ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.16}}

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

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

调用 <var>callbackfn</var> 时将传入三个参数：元素的值，元素的索引，和遍历的对象。

对 '''every''' 的调用不直接更改对象，但是对 <var>callbackfn</var> 的调用可能更改对象。

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

当以一个或两个参数调用 '''every''' 方法，采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L1275|}}

# 令 <var>O</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>lenValue</var> 为 以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1185|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenValue</var>)。
# 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>callbackfn</var>) 是 '''false'''，抛出一个 '''TypeError''' 异常。
# 如果提供了 <var>thisArg</var>，令 <var>T</var> 为 <var>thisArg</var>；否则令 <var>T</var> 为 '''undefined'''。
# 令 <var>k</var> 为 '''0'''。
# 只要 <var>k</var> < <var>len</var>，就重复 
## 令 <var>Pk</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
## 令 <var>kPresent</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>kPresent</var> 是 '''true'''，则 
### 令 <var>kValue</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果 .
### 令 <var>testResult</var> 为 以 <var>T</var> 作为 '''this''' 值以包含 <var>kValue</var>、<var>k</var> 和 <var>O</var> 的参数列表调用 <var>callbackfn</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法的结果。
### 如果 [[ES5/conversion#to-boolean|ToBoolean]](<var>testResult</var>) 是 '''false'''，返回 '''false'''。
## <var>k</var> 递增 '''1'''。
# 返回 '''true'''。

'''every''' 方法的 '''length''' 属性是 '''1'''。

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


==== {{anchor|x15.4.4.17}}Array.prototype.some ( callbackfn [ , thisArg ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.17}}

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

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

调用 <var>callbackfn</var> 时将传入三个参数：元素的值，元素的索引，和遍历的对象。

对 '''some''' 的调用不直接更改对象，但是对 <var>callbackfn</var> 的调用可能更改对象。

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

当以一个或两个参数调用 '''some''' 方法，采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L1232|}}

# 令 <var>O</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>lenValue</var> 为 以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1143|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenValue</var>)。
# 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>callbackfn</var>) 是 '''false''', 抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1146|Throw TypeError}}
# 如果提供了 <var>thisArg</var>，令 <var>T</var> 为 <var>thisArg</var>；否则令 <var>T</var> 为 '''undefined'''。
# 令 <var>k</var> 为 '''0'''。
# 只要 <var>k</var> < <var>len</var>，就重复 
## 令 <var>Pk</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
## 令 <var>kPresent</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>kPresent</var> 是 '''true'''，则 
### 令 <var>kValue</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 令 <var>testResult</var> 为 以 <var>T</var> 作为 '''this''' 值以包含 <var>kValue</var>、<var>k</var> 和 <var>O</var> 的参数列表调用 <var>callbackfn</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法的结果。
### 如果 [[ES5/conversion#to-boolean|ToBoolean]](<var>testResult</var>) 是 '''true'''，返回 '''true'''。
## <var>k</var> 递增 '''1'''。
# 返回 '''false'''。

'''some''' 方法的 '''length''' 属性是 '''1'''。

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


==== {{anchor|x15.4.4.18}}Array.prototype.forEach ( callbackfn [ , thisArg ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.18}}


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

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

调用 <var>callbackfn</var> 时将传入三个参数：元素的值，元素的索引，和遍历的对象。

对 '''forEach''' 的调用不直接更改对象，但是对 <var>callbackfn</var> 的调用可能更改对象。

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

当以一个或两个参数调用 '''forEach''' 方法，采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L1275|}}


# 令 <var>O</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>lenValue</var> 为 以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1100|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenValue</var>)。
# 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>callbackfn</var>) 是 '''false'''，抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1103|Throw TypeError}}
# 如果提供了 <var>thisArg</var>，令 <var>T</var> 为 <var>thisArg</var>；否则令 <var>T</var> 为 '''undefined'''。
# 令 <var>k</var> 为 '''0'''。
# 只要 <var>k</var> < <var>len</var>，就重复 
## 令 <var>Pk</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
## 令 <var>kPresent</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>kPresent</var> 是 '''true'''，则 
### 令 <var>kValue</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 以 <var>T</var> 作为 '''this''' 值以包含 <var>kValue</var>、<var>k</var> 和 <var>O</var> 的参数列表调用 callbackfn 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法。
## <var>k</var> 递增 '''1'''。
# 返回 '''undefined'''。

'''forEach''' 方法的 '''length''' 属性是 '''1'''。

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


==== {{anchor|x15.4.4.19}}Array.prototype.map ( callbackfn [ , thisArg ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.19}}

<var>callbackfn</var> 应该是个函数，它接受三个参数。'''map''' 按照索引的升序，对数组里存在的每个元素调用一次 <var>callbackfn</var>，并用结果构造一个新数组。<var>callbackfn</var> 只被实际存在的数组元素调用；它不会被缺少的数组元素调用。 {{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L1317|}}

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

调用 <var>callbackfn</var> 时将传入三个参数：元素的值，元素的索引，和遍历的对象。

对 '''map''' 的调用不直接更改对象，但是对 <var>callbackfn</var> 的调用可能更改对象。

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

当以一个或两个参数调用 '''map''' 方法，采用以下步骤：

# 令 <var>O</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>lenValue</var> 为 以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1228|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenValue</var>)。
# 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>callbackfn</var>) 是 '''false'''，抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1231|Throw TypeError}}
# 如果提供了 <var>thisArg</var>，令 <var>T</var> 为 <var>thisArg</var>；否则令 <var>T</var> 为 '''undefined'''。
# 令 <var>A</var> 为 仿佛用 '''new Array('''<var>len</var>''')''' {{extra note||因为返回的数组和操作对象的长度必须相等，所以直接创建个同样长度的数组，后面的操作只是对需要操作的项赋值而已。}} 创建的新数组，这里的 '''Array''' 是标准内置构造器名，<var>len</var> 是 <var>len</var> 的值。
# 令 <var>k</var> 为 '''0'''。
# 只要 <var>k</var> < <var>len</var>，就重复 
## 令 <var>Pk</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
## 令 <var>kPresent</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>kPresent</var> 是 '''true'''，则 
### 令 <var>kValue</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 令 <var>mappedValue</var> 为 以 <var>T</var> 作为 '''this''' 值以包含 <var>kValue</var>、<var>k</var> 和 <var>O</var> 的参数列表调用 <var>callbackfn</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法的结果。
### 以 <var>Pk</var>，属性描述符 {&#91;[Value]]: <var>mappedValue</var>, &#91;[Writable]]: '''true''', &#91;[Enumerable]]: '''true''', &#91;[Configurable]]: '''true'''} 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
## <var>k</var> 递增 '''1'''。
# 返回 <var>A</var>。

'''map''' 方法的 '''length''' 属性是 '''1'''。

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


==== {{anchor|x15.4.4.20}}Array.prototype.filter ( callbackfn [ , thisArg ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.20}}


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

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

调用 <var>callbackfn</var> 时将传入三个参数：元素的值，元素的索引，和遍历的对象。

对 '''filter''' 的调用不直接更改对象，但是对 <var>callbackfn</var> 的调用可能更改对象。

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

当以一个或两个参数调用 '''filter''' 方法，采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L1137|}}

# 令 <var>O</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#to-object|ToObject]] 的结果。
# 令 <var>lenValue</var> 为 以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1049|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenValue</var>)。
# 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>callbackfn</var>) 是 '''false''', 抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1052|Throw TypeError}}
# 如果提供了 <var>thisArg</var>，令 <var>T</var> 为 <var>thisArg</var>；否则令 T 为 '''undefined'''。
# 令 <var>A</var> 为 仿佛用 '''new Array()''' 创建的新数组，这里的 '''Array''' 是标准内置构造器名。
# 令 <var>k</var> 为 '''0'''。
# 令 <var>to</var> 为 '''0'''。
# 只要 <var>k</var> < <var>len</var>，就重复 
## 令 <var>Pk</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
## 令 <var>kPresent</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>kPresent</var> 是 <var>true</var>，则 
### 令 <var>kValue</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 令 <var>selected</var> 为 以 <var>T</var> 作为 '''this''' 值以包含 <var>kValue</var>、<var>k</var> 和 <var>O</var> 的参数列表调用 <var>callbackfn</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法的结果。
### 如果 [[ES5/conversion#ToBoolean|ToBoolean]](<var>selected</var>) 是 '''true'''，则 
#### 以 [[ES5/conversion#ToString|ToString]](<var>to</var>)，属性描述符 {&#91;[Value]]: <var>kValue</var>, &#91;[Writable]]: '''true''', &#91;[Enumerable]]: '''true''', &#91;[Configurable]]: '''true'''} 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
#### <var>to</var> 递增 '''1'''。
## <var>k</var> 递增 '''1'''。
# 返回 <var>A</var>。

'''filter''' 方法的 '''length''' 属性是 '''1'''。

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


==== {{anchor|x15.4.4.21}}Array.prototype.reduce ( callbackfn [ , initialValue ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.21}}

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

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

对 '''reduce''' 的调用不直接更改对象，但是对 <var>callbackfn</var> 的调用可能更改对象。

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

当以一个或两个参数调用 '''reduce''' 方法，采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L1477|}}

# 令 <var>O</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#ToObject|ToObject]] 的结果。
# 令 <var>lenValue</var> 为 以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1394|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenValue</var>)。
# 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>callbackfn</var>) 是 '''false'''，抛出一个 '''TypeError''' 异常。
# 如果 <var>len</var> 是 '''0''' 并且 <var>initialValue</var> 不是 <var>present</var>，抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1409|Throw TypeError}}
# 令 <var>k</var> 为 '''0'''。
# 如果 <var>initialValue</var> 参数有传入值，则 
## 设定 <var>accumulator</var> 为 <var>initialValue</var>。
# 否则，<var>initialValue</var> 参数没有传入值 {{extra note||如果初始没有传入initialValue则去数据中寻找，并消耗循环位置。如果找不到可用的就抛出异常。}}
## 令 <var>kPresent</var> 为 '''false'''。
## 只要 <var>kPresent</var> 是 '''false''' 并且 <var>k</var> < <var>len</var>，就重复 
### 令 <var>Pk</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
### 令 <var>kPresent</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
### 如果 <var>kPresent</var> 是 '''true'''，则 
#### 令 <var>accumulator</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### <var>k</var> 递增 '''1'''.
## 如果 <var>kPresent</var> 是 '''false'''，抛出一个 '''TypeError''' 异常。
# 只要 <var>k</var> < <var>len</var>，重复
## 令 <var>Pk</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
## 令 <var>kPresent</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>kPresent</var> 是 '''true'''，则 
### 令 <var>kValue</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 令 <var>accumulator</var> 为 以 '''undefined''' 作为 '''this''' 值并以包含 <var>accumulator</var>、<var>kValue</var>、<var>k</var> 和 <var>O</var> 的参数列表调用 <var>callbackfn</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法的结果。
## <var>k</var> 递增 '''1'''。
# 返回 <var>accumulator</var>。

'''reduce''' 方法的 '''length''' 属性是 '''1'''。

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


==== {{anchor|x15.4.4.22}}Array.prototype.reduceRight ( callbackfn [ , initialValue ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.4.22}}

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

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

对 '''reduceRight''' 的调用不直接更改对象，但是对 <var>callbackfn</var> 的调用可能更改对象。

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

当以一个或两个参数调用 '''reduceRight''' 方法，采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/array.js#L1530|}}

# 令 <var>O</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#ToObject|ToObject]] 的结果。
# 令 <var>lenValue</var> 为 以 '''"length"''' 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/array.js?r{{=}}13175#1447|This.Length}}
# 令 <var>len</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>lenValue</var>)。
# 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>callbackfn</var>) 是 '''false'''，抛出一个 '''TypeError''' 异常。
# 如果 <var>len</var> 是 '''0''' 并且 <var>initialValue</var> 不是 <var>present</var>，抛出一个 '''TypeError''' 异常。
# 令 <var>k</var> 为 '''0'''。
# 如果 <var>initialValue</var> 参数有传入值，则 
## 设定 <var>accumulator</var> 为 <var>initialValue</var>。
# 否则，<var>initialValue</var> 参数没有传入值 {{extra note||如果初始没有传入initialValue则去数据中寻找，并消耗循环位置。如果找不到可用的就抛出异常。}}
## 令 <var>kPresent</var> 为 '''false'''。
## 只要 <var>kPresent</var> 是 '''false''' 并且 <var>k</var> ≥ '''0'''，就重复 
### 令 <var>Pk</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
### 令 <var>kPresent</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
### 如果 <var>kPresent</var> 是 '''true'''，则 
#### 令 <var>accumulator</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### <var>k</var> 递减 '''1'''。
## 如果 <var>kPresent</var> 是 '''false'''，抛出一个 '''TypeError''' 异常。
# 只要 <var>k</var> ≥ '''0'''，就重复 
## 令 <var>Pk</var> 为 [[ES5/conversion#ToString|ToString]](<var>k</var>)。
## 令 <var>kPresent</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#HasProperty|<nowiki>[[HasProperty]]</nowiki>]] 内部方法的结果。
## 如果 <var>kPresent</var> 是 '''true'''，则 
### 令 <var>kValue</var> 为 以 <var>Pk</var> 作为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 令 <var>accumulator</var> 为 以 '''undefined''' 作为 '''this''' 值并以包含 <var>accumulator</var>、<var>kValue</var>、<var>k</var> 和 <var>O</var> 的参数列表调用 <var>callbackfn</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法的结果。
## <var>k</var> 递减 '''1'''.
# 返回 <var>accumulator</var>。

'''reduceRight''' 方法的 '''length''' 属性是 '''1'''。

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


=== {{anchor|x15.4.5}}Array 实例的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.5}}

'''Array''' 实例从数组原型对象继承属性，'''Array''' 实例的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性是 '''"Array"'''。'''Array''' 实例还有以下属性。


==== {{anchor|x15.4.5.1}}<nowiki>[[DefineOwnProperty]]</nowiki> ( P, Desc, Throw ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.5.1}}

数组对象使用一个，用在其他原生 ECMAscript 对象的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法 ([[ES5/types#DefineOwnProperty|8.12.9]]) 的变化版。

设 <var>A</var> 为一个数组对象，<var>Desc</var> 为一个属性描述符，<var>Throw</var> 为一个布尔标示。

在以下算法中，术语“'''拒绝'''”指代“如果 <var>Throw</var> 是 '''true'''，则抛出 '''TypeError''' 异常，否则返回 '''false'''。

当用属性名 <var>P</var>、属性描述 <var>Desc</var>、布尔值 <var>Throw</var> 调用 <var>A</var> 的 '''<nowiki>[[DefineOwnProperty]]</nowiki>''' 内部方法，采用以下步骤：

# 令 <var>oldLenDesc</var> 为 以 '''"length"''' 作为参数调用 <var>A</var> 的 [[ES5/types#GetOwnProperty|<nowiki>[[GetOwnProperty]]</nowiki>]] 内部方法的结果。 结果绝不会是 '''undefined''' 或一个访问器描述符，因为在创建数组时的 '''length''' 是一个不可删除或重新配置的数据属性。
# 令 <var>oldLen</var> 为 <var>oldLenDesc</var>.[[ES5/types#Value|<nowiki>[[Value]]</nowiki>]]。
# 如果 <var>P</var> 是 '''"length"''', 则 
## 如果 <var>Desc</var> 的 [[ES5/types#Value|<nowiki>[[Value]]</nowiki>]] 字段不存在 , 则 
### 以 '''"length"'''、<var>Desc</var>、和 <var>Throw</var> 作为参数在 <var>A</var> 上调用默认的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法 ([[ES5/types#DefineOwnProperty|8.12.9]])，返回结果。
## 令 <var>newLenDesc</var> 为 <var>Desc</var> 的一个拷贝。
## 令 <var>newLen</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>Desc</var>.[[ES5/types#Value|<nowiki>[[Value]]</nowiki>]])。
## 如果 <var>newLen</var> 不等于 [[ES5/conversion#ToNumber|ToNumber]](<var>Desc</var>.[[ES5/types#Value|<nowiki>[[Value]]</nowiki>]])，抛出一个 '''RangeError''' 异常。
## 设定 <var>newLenDesc</var>.[[ES5/types#Value|<nowiki>[[Value]]</nowiki>]] 为 <var>newLen</var>。
## 如果 <var>newLen</var> ≥ <var>oldLen</var>，则 
### 以 '''"length"'''、<var>newLenDesc</var> 和 <var>Throw</var> 作为参数在 <var>A</var> 上调用默认的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法 ([[ES5/types#DefineOwnProperty|8.12.9]])，返回结果。
## 如果 <var>oldLenDesc</var>.[[ES5/types#Writable|<nowiki>[[Writable]]</nowiki>]] 是 '''false'''，'''拒绝''' 
## 如果 <var>newLenDesc</var>.[[ES5/types#Writable|<nowiki>[[Writable]]</nowiki>]] 不存在或值是 '''true'''，令 <var>newWritable</var> 为 '''true'''。
## 否则，
### 因为它将使得无法删除任何元素，所以需要延后设定 [[ES5/types#Writable|<nowiki>[[Writable]]</nowiki>]] 特性为 '''false'''。
### 令 <var>newWritable</var> 为 '''false'''。
### 设定 <var>newLenDesc</var>.[[ES5/types#Writable|<nowiki>[[Writable]]</nowiki>]] 为 '''true'''。
## 令 <var>succeeded</var> 为 以 '''"length"'''、<var>newLenDesc</var> 和 <var>Throw</var> 作为参数在 <var>A</var> 上调用默认的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法 ([[ES5/types#DefineOwnProperty|8.12.9]]) 的结果 
## 如果 <var>succeeded</var> 是 '''false'''，返回 '''false'''。
## 只要 <var>newLen</var> < <var>oldLen</var>，就重复，
### 设定 <var>oldLen</var> 为 <var>oldLen</var> – '''1'''。
### 令 <var>deleteSucceeded</var> 为 以 [[ES5/conversion#ToString|ToString]](<var>oldLen</var>) 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]] 内部方法的结果。
### 如果 <var>deleteSucceeded</var> 是 '''false'''，则 
#### 设定 <var>newLenDesc</var>.[[ES5/types#Value|<nowiki>[[Value]]</nowiki>]] 为 <var>oldLen</var> + '''1'''。
#### 如果 <var>newWritable</var> 是 '''false'''，设定 <var>newLenDesc</var>.[[ES5/types#Writable|<nowiki>[[Writable]]</nowiki>]] 为 '''false'''。
#### 以 '''"length"'''、<var>newLenDesc</var> 和 '''false''' 为参数在 <var>A</var> 上调用默认的 <nowiki>[[DefineOwnProperty]]</nowiki> 内部方法。
#### '''拒绝'''。{{v8 partial||严格模式下不会抛出异常。}}
## 如果 <var>newWritable</var> 是 '''false'''，则 
### 以 '''"length"'''，属性描述符 {<nowiki>[[Writable]]</nowiki>: '''false'''} 和 '''false''' 作为参数在 <var>A</var> 上调用 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。这个调用始终返回 '''true'''。
## 返回 '''true'''。
# 否则如果 <var>P</var> 是一个数组索引 ([[ES5/builtins#x15.4|15.4]])，则 
## 令 <var>index</var> 为 [[ES5/conversion#to-uint32|ToUint32]](<var>P</var>)。
## 如果 <var>index</var> ≥ <var>oldLen</var> 并且 <var>oldLenDesc</var>.[[ES5/types#Writable|<nowiki>[[Writable]]</nowiki>]] 是 '''false'''，'''拒绝'''。
## 令 <var>succeeded</var> 为 以 <var>P</var>、<var>Desc</var> 和 '''false''' 作为参数在 <var>A</var> 上调用默认的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法 ([[ES5/types#DefineOwnProperty|8.12.9]]) 的结果。
## 如果 <var>succeeded</var> 是 '''false'''，'''拒绝'''。
## 如果 <var>index</var> ≥ <var>oldLen</var>
### 设定 <var>oldLenDesc</var>.[[ES5/types#Value|<nowiki>[[Value]]</nowiki>]] 为 <var>index</var> + '''1'''。
### 以 "'''length"'''、<var>oldLenDesc</var> 和 '''false''' 作为参数在在 <var>A</var> 上调用默认的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。这个调用始终返回 '''true'''。
## 返回 '''true'''。
# 以 <var>P</var>、<var>Desc</var> 和 <var>Throw</var> 作为参数在在 <var>A</var> 上调用默认的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法 ([[ES5/types#DefineOwnProperty|8.12.9]])，返回结果。


==== {{anchor|x15.4.5.2}}length ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.4.5.2}}

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

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

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


== {{anchor|x15.5}}String 对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.5}}


=== {{anchor|x15.5.1}}作为函数调用 String 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.1}}

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


==== {{anchor|x15.5.1.1}}String ( [ value ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.1.1}}

返回一个由 [[ES5/conversion#ToString|ToString]](<var>value</var>) 计算出的字符串值（不是 '''String''' 对象）。如果没有提供 <var>value</var>，返回空字符串 ""。


=== {{anchor|x15.5.2}}String 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.2}}

当 '''String''' 作为一个 [[ES5/expressions#x11.2.2|new]] 表达式的一部分被调用，它是个构造器：它初始化新创建的对象。


==== {{anchor|x15.5.2.1}}new String ( [ value ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.2.1}}

新构造对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性设定为标准内置的字符串原型对象，它是 [[ES5/builtins#x15.5.3.1|String.prototype]] 的初始值 ([[ES5/builtins#x15.5.3.1|15.5.3.1]])。

新构造对象的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性设定为 '''"String"'''。

新构造对象的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性设定为 '''true'''。

新构造对象的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性设定为 [[ES5/conversion#ToString|ToString]](<var>value</var>)，或如果没提供 <var>value</var> 则设定为空字符串。


=== {{anchor|x15.5.3}}String 构造器的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.3}}

'''String''' 构造器的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性的值是标准的内置 [[ES5/builtins#x15.3.4|Function 原型对象]]。

除了内部属性和 '''length''' 属性（值为 '''1'''）之外，'''String''' 构造器还有以下属性：


==== {{anchor|x15.5.3.1}}String.prototype ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.3.1}}

'''String.prototype''' 的初始值是标准的内置 [[ES5/builtins#x15.5.4|String 原型对象]]。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#45|FunctionSetPrototype}}

这个属性有特性 { &#91;[Writable]]: '''false''', &#91;[Enumerable]]: '''false''', &#91;[Configurable]]: '''false''' }。


==== {{anchor|x15.5.3.2}}String.fromCharCode ( [ char0 [ , char1 [ , … ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.3.2}}

返回一个字符串值，包含的字符数与参数数目相同。每个参数指定返回字符串中的一个字符，也就是说第一个参数第一个字符，以此类推（从左到右）。一个参数转换为一个字符，通过先应用 [[ES5/conversion#to-uint16|ToUint16]] 操作，再将返回的16位整数看作字符的代码单元值。如果没提供参数，返回空字符串。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#826|StringFromCharCode}}

'''fromCharCode''' 函数的 '''length''' 属性是 '''1'''。


=== {{anchor|x15.5.4}}字符串原型对象的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4}}

字符串原型对象本身是一个值为空字符串的 '''String''' 对象（它的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 是 '''"String"'''）。

字符串原型对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性值是标准的内置 [[ES5/builtins#x15.2.4|Object 原型对象]]。


==== {{anchor|x15.5.4.1}}String.prototype.constructor ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.1}}

'''String.prototype.constructor''' 的初始值是内置 '''String''' 构造器。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#960|Set Ptototype.constructor}}


==== {{anchor|x15.5.4.2}}String.prototype.toString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.2}}

返回 '''this''' 字符串值。（注，对于一个 '''String''' 对象，'''toString''' 方法和 '''valueOf''' 方法返回相同值。）

'''toString''' 函数是'''非通用'''的；如果它的 '''this''' 值不是一个字符串或字符串对象，则抛出一个 '''TypeError''' 异常。因此它不能作为方法转移到其他类型对象上。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#50|Throw TypeError}}


==== {{anchor|x15.5.4.3}}String.prototype.valueOf ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.3}}

返回 '''this''' 字符串值。

'''valueOf''' 函数是'''非通用'''的；如果它的 '''this''' 值不是一个字符串或字符串对象，则抛出一个 '''TypeError''' 异常。因此它不能作为方法转移到其他类型对象上。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#59|Throw TypeError}}


==== {{anchor|x15.5.4.4}}String.prototype.charAt (pos) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.4}}

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

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

当用一个参数 <var>pos</var> 调用 '''charAt''' 方法，采用以下步骤：

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>S</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。
# 令 <var>position</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>pos</var>)。 
# 令 <var>size</var> 为 <var>S</var> 的字符数。
# 如果 <var>position</var> < '''0''' 或 <var>position</var> ≥ <var>size</var>，返回空字符串。
# 返回一个长度为 '''1''' 的字符串，它包含 <var>S</var> 中 <var>position</var> 位置的一个字符，在这里 <var>S</var> 中的第一个（最左边）字符被当作是在位置 '''0'''，下一个字符被当作是在位置 '''1'''，等等。

{{note| '''charAt''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.5}}String.prototype.charCodeAt (pos) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.5}}

将 '''this''' 对象转换为一个字符串，返回一个代表这个字符串 <var>pos</var> 位置字符的代码单元值的数字（小于 '''2<sup>16</sup>''' 的非负整数）。如果那个位置没有字符，返回 '''NaN'''。

当用一个参数 <var>pos</var> 调用 '''charCodeAt''' 方法，采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/runtime.cc#L3110|}}

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>S</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。
# 令 <var>position</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>pos</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r{{=}}13187#2217|Convert to Number}}
# 令 <var>size</var> 为 <var>S</var> 的字符数。
# 如果 <var>position</var> < '''0''' 或 <var>position</var> ≥ <var>size</var>，返回 '''NaN'''.
# 返回一个数字类型值，值是字符串 <var>S</var> 中 <var>position</var> 位置字符的代码单元值。 在这里 <var>S</var> 中的第一个（最左边）字符被当作是在位置 '''0'''，下一个字符被当作是在位置 '''1'''，等等。

{{note| '''charCodeAt''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.6}}String.prototype.concat ( [ string1 [ , string2 [ , … ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.6}}

当用一个或更多参数 <var>string1</var>、<var>string2</var>，等，调用 '''concat''' 方法，它返回一个字符串，其中包含了转换成字符串类型的 '''this''' 对象中的所有字符和后面跟着的每个参数（例如：<var>string1</var>、<var>string2</var>，等）转换成字符串类型后里面的所有字符。返回结果是一个字符串值，不是一个字符串对象。采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/string.js#L92|字符串连接是低效的，v8中对此实现优化。}}

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>S</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#100|This.ToString}}
# 令 <var>args</var> 为一个内部列表，它是传给这个函数的参数列表的拷贝。
# 令 <var>R</var> 为 <var>S</var>。
# 只要 <var>args</var> 不是空，就重复 
## 删除 <var>args</var> 的第一个元素，并令 <var>next</var> 为这个元素。
## 令 <var>R</var> 为一个包含了 <var>R</var> 中原有的所有字符跟上 [[ES5/conversion#ToString|ToString]](<var>next</var>) 中的所有字符 的字符串值。
# 返回 <var>R</var>。

'''concat''' 方法的 '''length''' 属性是 '''1'''.

{{note| '''concat''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.7}}String.prototype.indexOf (searchString, position) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.7}}

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

'''indexOf''' 需要两个参数 <var>searchString</var> 和 <var>position</var>，执行以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/string.js#L116|}}

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 S 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#123|This.ToString}}
# 令 <var>searchStr</var> 为 [[ES5/conversion#ToString|ToString]](<var>searchString</var>)。
# 令 <var>pos</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>position</var>)。（如果 <var>position</var> 是 '''undefined'''，此步骤产生 '''0'''）。
# 令 <var>len</var> 为 <var>S</var> 的字符数。
# 令 <var>start</var> 为 [[ES5/builtins#x15.8.2.12|min]]([[ES5/builtins#x15.8.2.11|max]](<var>pos</var>, '''0'''), <var>len</var>)。
# 令 <var>searchLen</var> 为 <var>SearchStr</var> 的字符数。
# 返回 一个不小于 <var>start</var> 的可能的最小值整数 <var>k</var>，使得 <var>k</var> + <var>searchLen</var> 不大于 <var>len</var>，并且对所有小于 <var>searchLen</var> 的非负数整数 <var>j</var>、<var>S</var> 的 <var>k</var> + <var>j</var> 位置字符和 <var>searchStr</var> 的 <var>j</var> 位置字符相同；但如果没有这样的整数 <var>k</var>，则返回 '''-1'''。{{extra note||这里只定义了搜索结果的标准，搜索过程由具体的实现来定义。}}

'''indexOf''' 的 '''length''' 属性是 '''1'''。

{{note| '''indexOf''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.8}}String.prototype.lastIndexOf (searchString, position) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.8}}


将 '''this''' 对象转换为一个字符串，如果 <var>searchString</var> 在这个字符串里小于或等于 <var>position</var> 的位置中的一个或多个位置使它呈现为字符串的子串，那么返回这些位置中最大的索引；否则返回 '''-1'''。如果 <var>position</var> 是 '''undefined''' {{extra note||未必需要undefined，任何ToNumber之后得到NaN的值都可以搜索整个字符串。}}，就认为它是字符串值的长度，以搜索整个字符串。

<var>lastIndexOf</var> 需要两个参数 <var>searchString</var> 和 <var>position</var>，执行以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/string.js#L135|}}

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>S</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#142|This.ToString}}
# 令 <var>searchStr</var> 为 [[ES5/conversion#ToString|ToString]](<var>searchString</var>)。
# 令 <var>numPos</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>position</var>)。( 如果 <var>position</var> 是 '''undefined'''，此步骤产生 '''NaN''')。
# 如果 <var>numPos</var> 是 '''NaN'''，令 <var>pos</var> 为 '''+∞'''；否则，令 <var>pos</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>numPos</var>)。
# 令 <var>len</var> 为 <var>S</var> 的字符数。
# 令 <var>start</var> 为 [[ES5/builtins#x15.8.2.12|min]]([[ES5/builtins#x15.8.2.11|max]](<var>pos</var>, '''0'''), '''len''')。
# 令 <var>searchLen</var> 为 <var>SearchStr</var> 的字符数。
# 返回 一个不大于 <var>start</var> 的可能的最大值整数 <var>k</var>，使得 <var>k</var> + <var>searchLen</var> 不大于 <var>len</var>，并且对所有小于 <var>searchLen</var> 的非负数整数 <var>j</var>，<var>S</var> 的 <var>k</var> + <var>j</var> 位置字符和 <var>searchStr</var> 的 <var>j</var> 位置字符相同；但如果没有这样的整数 <var>k</var>，则返回 '''-1'''。{{extra note||这里只定义了搜索结果的标准，搜索过程由具体的实现来定义。}}。

'''lastIndexOf''' 的 '''length''' 属性是 '''1'''。

{{note| '''lastIndexOf''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.9}}String.prototype.localeCompare (that) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.9}}

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

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

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 S 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#176|Convert to String}}
# 令 <var>That</var> 为 [[ES5/conversion#ToString|ToString]](<var>that</var>)。

如果将 '''localeCompare''' 方法看做是将 <var>this</var> 和 <var>that</var> 作为两个参数的函数，那么它是在所有字符串集合上的保持一致的比较函数（在 [[ES5/builtins#x15.4.4.11|15.4.4.11]] 定义）。

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

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

{{note| '''localeCompare''' 方法自身不适合直接作为 '''Array.prototype.sort''' 的参数，因为后者需要的是两个参数的函数。}}

{{note| 这个函数的目的是在宿主环境中任何依靠语言敏感的比较方式都可用于 ECMAScript 环境，并根据宿主环境当前语言环境设置的规则进行比较。强烈建议这个函数把根据 Unicode 标准的标准等价的字符串当做是相同的（也就是说，要比较的字符串仿佛是都先被转换为正规化形式 C 或正规化形式 D 了）。还建议这个函数不履行 Unicode 相容等价或分解。}}

{{note| 本标准的未来版本可能会使用这个函数的第二个参数；建议实现不将这个参数位用作其他用途。}}

{{note| '''localeCompare''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.10}}String.prototype.match (regexp) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.10}}

当以 <var>regexp</var> 作为参数调用 '''match''' 方法，采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.21/src/string.js#L179|}}

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>S</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。
# 如果 [[ES5/types#Type|Type]](<var>regexp</var>) 是 '''Object''' 并且 <var>regexp</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性的值是 '''"RegExp"'''，则令 <var>rx</var> 为 <var>regexp</var>；{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#188|IsRegExp}}
# 否则，令 <var>rx</var> 为 仿佛是用表达式 '''new RegExp('''<var>regexp</var>''')''' 创建的新正则对象，这里的 '''RegExp''' 是标准内置构造器名。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#200|new RegExp}}
# 令 <var>global</var> 为 以 '''"global"''' 为参数调用 <var>rx</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 令 <var>exec</var> 为 标准内置函数 '''RegExp.prototype.exec''' ( 见 [[ES5/builtins#x15.10.6.2|15.10.6.2]])
# 如果 <var>global</var> 不是 '''true'''，则 
## 以 <var>rx</var> 作为 '''this''' 值，用包含 <var>S</var> 的参数列表调用 <var>exec</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法，返回结果。
# 否则，<var>global</var> 是 '''true'''
## 以 '''"lastIndex"''' 和 '''0''' 作为参数调用 <var>rx</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
## 令 <var>A</var> 为 仿佛是用表达式 '''new Array()''' 创建的新数组，这里的 '''Array''' 是标准内置构造器名。
## 令 <var>previousLastIndex</var> 为 '''0'''。
## 令 <var>n</var> 为 '''0'''。
## 令 <var>lastMatch</var> 为 '''true'''。
## 只要 <var>lastMatch</var> 是 '''true'''，就重复 
### 令 <var>result</var> 为 以 <var>rx</var> 作为 '''this''' 值，用包含 <var>S</var> 的参数列表调用 <var>exec</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法的结果。
### 如果 <var>result</var> 是 '''null'''，则设定 <var>lastMatch</var> 为 '''false'''。
### 否则，<var>result</var> 不是 '''null'''
#### 令 <var>thisIndex</var> 为 以 '''"lastIndex"''' 为参数调用 <var>rx</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
#### 如果 <var>thisIndex</var> = <var>previousLastIndex</var> 则 {{question||这个真的有必要吗？有什么正则表达式exec执行成功之后lastIndex会和上一次相等吗？}}
##### 以 '''"lastIndex"''' 和 <var>thisIndex</var> + '''1''' 为参数调用 <var>rx</var> 的 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]] 内部方法。
##### 设定 <var>previousLastIndex</var> 为 <var>thisIndex</var> + '''1'''。
#### 否则，设定 <var>previousLastIndex</var> 为 <var>thisIndex</var>。
#### 令 <var>matchStr</var> 为 以 '''0''' 为参数调用 <var>result</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
#### 以 [[ES5/conversion#ToString|ToString]](<var>n</var>)，属性描述符 {<nowiki>[[Value]]</nowiki>: <var>matchStr</var>, <nowiki>[[Writable]]</nowiki>: '''true''', <nowiki>[[Enumerable]]</nowiki>: '''true''', <nowiki>[[configurable]]</nowiki>: '''true'''} 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
#### <var>n</var> 递增 '''1'''。
## 如果 <var>n</var> = '''0'''，则返回 '''null'''。
## 返回 <var>A</var>。

{{note| '''match''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.11}}String.prototype.replace (searchValue, replaceValue) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.11}}

首先根据以下步骤设定 <var>string</var>：

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>string</var> 为 以 '''this''' 值作为为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。

如果 <var>searchValue</var> 是一个正则表达式（[[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性是 '''"RegExp"''' 的对象），按照如下执行：如果 <var>searchValue</var>.'''global''' 是 '''false'''，则搜索 <var>string</var>，找出匹配正则表达式 <var>searchValue</var> 的第一个子字符串。如果 <var>searchValue</var>.'''global''' 是 '''true'''，则搜索 <var>string</var>，找出匹配正则表达式 <var>searchValue</var> 的所有子字符串。搜索的做法与 '''String.prototype.match''' 相同，包括对 <var>searchValue</var>.'''lastIndex''' 的更新。令 <var>m</var> 为 <var>searchValue</var> 的左捕获括号的个数（使用 [[ES5/builtins#x15.10.2.1|15.10.2.1]] 指定的 '''NcapturingParens'''）。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#232|IsRegExp}}

如果 <var>searchValue</var> 不是正则表达式，令 <var>searchString</var> 为 [[ES5/conversion#ToString|ToString]](<var>searchValue</var>)，并搜索 <var>string</var>，找出第一个出现的 <var>searchString</var> 的子字符串。令 <var>m</var> 为 '''0'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#272|ToString}}

如果 <var>replaceValue</var> 是函数，则对每个匹配的子字符串，以 <var>m</var> + '''3''' 个参数调用这个函数。第一个参数是匹配的子字符串。如果 <var>searchValue</var> 是正则表达式，接下来 <var>m</var> 个参数是 [[ES5/builtins#Patterns-MatchResult|MatchResult]] 里的所有捕获值。第 <var>m</var> + '''2''' 个参数是发生的匹配在 <var>string</var> 里的偏移量，第 <var>m</var> + '''3''' 个参数是 <var>string</var>。结果是将输入的原字符串里的每个匹配子字符串替换为相应函数调用的返回值（必要的情况下转换为字符串）得到的字符串。

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

{|border="1" cellpadding="5" ailgn="center" style="border-collapse:collapse;"
|+ '''表22 替代文本符号替换''' 
|- style="background:#EEE;"
! width="60"| 字符 
! 替代文本 
|-
| $$
| $
|-
| $&
| 匹配到的子字符串 
|- 
| $` {{extra note||字符\u0060，键盘上ESC下面那个键。}}
| string 中匹配到的子字符串之前部分。
|-
| $' {{extra note||字符\u0027，单引号。}}
| string 中匹配到的子字符串之后部分。
|-
| $n
| 第 <var>n</var> 个捕获结果，<var>n</var> 是范围在 '''1''' 到 '''9''' 的单个数字，并且紧接着 <var>$n</var> 后面的不是十进制数字。如果 '''n''' ≤ '''m''' 且第 '''n''' 个捕获结果是 '''undefined'''，就用空字符串代替。如果 <var>n</var> > <var>m</var>，结果是实现定义的。
|-
| $nn
| 第 <var>nn</var> 个捕获结果，<var>nn</var> 是范围在 '''01''' 到 '''99''' 的十进制两位数。如果 <var>nn</var> ≤ <var>m</var> 且第 <var>nn</var> 个捕获结果是 '''undefined'''，就用空字符串代替。如果 <var>nn</var> > <var>m</var>，结果是实现定义的。
|}

{{note| '''replace''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.12}}String.prototype.search (regexp) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.12}}

当用参数 <var>regexp</var> 调用 '''search''' 方法，采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.22/src/string.js#L545|v8对正则表达式做了缓存以避免不必要的正则对象实例化。}}

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>string</var> 为 以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。
# 如果 [[ES5/types#Type|Type]](<var>regexp</var>) 是 '''Object''' 且 <var>regexp</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性的值是 '''"RegExp"''', 则令 <var>rx</var> 为 <var>regexp</var>；{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#506|IsRegExp}}
# 否则，令 <var>rx</var> 为仿佛是用表达式 '''new RegExp('''<var>regexp</var>''')''' 创建的新正则对象，这里的 '''RegExp''' 是标准内置构造器名。
# 从 <var>string</var> 开始位置搜索正则表达式模式 <var>rx</var> 的匹配。如果找到匹配，令 <var>result</var> 为匹配在 <var>string</var> 里的偏移量；如果没有找到匹配，令 <var>result</var> 为 '''-1'''。执行搜索时 <var>regexp</var> 的 '''lastIndex''' 和 '''global''' 属性是被忽略的。<var>regexp</var> 的 '''lastIndex''' 属性保持不变。
# 返回 <var>result</var>。

{{note| '''search''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.13}}String.prototype.slice (start, end) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.13}}

<var>slice</var> 方法需要两个参数 <var>start</var> 和 <var>end</var>，将 '''this''' 对象转换为一个字符串，返回这个字符串中从 <var>start</var> 位置的字符到（但不包含）<var>end</var> 位置的字符的一个子字符串（或如果 <var>end</var> 是 '''undefined'''，就直接到字符串尾部）。用 <var>sourceLength</var> 表示字符串长度，如果 <var>start</var> 是负数，就把它看做是 <var>sourceLength</var> + <var>start</var>；如果 <var>end</var> 是负数，就把它看做是 <var>sourceLength</var> + <var>end</var>。返回结果是一个字符串值，不是字符串对象。采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.22/src/string.js#L567|}}

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>S</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。
# 令 <var>len</var> 为 <var>S</var> 的字符数 .{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#525|This.ToString.Length}}
# 令 <var>intStart</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>start</var>)。
# 如果 <var>end</var> 是 '''undefined'''，令 <var>intEnd</var> 为 <var>len</var>；否则 令 <var>intEnd</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>end</var>)。
# 如果 <var>intStart</var> 是 <var>negative</var>，令 <var>from</var> 为 [[ES5/builtins#x15.8.2.11|max]](<var>len</var> + <var>intStart</var> , '''0''')；否则 令 <var>from</var> 为 [[ES5/builtins#x15.8.2.12|min]](<var>intStart</var> , <var>len</var>)。
# 如果 <var>intEnd</var> 是 <var>negative</var>，令 <var>to</var> 为 [[ES5/builtins#x15.8.2.11|max]](<var>len</var> + <var>intEnd</var>, '''0''')；否则 令 <var>to</var> 为 [[ES5/builtins#x15.8.2.12|min]](<var>intEnd</var>，<var>len</var>)。
# 令 <var>span</var> 为 [[ES5/builtins#x15.8.2.11|max]](<var>to</var> - <var>from</var>, '''0''' )。
# 返回 一个包含 <var>S</var> 中 <var>form</var> 位置的字符开始的 <var>span</var> 个连续字符 的字符串。{{v8|https://github.com/v8/v8/blob/3.22/src/runtime.cc#L4417|v8使用这个接口来截取字符串。}}

'''slice''' 方法的 '''length''' 属性是 '''2'''。

{{note| '''slice''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.14}}String.prototype.split (separator, limit) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.14}}

将 '''this''' 字符串转换为一个字符串，返回一个数组对象，里面存储了这个字符串的子字符串。子字符串是从左到右搜索 <var>separator</var> 的匹配来确定的；这些匹配结果不成为返回数组的任何子字符串元素，但被用来分割字符串。<var>separator</var> 的值可以是一个任意长度的字符串，也可以是一个正则对象（即，一个 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性为 '''"RegExp"''' 的对象；见 [[ES5/builtins#x15.10|15.10]]）。

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

如果 '''this''' 对象是（或转换成）空字符串，返回的结果取决于 <var>separator</var> 是否可匹配空字符串。如果可以，结果是不包含任何元素的数组。否则，结果是包含一个空字符串元素的数组。

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

例如，

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

执行结果是数组：

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

如果 <var>separator</var> 是 '''undefined'''，则返回结果是只包含 '''this''' 值（转换为字符串）一个字符串元素的数组。如果 <var>limit</var> 不是 '''undefined'''，则输出数组被切断为包含不大于 <var>limit</var> 个元素。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#574|Seperator Undefined}}


当调用 '''split''' 方法，采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.22/src/string.js#L611|v8的实现是单独对字符串和正则处理的。}} {{v8|https://github.com/v8/v8/blob/3.22/src/runtime.cc#L6558|使用字符串。}} {{v8|https://github.com/v8/v8/blob/3.22/src/string.js#L650|使用正则。}}

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>S</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。
# 令 <var>A</var> 为 仿佛使用表达式 '''new Array()''' 创建的新对象，这里的 '''Array''' 是标准内置构造器名。
# 令 <var>lengthA</var> 为 '''0'''。
# 如果 <var>limit</var> 是 '''undefined'''，令 <var>lim</var> = '''2<sup>32</sup>''' - '''1'''; 否则 令 <var>lim</var> = [[ES5/conversion#to-uint32|ToUint32]](<var>limit</var>)。
# 令 <var>s</var> 为 <var>S</var> 的字符数。
# 令 <var>p</var> = '''0'''。
# 如果 <var>separator</var> 是正则对象（它的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 是 '''"RegExp"'''），令 <var>R</var> = <var>separator</var>；否则，令 <var>R</var> = [[ES5/conversion#ToString|ToString]](<var>separator</var>)。
# 如果 <var>lim</var> = '''0'''，返回 <var>A</var>。
# 如果 <var>separator</var> 是 '''undefined''', 则 
## 以 '''"0"'''、属性描述符 {<nowiki>[[Value]]</nowiki>: <var>S</var>, <nowiki>[[Writable]]</nowiki>: '''true''', <nowiki>[[Enumerable]]</nowiki>: '''true''', <nowiki>[[Configurable]]</nowiki>: '''true'''} 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
## 返回 <var>A</var>。
# 如果 <var>s</var> = '''0'''，则 
## 调用 [[#SplitMatch|SplitMatch]](<var>S</var>, '''0''', <var>R</var>) 并 令 <var>z</var> 为 它的 [[ES5/builtins#Patterns-MatchResult|MatchResult]] 结果。
## 如果 <var>z</var> 不是 '''failure'''，返回 <var>A</var>。
## 以 '''"0"'''、属性描述符 {<nowiki>[[Value]]</nowiki>: <var>S</var>, <nowiki>[[Writable]]</nowiki>: '''true''', <nowiki>[[Enumerable]]</nowiki>: '''true''', <nowiki>[[Configurable]]</nowiki>: '''true'''} 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
## 返回 <var>A</var>。
# 令 <var>q</var> = <var>p</var>。
# 只要 <var>q</var> ≠ <var>s</var>，就重复 
## 调用 [[#SplitMatch|SplitMatch]](<var>S</var>, <var>q</var>, <var>R</var>) 并 令 <var>z</var> 为 它的 [[ES5/builtins#Patterns-MatchResult|MatchResult]] 结果。
## 如果 <var>z</var> 是 '''failure''', 则 令 <var>q</var> = <var>q</var> + '''1'''。
## 否则，<var>z</var> 不是 '''failure'''
### <var>z</var> 必定是一个 [[ES5/builtins#Patterns-State|State]]。令 <var>e</var> 为 <var>z</var> 的 '''endIndex''' 并 令 <var>cap</var> 为 <var>z</var> 的 '''captures''' 数组。
### 如果 <var>e</var> = <var>p</var>，则 令 <var>q</var> = <var>q</var> + '''1'''。
### 否则，<var>e</var> ≠ <var>p</var>
#### 令 <var>T</var> 为一个字符串，它的值等于包含 在 <var>S</var> 中 <var>p</var>（包括它）位置到 <var>q</var>（不包括）位置的字符 的子字符串的值。
#### 以 [[ES5/conversion#ToString|ToString]](<var>lengthA</var>)、属性描述符 {<nowiki>[[Value]]</nowiki>: <var>T</var>, <nowiki>[[Writable]]</nowiki>: '''true''', <nowiki>[[Enumerable]]</nowiki>: '''true''', <nowiki>[[Configurable]]</nowiki>: '''true'''} 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法 .
#### <var>lengthA</var> 递增 '''1'''。
#### 如果 <var>lengthA</var> = <var>lim</var>，返回 <var>A</var>。
#### 令 <var>p</var> = <var>e</var>。
#### 令 <var>i</var> = '''0'''。
#### 只要 <var>i</var> 不等于 <var>cap</var> 中的元素个数，就重复。
##### 令 <var>i</var> = <var>i</var> + '''1'''。
##### 以 [[ES5/conversion#ToString|ToString]](<var>lengthA</var>)、属性描述符 {<nowiki>[[Value]]</nowiki>: <var>cap</var>[<var>i</var>], <nowiki>[[Writable]]</nowiki>: '''true''', <nowiki>[[Enumerable]]</nowiki>: '''true''', <nowiki>[[Configurable]]</nowiki>: '''true'''} 和 '''false''' 作为参数调用 A 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
##### <var>lengthA</var> 递增 '''1'''。
##### 如果 <var>lengthA</var> = <var>lim</var>，返回 <var>A</var>。
#### 令 <var>q</var> = <var>p</var>。
# 令 <var>T</var> 为 为一个字符串，它的值等于包含 在 <var>S</var> 中 <var>p</var>（包括它）位置到 <var>q</var>（不包括）位置的字符 的子字符串的值。
# 以 [[ES5/conversion#ToString|ToString]](<var>lengthA</var>)、属性描述符 {<nowiki>[[Value]]</nowiki>: <var>T</var>, <nowiki>[[Writable]]</nowiki>: '''true''', <nowiki>[[Enumerable]]</nowiki>: '''true''', <nowiki>[[Configurable]]</nowiki>: '''true'''} 和 '''false''' 作为参数调用 <var>A</var> 的 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]] 内部方法。
# 返回 <var>A</var>。


{{anchor|SplitMatch}}'''SplitMatch''' 抽象操作需要三个参数，字符串 <var>S</var>、整数 <var>q</var>、字符串或正则对象 <var>R</var>，按照以下顺序执行并返回一个 [[ES5/builtins#Patterns-MatchResult|MatchResult]]：

# 如果 <var>R</var> 是个正则对象 ( 它的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 是 '''"RegExp"''')，则 
## 以 <var>S</var> 和 <var>q</var> 作为参数调用 <var>R</var> 的 [[ES5/types#Match|<nowiki>[[Match]]</nowiki>]] 内部方法，并返回 [[ES5/builtins#Patterns-MatchResult|MatchResult]] 的结果。
# 否则，[[ES5/types#Type|Type]](<var>R</var>) 必定是 '''String'''。令 <var>r</var> 为 <var>R</var> 的字符数。{{extra note||如果为字符串时是按照字符子串的匹配算法（由实现定义），但返回的依然是MatchResult结构}}
# 令 <var>s</var> 为 <var>S</var> 的字符数 .
# 如果 <var>q</var> + <var>r</var> > <var>s</var> 则返回 [[ES5/builtins#Patterns-MatchResult|MatchResult]] '''failure'''。
# 如果存在一个在 '''0'''（包括）到 <var>r</var>（不包括）之间的整数 <var>i</var>，使得 <var>S</var> 的 <var>q</var> + <var>i</var> 位置上的字符和 <var>R</var> 的 <var>i</var> 位置上的字符不同，则返回 '''failure'''。
# 令 <var>cap</var> 为 '''captures''' 的空数组 ( 见 [[#x15.10.2.1|15.10.2.1]])。
# 返回 [[ES5/builtins#Patterns-State|State]] 数据结构 (<var>q</var> + <var>r</var>, <var>cap</var>). ( 见 [[#x15.10.2.1|15.10.2.1]])

'''split''' 方法的 '''length''' 属性是 '''2'''.

{{note| 分隔符是正则对象时，'''split''' 方法忽略 '''separator.global''' 的值。}}

{{note| split 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.15}}String.prototype.substring (start, end) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.15}}

<var>substring</var> 方法需要两个参数 <var>start</var> 和 <var>end</var>，将 '''this''' 对象转换为一个字符串，返回一个子串，这个子串包含了在转换结果字符串中从 <var>start</var> 位置字符一直到（但不包括）<var>end</var> 位置的字符（或如果 <var>end</var> 是 '''undefined'''，就到字符串末尾）。返回结果是字符串值，不是字符串对象。

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

如果 <var>start</var> 大于 <var>end</var>，交换它们的值。

采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.22/src/string.js#L713|}}

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>S</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#672|This.ToString}}
# 令 <var>len</var> 为 <var>S</var> 的字符数。
# 令 <var>intStart</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>start</var>)。
# 如果 <var>end</var> 是 '''undefined'''，令 <var>intEnd</var> 为 <var>len</var>；否则 令 <var>intEnd</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>end</var>)。
# 令 <var>finalStart</var> 为 [[ES5/builtins#x15.8.2.12|min]]([[ES5/builtins#x15.8.2.11|max]](<var>intStart</var>, '''0''' ), <var>len</var>)。
# 令 <var>finalEnd</var> 为 [[ES5/builtins#x15.8.2.12|min]]([[ES5/builtins#x15.8.2.11|max]](<var>intEnd</var>, '''0''' ), <var>len</var>)。
# 令 <var>from</var> 为 [[ES5/builtins#x15.8.2.12|min]](<var>finalStart</var>, <var>finalEnd</var>)。
# 令 <var>to</var> 为 [[ES5/builtins#x15.8.2.11|max]](<var>finalStart</var>, <var>finalEnd</var>)。
# 返回 一个长度是 <var>to</var> - <var>from</var> 的字符串，它包含 <var>S</var> 中从索引值 <var>form</var> 到 <var>to</var> - '''1'''（按照索引升序）的所有字符。 {{v8|https://github.com/v8/v8/blob/3.22/src/runtime.cc#L4389|SubString}}

'''substring''' 方法的 '''length''' 属性是 '''2'''。

{{note| '''substring''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.16}}String.prototype.toLowerCase ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.16}}

采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.22/src/string.js#L790|toLowerCase}}

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>S</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/string.js?r{{=}}13187#763|This.ToString}}
# 令 <var>L</var> 为一个字符串，<var>L</var> 的每个字符是 <var>S</var> 中相应字符的 Unicode 小写等量，或者（如果没有 Unicode 小写等量存在）是实际的 <var>S</var> 中相应字符值。{{extra note||这里只定义结果，具体过程由实现定义。}} {{v8|https://github.com/v8/v8/blob/3.22/src/runtime.cc#L6485|}}
# 返回 <var>L</var>。

为了此操作，字符串的16位代码单元被看作是 Unicode <b title="Basic Multilingual Plane">基本多文种平面</b>中的代码点。代理代码点直接从 <var>S</var> 转移到 <var>L</var>，不做任何映射。

返回结果必须是根据 Unicode 字符数据库里的大小写映射得到的（对此数据库明确规定，不仅包括 [http://www.unicode.org/Public/UNIDATA/UnicodeData.txt UnicodeData.txt] 文件，而且还包括 Unicode 2.1.8 和更高版本里附带的 [http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt SpecialCasings.txt] 文件）。

{{note| 某些字符的大小写映射可产生多个字符。这种情况下结果字符串与原字符串的长度未必相等。因为 '''toUpperCase''' 和 '''toLowerCase''' 都有上下文敏感的行为，所以这俩函数不是对称的。也就是说，'''s.toUpperCase().toLowerCase()''' 不一定等于 '''s.toLowerCase()'''。}}

{{note| '''toLowerCase''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.17}}String.prototype.toLocaleLowerCase ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.17}}

此函数产生依照 宿主环境的当前语言设置 更正的结果，而不是独立于语言环境的结果，除此之外它的运作方式与 '''toLowerCase''' 完全一样。只有在少数情况下有一个区别（如，土耳其语），就是那个语言和正规 Unicode 大小写映射有冲突时的规则。{{v8|https://github.com/v8/v8/blob/3.22/src/string.js#L800|}}

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

{{note| '''toLocaleLowerCase''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.18}}String.prototype.toUpperCase ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.18}}

此函数的将字符映射到在 Unicode 字符数据库中与其等值的大写字符，除此之外此函数的行为采用与 '''String.prototype.toLowerCase''' 完全相同的方式。{{v8|https://github.com/v8/v8/blob/3.22/src/runtime.cc#L6491|}}

{{note| '''toUpperCase''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.19}}String.prototype.toLocaleUpperCase ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.19}}

此函数产生依照 宿主环境的当前语言设置 更正的结果，而不是独立于语言环境的结果，除此之外它的运作方式与 '''toUpperCase''' 完全一样。只有在少数情况下有一个区别（如，土耳其语），就是那个语言和正规 Unicode 大小写映射有冲突时的规则。{{v8|https://github.com/v8/v8/blob/3.22/src/string.js#L820|}}

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

{{note| '''toLocaleUpperCase''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}


==== {{anchor|x15.5.4.20}}String.prototype.trim ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.20}}

采用以下步骤：{{v8|https://github.com/v8/v8/blob/3.22/src/string.js#L829|}}

# 以 '''this''' 值作为参数调用 [[ES5/conversion#CheckObjectCoercible|CheckObjectCoercible]]。
# 令 <var>S</var> 为以 '''this''' 值作为参数调用 [[ES5/conversion#ToString|ToString]] 的结果。
# 令 <var>T</var> 为一个字符串值，它是 <var>S</var> 的一个拷贝，并删除了开头和结尾中空白的。空白的定义是 [[ES5/lexical#white-space|空白字符]] 和 [[ES5/lexical#line-terminator|行终止符]] 的并集。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r{{=}}13187#6009|Substring Left to Right}}
# 返回 <var>T</var>。

{{note| '''trim''' 函数被有意设计成通用的；它不要求它的 '''this''' 值是字符串对象。因此，他可以当做方法转移到其他类型对象。}}

==={{anchor|x15.5.5}}String 实例的属性===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.5}}

字符串实例从字符串原型对象继承属性，字符串实例的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性值是 '''"String"'''。字符串实例还有 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性，'''length''' 属性，和一组属性名是数组索引的可遍历属性。

[[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性是代表这个字符串对象的字符串值。以数组索引命名的属性对应字符串值里的单字符。一个特殊的 '''<nowiki>[[GetOwnProperty]]</nowiki>''' 内部方法用来为数组索引命名的属性指定数字，值，和特性。

==== {{anchor|x15.5.5.1}}length ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.5.1}}

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

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

==== {{anchor|x15.5.5.2}}<nowiki>[[GetOwnProperty]]</nowiki> ( P ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.5.5.2}}

数组对象使用一个，用在其他原生 ECMAscript 对象的 [[ES5/types#GetOwnProperty|<nowiki>[[GetOwnProperty]]</nowiki>]] 内部方法的变化版。这个特殊内部方法用来给命名属性添加访问器，对应到字符串对象的单字符。{{v8|https://github.com/v8/v8/blob/3.22/src/objects.cc#L4463|}}

设 <var>S</var> 为一个字符串对象，<var>P</var> 为一个字符串。

当以属性名 <var>P</var> 调用 <var>S</var> 的 '''<nowiki>[[GetOwnProperty]]</nowiki>''' 内部方法，采用以下步骤：

# 令 <var>desc</var> 为 以 <var>P</var> 为参数调用 <var>S</var> 的默认 [[ES5/types#GetOwnProperty|<nowiki>[[GetOwnProperty]]</nowiki>]] 内部方法的结果。
# 如果 <var>desc</var> 不是 '''undefined'''，返回 <var>desc</var>。
# 如果 [[ES5/conversion#ToString|ToString]]([[ES5/notation#abs|abs]]( [[ES5/conversion#ToInteger|ToInteger]](<var>P</var> ))) 与 <var>P</var> 的值不同，返回 '''undefined'''。
# 令 <var>str</var> 为 <var>S</var> 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性字符串值。
# 令 <var>index</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>P</var>)。
# 令 <var>len</var> 为 <var>str</var> 里的字符数。
# 如果 <var>len</var> ≤ <var>index</var>，返回 '''undefined'''。
# 令 <var>resultStr</var> 为一个长度为 '''1''' 的字符串，里面包含 <var>str</var> 中 <var>index</var> 位置的一个字符，在这里 <var>str</var> 中的第一个（最左边）字符被认为是在位置 '''0'''，下一个字符在位置 '''1'''，依此类推。
# 返回一个属性描述符 { &#91;[Value]]: <var>resultStr</var>, &#91;[Enumerable]]: '''true''', &#91;[Writable]]: '''false''', &#91;[Configurable]]: '''false''' }

== {{anchor|x15.6}}Boolean 对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.6}}


=== {{anchor|x15.6.1}}作为函数调用 Boolean 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6.1}}

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


==== {{anchor|x15.6.1.1}}Boolean (value) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6.1.1}}

返回由 [[ES5/conversion#ToBoolean|ToBoolean]](<var>value</var>) 计算出的 '''Boolean''' 值（非 '''Boolean''' 对象）。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#219|ToBoolean}}


=== {{anchor|x15.6.2}}Boolean 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6.2}}

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


==== {{anchor|x15.6.2.1}}new Boolean (value) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6.2.1}}

新构造对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性设定为原始 [[#15.6.4|Boolean 原型对象]]，它是 [[#x15.6.3.1|Boolean.prototype]] 的初始值。

新构造对象的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性设定为 '''"Boolean"'''。

新构造对象的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性设定为 [[ES5/conversion#ToBoolean|ToBoolean]](<var>value</var>)。

新构造对象的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性设定为 '''true'''。


=== {{anchor|x15.6.3}}Boolean 构造器的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6.3}}

'''Boolean''' 构造器的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性的值是 [[#15.3.4|Function 原型对象]]。

除了内部属性和 '''length''' 属性（值为 '''1'''）外，'''Boolean''' 构造器还有以下属性：


==== {{anchor|x15.6.3.1}}Boolean.prototype====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6.3.1}}

'''Boolean.prototype''' 的初始值是 [[#15.6.4|Boolean 原型对象]]。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#223|Set Prototype}}

这个属性有特性 { &#91;[Writable]]: '''false''', &#91;[Enumerable]]: '''false''', &#91;[Configurable]]: '''false''' }。


=== {{anchor|x15.6.4}}Boolean 原型对象的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6.4}}

[[#15.6.4|Boolean 原型对象]]自身是一个值为 '''false''' 的 '''Boolean''' 对象（它的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 是 '''"Boolean"'''）。

[[#15.6.4|Boolean 原型对象]]的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性值是标准的内置 [[#15.2.4|Object 原型对象]]。


====Boolean.prototype.constructor{{anchor|x15.6.4.1}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6.4.1}}

'''Boolean.prototype.constructor''' 的初始值是内置的 '''Boolean''' 构造器。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#230|Set Prototype.constructor}}


===={{anchor|x15.6.4.2}}Boolean.prototype.toString ( )====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6.4.2}}

采用以下步骤：

# 令 <var>B</var> 为 '''this''' 值。
# 如果 [[ES5/types#Type|Type]](<var>B</var>) 是 '''Boolean'''，则令 <var>b</var> 为 <var>B</var>。
# 否则如果 [[ES5/types#Type|Type]](<var>B</var>) 是 '''Object''' 且 <var>B</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性值是 '''"Boolean"'''，则令 <var>b</var> 为 <var>B</var> 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性值。
# 否则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1340|Throw TypeError}}
# 如果 <var>b</var> 是 '''true'''，则返回 '''"true"'''；否则返回 '''"false"'''。


===={{anchor|x15.6.4.3}}Boolean.prototype.valueOf ( )====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6.4.3}}

采用以下步骤：

# 令 <var>B</var> 为 '''this''' 值。
# 如果 [[ES5/types#Type|Type]](<var>B</var>) 是 '''Boolean'''，则令 <var>b</var> 为 <var>B</var>。
# 否则如果 [[ES5/types#Type|Type]](<var>B</var>) 是 '''Object''' 且 <var>B</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性值是 '''"Boolean"'''，则令 <var>b</var> 为 <var>B</var> 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性值。
# 否则抛出一个 '''TypeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1352|Throw TypeError}}
# 返回 <var>b</var>。


=== {{anchor|x15.6.5}}Boolean 实例的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.6.5}}

'''Boolean''' 实例从 [[#15.6.4|Boolean 原型对象]]继承属性，且 '''Boolean''' 实例的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性值是 '''"Boolean"'''。'''Boolean''' 实例 还有一个 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性。

[[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性是代表这个 '''Boolean''' 对象的 '''Boolean''' 值。

== {{anchor|x15.7}}Number 对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.7}}


=== {{anchor|x15.7.1}}作为函数调用的 Number 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.1}}

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


==== {{anchor|x15.7.1.1}}Number ( [ value ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.1.1}}

如果提供了 <var>value</var>，返回 [[ES5/conversion#ToNumber|ToNumber]](<var>value</var>) 计算出的 '''Number''' 值（非 '''Number''' 对象），否则返回 '''+0'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1377|Default 0}}


=== {{anchor|x15.7.2}}Number 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.2}}

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


==== {{anchor|x15.7.2.1}}new Number ( [ value ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.2.1}}

新构造对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性设定为原始 [[#x15.7.4|Number 原型对象]]，它是 [[#15.7.3.1|Number.prototype]] 的初始值。

新构造对象的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性设定为 '''"Number"'''。

新构造对象的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性在提供了 <var>value</var> 时设定为 [[ES5/conversion#ToNumber|ToNumber]](<var>value</var>)，否则设定为 '''+0'''。

新构造对象的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性设定为 '''true'''。


=== {{anchor|x15.7.3}}Number 构造器的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.3}}

'''Number''' 构造器的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性值是 [[#15.3.4|Function 原型对象]]。

除了内部属性和 '''length''' 属性（值为 '''1'''）之外，'''Number''' 构造器还有以下属性：


==== {{anchor|x15.7.3.1}}Number.prototype ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.3.1}}

'''Number.prototype''' 的初始值是 [[#x15.7.4|Number 原型对象]]。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1385|Set Prototype}}

这个属性有特性 { &#91;[Writable]]: '''false''', &#91;[Enumerable]]: '''false''', &#91;[Configurable]]: '''false''' }。


==== {{anchor|x15.7.3.2}}Number.MAX_VALUE ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.3.2}}

'''Number.MAX_VALUE''' 的值是 '''Number''' 类型的最大正有限值，约为 '''1.7976931348623157×10<sup>308</sup>'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1529||Set Max Value}} {{extra note||<nowiki>这个值实际上就是64位IEEE754浮点数的最大规约数，尾数的52位全用二进制的1填充，指数位为其最大值1023。下面这个测试结果应为true：&#13;(Math.pow(2,53)-1)*Math.pow(2,1023-52)==Number.MAX_VALUE</nowiki>}}

这个属性有特性 { &#91;[Writable]]: '''false''', &#91;[Enumerable]]: '''false''', &#91;[Configurable]]: '''false''' }。


==== {{anchor|x15.7.3.3}}Number.MIN_VALUE ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.3.3}}

'''Number.MIN_VALUE''' 的值是 '''Number''' 类型的最小正有限值，约为 '''5×10<sup>-324</sup>'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1535|Set Min Value}} {{extra note||<nowiki>这个值实际上就是64位IEEE754浮点数的最小非规约数，尾数除了最低位之外都为0，指数位全为0。下面这个测试结果应为true：&#13;Math.pow(2,-1022-52)==Number.MIN_VALUE</nowiki>}}

这个属性有特性 { &#91;[Writable]]: '''false''', &#91;[Enumerable]]: '''false''', &#91;[Configurable]]: '''false''' }。


==== {{anchor|x15.7.3.4}}Number.NaN ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.3.4}}

'''Number.NaN''' 的值是 '''NaN'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1539|Set NaN Value}}

这个属性有特性 { &#91;[Writable]]: '''false''', &#91;[Enumerable]]: '''false''', &#91;[Configurable]]: '''false''' }。


==== {{anchor|x15.7.3.5}}Number.NEGATIVE_INFINITY ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.3.5}}

'''Number.NEGATIVE_INFINITY''' 的值是'''-∞'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1542|Set -INF Value}}

这个属性有特性 { &#91;[Writable]]: '''false''', &#91;[Enumerable]]: '''false''', &#91;[Configurable]]: '''false''' }。


==== {{anchor|x15.7.3.6}}Number.POSITIVE_INFINITY ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.3.6}}

'''Number.POSITIVE_INFINITY''' 的值是 '''+∞'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1548|Set INF Value}}

这个属性有特性 { &#91;[Writable]]: '''false''', &#91;[Enumerable]]: '''false''', &#91;[Configurable]]: '''false''' }。


=== {{anchor|x15.7.4}}Number 原型对象的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.4}}

'''Number''' 原型对象其自身是 '''Number''' 对象（其 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 是 '''"Number"'''），其值为 '''+0'''。

'''Number''' 原型对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性值是标准内置 [[#15.2.4|Object 原型对象]]。

除非另外明确声明，以下定义的 '''Number''' 原型对象的方法是非通用的，传递给它们的 '''this''' 值必须是 '''Number''' 值或 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性值是 '''"Number"''' 的对象。

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


==== {{anchor|x15.7.4.1}}Number.prototype.constructor ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.4.1}}

'''Number.prototype.constructor''' 的初始值是内置 '''Number''' 构造器。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1525|Set Prototype.constructor}}


==== {{anchor|x15.7.4.2}}Number.prototype.toString ( [ radix ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.4.2}}

可选参数 <var>radix</var> 应当是 '''2''' 到 '''36''' 闭区间上的整数。如果 <var>radix</var> 不存在或是 '''undefined'''，用数字 '''10''' 作为 <var>radix</var> 的值。如果 [[ES5/conversion#ToInteger|ToInteger]](<var>radix</var>) 是数字 '''10'''，则将 '''this Number 对象''' 作为一个参数传给 [[ES5/conversion#ToString|ToString]] 抽象操作；返回结果字符串值。

如果 [[ES5/conversion#ToInteger|ToInteger]]( <var>radix</var> ) 不是在 '''2''' 到 '''36''' 闭区间上的整数，则抛出一个 '''RangeError''' 异常。如果 [[ES5/conversion#ToInteger|ToInteger]]( <var>radix</var> ) 是 '''2''' 到 '''36''' 的整数，但不是 '''10'''，则结果是 '''this Number 值''' 使用指定基数表示法的字符串。字母 '''a-z''' 用来指值为 '''10''' 到 '''35''' 的数字。基数不为 '''10''' 时的精确算法是依赖于实现的，然而算法应当是 [[ES5/conversion#x9.8.1|9.8.1]] 指定算法的推广形式。

'''toString''' 函数不是通用的；如果 '''this''' 值不是数字或 '''Number''' 对象，抛出一个 '''TypeError''' 异常。因此它不能当作方法转移到其他类型对象上。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1394|Throw TypeError}}


==== {{anchor|x15.7.4.3}}Number.prototype.toLocaleString() ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.4.3}}

根据宿主环境的当前语言环境惯例来格式化 '''this Number 值'''，生成代表这个值的字符串。此函数是依赖于实现的，允许但不鼓励它的返回值与 '''toString''' 相同。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1416|Call NumberToString}}

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


==== {{anchor|x15.7.4.4}}Number.prototype.valueOf ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.4.4}}

返回 '''this Number 值'''。

'''valueOf''' 函数不是通用的；如果 '''this''' 值不是数字或 '''Number''' 对象，抛出一个 '''TypeError''' 异常。因此它不能当作方法转移到其他类型对象上。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1425|Throw TypeError}}


==== {{anchor|x15.7.4.5}}Number.prototype.toFixed (fractionDigits) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.4.5}}

返回一个包含了 代表 '''this Number 值'''的留有小数点后 <var>fractionDigits</var> 个数字的十进制固定小数点记法 的字符串。如果 <var>fractionDigits</var> 是 '''undefined'''，就认为是 '''0'''。具体来说，执行以下步骤：{{v8|https://github.com/v8/v8/blob/3.22/src/v8natives.js#L1547|}}

# 令 <var>f</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>fractionDigits</var>)。（如果 <var>fractionDigits</var> 是 '''undefined'''，此步骤产生 '''0''' 值。）
# 如果 <var>f</var> < '''0''' 或 <var>f</var> > '''20'''，抛出一个 '''RangeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1445|Throw RangeError}}
# 令 <var>x</var> 为 '''this Number 值'''。
# 如果 <var>x</var> 是 '''NaN'''，返回字符串 '''"NaN"'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1448|Return "NaN"}}
# 令 <var>s</var> 为空字符串。
# 如果 <var>x</var> < '''0'''，则 
## 令 <var>s</var> 为 '''"-"'''。
## 令 <var>x</var> = -<var>x</var>。
# 如果 <var>x</var> ≥ '''10<sup>21</sup>'''，则 
## 令 <var>m</var> = [[ES5/conversion#ToString|ToString]](<var>x</var>)。
# 否则，<var>x</var> < '''10<sup>21</sup>'''
## 令 <var>n</var> 为一个整数，让 <var>n</var> ÷ '''10'''<sup><var>f</var></sup> - <var>x</var> 准确的数学值尽可能接近零。如果有两个这样 <var>n</var> 值，选择较大的 <var>n</var>。{{extra note||<nowiki>根据这个定义n=round(x*pow(10,f))</nowiki>}}
## 如果 <var>n</var> = '''0'''，令 <var>m</var> 为字符串 '''"0"'''。否则，令 <var>m</var> 为由 <var>n</var> 的十进制表示里的数 组成的字符串（为了没有前导零）。
## 如果 <var>f</var> ≠ '''0'''，则 
### 令 <var>k</var> 为 <var>m</var> 里的字符数目。
### 如果 <var>k</var> ≤ <var>f</var>，则 
#### 令 <var>z</var> 为 <var>f</var> + '''1''' - <var>k</var> 个 '''<nowiki>'0'</nowiki>''' 组成的字符串。
#### 令 <var>m</var> 为 串联字符串 <var>z</var> 和 <var>m</var> 的结果。
#### 令 <var>k</var> = <var>f</var> + '''1'''。
### 令 <var>a</var> 为 <var>m</var> 的前 <var>k</var> – <var>f</var> 个字符，令 <var>b</var> 为其余 <var>f</var> 个字符。
### 令 <var>m</var> 为 串联三个字符串 <var>a</var>、'''"."''' 和 <var>b</var> 的结果。
# 返回串联字符串 <var>s</var> 和 <var>m</var> 的结果。

'''toFixed''' 方法的 '''length''' 属性是 '''1'''。

如果以多个参数调用 '''toFixed''' 方法，则行为是不确定的（[[#|见15章]]）。

实现是被允许在 <var>fractionDigits</var> 小于 '''0''' 或大于 '''20''' 时扩展 '''toFixed''' 的行为。在这种情况下，对这样的 <var>fractionDigits</var> 值 '''toFixed''' 将未必抛出 '''RangeError'''。

{{note | 对于某些值，'''toFixed''' 的输出可比 '''toString''' 的更精确，因为 '''toString''' 只打印区分相邻 '''Number''' 值的足够的有效数字。例如，{{extra note||toString是在十进制上对不精确的结果近似，而toFixed则是在二进制上对不精确的结果近似。这里的例子是使用了特殊数字，末尾的128在二进制上尾数全是0，所以toFixed不会舍去任何东西，它看起来精度比较高。实际上toString和toFixed只是近似时使用的进制不同，没有谁“更精确”。}}

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


==== {{anchor|x15.7.4.6}}Number.prototype.toExponential (fractionDigits) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.4.6}}

返回一个代表 '''this Number 值''' 的科学计数法的字符串，它的有效数字的小数点前有一个数字，有效数字的小数点后有 <var>fractionDigits</var> 个数字。如果 <var>fractionDigits</var> 是 '''undefined'''，包括指定唯一 '''Number''' 值需要的尽可能多的有效数字（就像 [[ES5/conversion#ToString|ToString]]，但在这里总是以科学计数法输出）。具体来说执行以下步骤：{{v8|https://github.com/v8/v8/blob/3.22/src/v8natives.js#L1572|}}

# 令 <var>x</var> 为 '''this Number 值'''。
# 令 <var>f</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>fractionDigits</var>)。
# 如果 <var>x</var> 是 '''NaN'''，返回字符串 '''"NaN"'''。
# 令 <var>s</var> 为空字符串。
# 如果 <var>x</var> < '''0'''，则 
## 令 <var>s</var> 为 '''"-"'''。
## 令 <var>x</var> = -<var>x</var>。
# 如果 <var>x</var> = '''+∞'''，则
## 返回串联字符串 <var>s</var> 和 '''"Infinity"''' 的结果。
# 如果 <var>fractionDigits</var> 不是 '''undefined''' 且（<var>f</var> < '''0''' 或 <var>f</var> > '''20'''），抛出一个 '''RangeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1476|Throw RangeError}}
# 如果 <var>x</var> = '''0'''，则 
## 令 <var>f</var> = '''0'''。
## 令 <var>m</var> 为包含 <var>f</var> + '''1''' 个 '''<nowiki>'0'</nowiki>''' 的字符串。
## 令 <var>e</var> = '''0'''。
# 否则，<var>x</var> ≠ '''0'''
## 如果 <var>fractionDigits</var> 不是 '''undefined'''，则 
### 令 <var>e</var> 和 <var>n</var> 为整数，使得满足 '''10'''<sup><var>f</var></sup> ≤ <var>n</var> < '''10'''<sup><var>f</var>+'''1'''</sup> 且 <var>n</var> × '''10'''<sup><var>e</var>-<var>f</var></sup> - <var>x</var> 的准确数学值尽可能接近零。如果 <var>e</var> 和 <var>n</var> 有两个这样的组合，选择使 <var>n</var> × '''10'''<sup><var>e</var>-<var>f</var></sup> 更大的组合。
## 否则，<var>fractionDigits</var> 是 '''undefined'''
### 令 <var>e</var>、<var>n</var> 和 <var>f</var> 为整数，使得满足 <var>f</var> ≥ '''0'''、'''10'''<sup><var>f</var></sup>≤ <var>n</var> < '''10'''<sup><var>f</var>+'''1'''</sup>、<var>n</var> × '''10'''<sup><var>e</var>-<var>f</var></sup> 的 '''Number''' 值是 <var>x</var>，且 <var>f</var> 的值尽可能小。注：<var>n</var> 的十进制表示有 <var>f</var> + '''1''' 个数字，<var>n</var> 不能被 '''10''' 整除，并且 <var>n</var> 的最少有效位数不一定唯一由这些条件确定。
## 令 <var>m</var> 为由 <var>n</var> 的十进制表示里的数 组成的字符串（没有前导零）。
# 如果 <var>f</var> ≠ '''0'''，则 
## 令 <var>a</var> 为 <var>m</var> 中的第一个字符，令 <var>b</var> 为 <var>m</var> 中的其余字符。
## 令 <var>m</var> 为串联三个字符串 <var>a</var>、'''"."''' 的 <var>b</var> 的结果。
# 如果 <var>e</var> = '''0'''，则 
## 令 <var>c</var> = '''"+"'''。
## 令 <var>d</var> = '''"0"'''。
# 否则 
## 如果 <var>e</var> > '''0'''，则 令 <var>c</var> = '''"+"'''。
## 否则，<var>e</var> ≤ '''0'''
### 令 <var>c</var> = '''"-"'''。
### 令 <var>e</var> = -<var>e</var>。
## 令 <var>d</var> 为有 <var>e</var> 的十进制表示里的数 组成的字符串（没有前导零）。
# 令 <var>m</var> 为串联四个字符串 <var>m</var>、'''"e"'''、<var>c</var> 和 <var>d</var> 的结果。
# 返回串联字符串 <var>s</var> 和 <var>m</var> 的结果。

'''toExponential''' 方法的 '''length''' 属性是 '''1'''。

如果用多于一个参数调用 '''toExponential''' 方法，则行为是未定义的（[[#|见15章]]）。

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

{{note| 对于需要提供比上述规则更准确转换的实现，建议用以下算法作为指引替代步骤 '''9.2.1'''：}}

# 令 <var>e</var>、<var>n</var> 和 <var>f</var> 为整数，使得满足 <var>f</var> ≥ '''0'''，'''10'''<sup><var>f</var></sup> ≤ <var>n</var> < '''10'''<sup><var>f</var>+'''1'''</sup>，<var>n</var> × '''10'''<sup><var>e</var>-<var>f</var></sup> 的 '''Number''' 值是 <var>x</var>，且 <var>f</var> 的值尽可能小。如果这样的 <var>n</var> 值可能多个，选择使 <var>n</var> × '''10'''<sup><var>e</var>-<var>f</var></sup> 的值尽可能接近 <var>x</var> 的 <var>n</var> 值。如果有两个这样的 <var>n</var> 值，选择偶数。


==== {{anchor|x15.7.4.7}}Number.prototype.toPrecision (precision) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.4.7}}

返回一个字符串，它代表 '''this Number 值''' 的科学计数法（有效数字的小数点前有一个数字，有效数字的小数点后有 <var>precision</var> - '''1''' 个数字）或十进制固定计数法（<var>precision</var> 个有效数字）。如果 <var>precision</var> 是 '''undefined'''，用 [[ES5/conversion#ToString|ToString]] 调用代替。具体来说执行以下步骤：{{v8|https://github.com/v8/v8/blob/3.22/src/v8natives.js#L1598|}}

# 令 <var>x</var> 为 '''this''' 数字值。
# 如果 <var>precision</var> 是 '''undefined'''，返回 [[ES5/conversion#ToString|ToString]](<var>x</var>)。
# 令 <var>p</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>precision</var>)。
# 如果 x 是 '''NaN'''，返回字符串 '''"NaN"'''。
# 令 <var>s</var> 为空字符串。
# 如果 <var>x</var> < '''0'''，则 
## 令 <var>s</var> 为 '''"-"'''。
## 令 <var>x</var> = -<var>x</var>。
# 如果 <var>x</var> = '''+∞'''，则 
## 返回串联字符串 <var>s</var> 和 '''"Infinity"''' 的结果。
# 如果 <var>p</var> < '''1''' 或 <var>p</var> > '''21'''，抛出一个 '''RangeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/v8natives.js?r{{=}}13187#1501|Throw RangeError}}
# 如果 <var>x</var> = '''0'''，则 
## 令 <var>m</var> 为 <var>p</var> 个 '''<nowiki>'0'</nowiki>''' 组成的字符串。
## 令 <var>e</var> = '''0'''。
# 否则 <var>x</var> ≠ '''0'''，
## 令 <var>e</var> 和 <var>n</var> 为整数，使得满足 '''10'''<sup><var>p</var>-'''1'''</sup> ≤ <var>n</var> < '''10'''<sup><var>p</var></sup> 且 <var>n</var> × '''10'''<sup><var>e</var>-<var>p</var>+'''1'''</sup> - <var>x</var> 的准确数学值尽可能接近零。如果 <var>e</var> 和 <var>n</var> 有两个这样的组合，选择使 <var>n</var> × '''10'''<sup><var>e</var>-<var>p</var>+'''1'''</sup> 更大的组合。
## 令 <var>m</var> 为由 <var>n</var> 的十进制表示里的数 组成的字符串（没有前导零）。
## 如果 <var>e</var> < '''-6''' 或 <var>e</var> ≥ <var>p</var>。则 
### 令 <var>a</var> 为 <var>n</var> 的第一个字符，令 <var>b</var> 为 <var>m</var> 的其余 <var>p</var>-'''1''' 个字符/
### 令 <var>m</var> 为串联三个字符串 <var>a</var>、'''"."''' 和 <var>b</var> 的结果。
### 如果 <var>e</var> = '''0'''，则 
#### 令 <var>c</var> = '''"+"'''，令 <var>d</var> = '''"0"'''。
### 否则 <var>e</var> ≠ '''0'''，
#### 如果 <var>e</var> > '''0'''，则 
##### 令 <var>c</var> = '''"+"'''。
#### 否则 <var>e</var> < '''0'''，
##### 令 <var>c</var> = '''"-"'''。
##### 令 <var>e</var> = -<var>e</var>。
#### 令 <var>d</var> 为由 <var>e</var> 的十进制表示里的数 组成的字符串（没有前导零）。
### 令 <var>m</var> 为串联五个字符串 <var>s</var>、<var>m</var>、'''"e"'''、<var>c</var> 和 <var>d</var> 的结果。
# 如果 <var>e</var> = <var>p</var> - '''1'''，则返回串联字符串 <var>s</var> 和 <var>m</var> 的结果。
# 如果 <var>e</var> ≥ '''0'''，则 
## 令 <var>m</var> 为 <var>m</var> 的前 <var>e</var> + '''1''' 个字符，字符 '''<nowiki>'.'</nowiki>'''，<var>m</var> 的其余 <var>p</var> - (<var>e</var> + '''1''') 个字符 串联的结果。
# 否则 <var>e</var> < '''0'''，
## 令 <var>m</var> 为 字符串 '''"0."'''、- (<var>e</var> + '''1''') 个字符 '''<nowiki>'0'</nowiki>'''、字符串 <var>m</var> 串联的结果。
# 返回字符串 <var>s</var> 和 <var>m</var> 串联的结果。

'''toPrecision''' 方法的 '''length''' 属性是 '''1'''。

如果用多于一个参数调用 '''toPrecision''' 方法，则行为是未定义的（[[#|见15章]]）。

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


=== {{anchor|x15.7.5}}Number 实例的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.7.5}}

'''Number''' 实例从 '''Number''' 原型对象继承属性，'''Number''' 实例的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性是 '''"Number"'''。'''Number''' 实例还有一个 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性。

[[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性是代表 '''this Number 对象''' 的 '''Number''' 值。

== {{anchor|x15.8}}Math 对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.8}}

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

'''Math''' 对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性值是标准内置 '''Object''' 原型对象 ([[#15.2.4|15.2.4]])。'''Math''' 对象的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性值是 '''"Math"'''。

'''Math''' 对象没有 [[ES5/types#Construct|<nowiki>[[Construct]]</nowiki>]] 内部属性 ; '''Math''' 对象不能作为构造器被 '''new''' 运算符调用。

'''Math''' 对象没有 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部属性；'''Math''' 对象不能作为函数被调用。

{{note| 本规范中，短语“'''''x'' 的 Number 值'''”的技术含义定义在 8.5。{{extra note|ES5/types#the-Number-value-for-x|}}}}


=== {{anchor|x15.8.1}}Math 对象的值属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.1}}


==== {{anchor|x15.8.1.1}}E ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.1.1}}

自然对数的底数 '''e''' 的 '''Number''' 值，约为 '''2.7182818284590452354'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#222|Set E}}

此属性有特性 <nowiki>{ [[Writable]]:</nowiki> '''false''' <nowiki>, [[Enumerable]]:</nowiki> '''false''' <nowiki>, [[Configurable]]:</nowiki> '''false''' <nowiki>}</nowiki> 。


==== {{anchor|x15.8.1.2}}LN10 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.1.2}}

'''10''' 的自然对数的 '''Number''' 值，约为 '''2.302585092994046'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#227|Set LN10}}

此属性有特性 <nowiki>{ [[Writable]]:</nowiki> '''false''' <nowiki>, [[Enumerable]]:</nowiki> '''false''' <nowiki>, [[Configurable]]:</nowiki> '''false''' <nowiki>}</nowiki> 。

==== {{anchor|x15.8.1.3}}LN2 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.1.3}}

'''2''' 的自然对数的 '''Number''' 值，约为 '''0.6931471805599453'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#232|Set LN2}}

此属性有特性 <nowiki>{ [[Writable]]:</nowiki> '''false''' <nowiki>, [[Enumerable]]:</nowiki> '''false''' <nowiki>, [[Configurable]]:</nowiki> '''false''' <nowiki>}</nowiki> 。


==== {{anchor|x15.8.1.4}}LOG2E ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.1.4}}

自然对数的底数''' e''' 的以 '''2''' 为底数的对数的 '''Number''' 值；约为 '''1.4426950408889634'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#237|Set LOG2E}}

此属性有特性 <nowiki>{ [[Writable]]:</nowiki> '''false''' <nowiki>, [[Enumerable]]:</nowiki> '''false''' <nowiki>, [[Configurable]]:</nowiki> '''false''' <nowiki>}</nowiki> 。

{{note|'''Math.LOG2E''' 的值约为 '''Math.LN2''' 值的倒数。}}


==== {{anchor|x15.8.1.5}}LOG10E ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.1.5}}

自然对数的底数 '''e''' 的以 '''10''' 为底数的对数的 '''Number''' 值；约为 '''0.4342944819032518'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#241|Set LOG10E}}

此属性有特性 <nowiki>{ [[Writable]]:</nowiki> '''false''' <nowiki>, [[Enumerable]]:</nowiki> '''false''' <nowiki>, [[Configurable]]:</nowiki> '''false''' <nowiki>}</nowiki> 。

{{note|'''Math.LOG10E''' 的值约为 '''Math.LN10''' 值的倒数。}}


==== {{anchor|x15.8.1.6}}PI ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.1.6}}

圆的周长与直径之比 '''π''' 的 '''Number''' 值，约为 '''3.1415926535897932'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#245|Set PI}}

此属性有特性 <nowiki>{ [[Writable]]:</nowiki> '''false''' <nowiki>, [[Enumerable]]:</nowiki> '''false''' <nowiki>, [[Configurable]]:</nowiki> '''false''' <nowiki>}</nowiki> 。


==== {{anchor|x15.8.1.7}}SQRT1_2 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.1.7}}

'''½''' 的平方根的 '''Number''' 值，约为 '''0.7071067811865476'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#249|Set SQRT1_2}}

此属性有特性 <nowiki>{ [[Writable]]:</nowiki> '''false''' <nowiki>, [[Enumerable]]:</nowiki> '''false''' <nowiki>, [[Configurable]]:</nowiki> '''false''' <nowiki>}</nowiki> 。

{{note|'''Math.SQRT1_2''' 的值约为 '''Math.SQRT2''' 值的倒数。}}


==== {{anchor|x15.8.1.8}}SQRT2 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.1.8}}

'''2''' 的平方根的 '''Number''' 值，约为 '''1.4142135623730951'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#253|Set SQRT2}}

此属性有特性 <nowiki>{ [[Writable]]:</nowiki> '''false''' <nowiki>, [[Enumerable]]:</nowiki> '''false''' <nowiki>, [[Configurable]]:</nowiki> '''false''' <nowiki>}</nowiki> 。


=== {{anchor|x15.8.2}}Math 对象的函数属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2}}

对以下每个 '''Math''' 对象函数的每个参数（如果有多个，以左到右的顺序）应用 [[ES5/conversion#ToNumber|ToNumber]] 抽象操作，然后对结果 '''Number''' 值执行计算。

下面对函数的描述中，符号 '''NaN'''、'''-0'''、'''+0'''、'''-∞'''、'''+∞''' 指 [[ES5/types#8.5|8.5]] 描述的 '''Number''' 值。
{{note|这里没有精确规定函数 '''acos'''、'''asin'''、'''atan'''、'''atan2'''、'''cos'''、'''exp'''、'''log'''、'''pow'''、'''sin'''、'''sqrt'''、'''tan''' 的行为，除了需要特别说明对边界情况某些参数值的结果之外。对其他参数值，这些函数指在计算常见数学函数的结果，但选择的近似算法中的某些范围是被允许的。一般意图是实现者应该可以为ECMAScript在一个给定的硬件平台上使用相同的数学库，那是在平台上对C程序员们有用的。}}

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


==== {{anchor|x15.8.2.1}}abs (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.1}}

返回 <var>x</var> 的绝对值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#44|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''-0'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''-∞'''，返回结果是 '''+∞'''。


==== {{anchor|x15.8.2.2}}acos (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.2}}

返回 <var>x</var> 的反余弦的依赖实现的近似值。结果以弧度形式表示，范围是 '''+0''' 到 '''+π'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#52|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 大于 '''1'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 小于 '''-1'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 正好是 '''1'''，返回结果是 '''+0'''。


==== {{anchor|x15.8.2.3}}asin (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.3}}

返回 <var>x</var> 的反正弦的依赖实现的近似值。结果以弧度形式表示，范围是 '''-π/2''' 到 '''+π/2'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#58|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 大于 '''1'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 小于 '''–1'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''+0'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''-0'''，返回结果是 '''-0'''。


==== {{anchor|x15.8.2.4}}atan (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.4}}

返回 <var>x</var> 的反正切的依赖实现的近似值。结果以弧度形式表示，范围是 '''-π/2''' 到 '''+π/2'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#64|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''+0'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''-0'''，返回结果是 '''-0'''。
* 若 <var>x</var> 是 '''+∞'''，返回结果是 一个依赖于实现的近似值 '''+π/2'''。
* 若 <var>x</var> 是 '''-∞'''，返回结果是 一个依赖于实现的近似值 '''-π/2'''。


==== {{anchor|x15.8.2.5}}atan2 (y, x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.5}}

返回 参数 <var>y</var> 和 <var>x</var> 的商 <var>y</var> / <var>x</var> 的反正切 的依赖实现的近似值，<var>y</var> 和 <var>x</var> 的符号用于确定返回值的象限。注：命名为 <var>y</var> 的参数为第一个，命名为 <var>x</var> 的参数为第二个，这是有意的，是反正切函数俩参数的惯例。结果以弧度形式表示，范围是 '''-π''' 到 '''+π'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#72|Function Def}}

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


==== {{anchor|x15.8.2.6}}ceil (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.6}}

返回不小于 <var>x</var> 的且为数学整数的最小 ( 接近 '''-∞''' )  '''Number''' 值。如果 <var>x</var> 已是整数，则返回 <var>x</var>。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#79|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''+0'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''-0'''，返回结果是 '''-0'''。
* 若 <var>x</var> 是 '''+∞'''，返回结果是 '''+∞'''。
* 若 <var>x</var> 是 '''-∞'''，返回结果是 '''-∞'''。
* 若 <var>x</var> 小于 '''0''' 但大于 '''-1'''，返回结果是 '''-0'''。

{{note|'''Math.ceil(x)''' 的值与 '''-Math.floor(-x)''' 的值相同。}}


==== {{anchor|x15.8.2.7}}cos (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.7}}

返回 <var>x</var> 的余弦的依赖实现的近似值。参数被当做是弧度值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#85|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''+0'''，返回结果是 '''1'''。
* 若 <var>x</var> 是 '''-0'''，返回结果是 '''1'''。
* 若 <var>x</var> 是 '''+∞'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''-∞'''，返回结果是 '''NaN'''。


==== {{anchor|x15.8.2.8}}exp (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.8}}

返回 <var>x</var> 的指数的依赖实现的近似值（'''e''' 为 <var>x</var> 次方，'''e''' 为自然对数的底）。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#91|Function Def}}

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

==== {{anchor|x15.8.2.9}}floor (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.9}}

返回不大于 <var>x</var> 的且为数学整数的最大 ( 接近 '''+∞''' ) '''Number''' 值。如果 <var>x</var> 已是整数，则返回 <var>x</var>。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#97|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''+0'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''-0'''，返回结果是 '''-0'''。
* 若 <var>x</var> 是 '''+∞'''，返回结果是 '''+∞'''。
* 若 <var>x</var> 是 '''-∞'''，返回结果是 '''-∞'''。
* 若 <var>x</var> 大于 '''0''' 但小于 '''1'''，返回结果是 '''+0'''。

{{note|'''Math.floor(x)''' 的值与 '''-Math.ceil(-x)''' 的值相同。}}


====log (x){{anchor|x15.8.2.10}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.10}}

返回 '''x''' 的自然对数的依赖于实现的近似值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#113|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 小于 '''0'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''+0''' 或 '''-0'''，返回结果是 '''-∞'''。
* 若 <var>x</var> 是 '''1'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''+∞'''，返回结果是 '''+∞'''。


==== {{anchor|x15.8.2.11}}max ( [ value1 [ , value2 [ , … ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.11}}

给定零或多个参数，对每个参数调用 [[ES5/conversion#ToNumber|ToNumber]] 并返回调用结果里的最大值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#119|Function Def}}

* 若 没有给定参数，返回结果是 '''-∞'''。
* 若 任何值是 '''NaN'''，返回结果是 '''NaN'''。
* 按照 [[ES5/expressions#x11.8.5|11.8.5]] 指定方式进行值比较，确定最大值，与 [[ES5/expressions#x11.8.5|11.8.5]] 指定方式的一个不同点是在这里 '''+0''' 被看作大于 '''-0'''。

'''max''' 方法的 '''length''' 属性是 '''2'''。


==== {{anchor|x15.8.2.12}}min ( [ value1 [ , value2 [ , … ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.12}}

给定零或多个参数，对每个参数调用 [[ES5/conversion#ToNumber|ToNumber]] 并返回调用结果里的最小值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#149|Function Def}}

* 若 没有给定参数，返回结果是 '''+∞'''。
* 若 任何值是 '''NaN'''，返回结果是 '''NaN'''。
* 按照 [[ES5/expressions#x11.8.5|11.8.5]] 指定方式进行值比较，确定最小值，与 [[ES5/expressions#x11.8.5|11.8.5]] 指定方式的一个不同点是在这里 '''+0''' 被看作大于 '''-0'''。

'''min''' 方法的 '''length''' 属性是 '''2'''。


====pow (x, y){{anchor|x15.8.2.13}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.13}}

返回 <var>x</var> 的 <var>y</var> 次方的依赖于实现的近似值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#179|Function Def}}

* 若 <var>y</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>y</var> 是 '''+0'''，返回结果是 '''1'''，即使 <var>x</var> 是 '''NaN'''。
* 若 <var>y</var> 是 '''-0'''，返回结果是 '''1'''，即使 <var>x</var> 是 '''NaN'''。
* 若 <var>x</var> 是 '''NaN''' 且 <var>y</var> 是 非零，返回结果是 '''NaN'''。
* 若 [[ES5/notation#abs|abs]](<var>x</var>) > '''1''' 且 <var>y</var> 是 '''+∞'''，返回结果是 '''+∞'''。
* 若 [[ES5/notation#abs|abs]](<var>x</var>) > '''1''' 且 <var>y</var> 是 '''-∞'''，返回结果是 '''+0'''。
* 若 [[ES5/notation#abs|abs]](<var>x</var>) == '''1''' 且 <var>y</var> 是 '''+∞'''，返回结果是 '''NaN'''。
* 若 [[ES5/notation#abs|abs]](<var>x</var>) == '''1''' 且 <var>y</var> 是 '''-∞'''，返回结果是 '''NaN'''。
* 若 [[ES5/notation#abs|abs]](<var>x</var>) < '''1''' 且 <var>y</var> 是 '''+∞'''，返回结果是 '''+0'''。
* 若 [[ES5/notation#abs|abs]](<var>x</var>) < '''1''' 且 <var>y</var> 是 '''-∞'''，返回结果是 '''+∞'''。
* 若 <var>x</var> 是 '''+∞''' 且 <var>y</var> > '''0'''，返回结果是 '''+∞'''。
* 若 <var>x</var> 是 '''+∞''' 且 <var>y</var> < '''0'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''-∞''' 且 <var>y</var> > '''0''' 且 <var>y</var> 是 一个奇数，返回结果是 '''-∞'''。
* 若 <var>x</var> 是 '''-∞''' 且 <var>y</var> > '''0''' 且 <var>y</var> 不是 一个奇数，返回结果是 '''+∞'''。
* 若 <var>x</var> 是 '''-∞''' 且 <var>y</var> < '''0''' 且 <var>y</var> 是 一个奇数，返回结果是 '''-0'''。
* 若 <var>x</var> 是 '''-∞''' 且 <var>y</var> < '''0''' 且 <var>y</var> 不是 一个奇数，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''+0''' 且 <var>y</var> > '''0'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''+0''' 且 <var>y</var> < '''0'''，返回结果是 '''+∞'''。
* 若 <var>x</var> 是 '''-0''' 且 <var>y</var> > '''0''' 且 <var>y</var> 是 一个奇数，返回结果是 '''-0'''。
* 若 <var>x</var> 是 '''-0''' 且 <var>y</var> > '''0''' 且 <var>y</var> 不是 一个奇数，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''-0''' 且 <var>y</var> < '''0''' 且 <var>y</var> 是 一个奇数，返回结果是 '''-∞'''。
* 若 <var>x</var> 是 '''-0''' 且 <var>y</var> < '''0''' 且 <var>y</var> 不是 一个奇数，返回结果是 '''+∞'''。
* 若 <var>x</var> < '''0''' 且 <var>x</var> 是有限的 且 <var>y</var> 是有限的 且 <var>y</var> 不是整数，返回结果是 '''NaN'''。


==== {{anchor|x15.8.2.14}}random ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.14}}

返回一个大于或等于 '''0''' 但小于 '''1''' 的符号为正的 '''Number''' 值，选择随机或在该范围内近似均匀分布的伪随机，用一个依赖与实现的算法或策略。此函数不需要参数。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#186|Function Def}}


==== {{anchor|x15.8.2.15}}round (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.15}}

返回最接近 <var>x</var> 且为数学整数的 '''Number''' 值。如果两个整数同等接近 <var>x</var>，则结果是接近 '''+∞''' 的 '''Number''' 值 。如果 <var>x</var> 已是整数，则返回 <var>x</var>。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#191|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''+0'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''-0'''，返回结果是 '''-0'''。
* 若 <var>x</var> 是 '''+∞'''，返回结果是 '''+∞'''。
* 若 <var>x</var> 是 '''-∞'''，返回结果是 '''-∞'''。
* 若 <var>x</var> 大于 '''0''' 但小于 '''0.5'''，返回结果是 '''+0'''。
* 若 <var>x</var> 小于 '''0''' 但大于或等于 '''-0.5'''，返回结果是 '''-0'''。

{{note| '''Math.round(3.5)''' 返回 '''4'''，但 '''Math.round(-3.5)''' 返回 '''-3'''。}}

{{note| 当 '''''x''''' 为 '''-0''' 或 '''''x''''' 小于 '''0''' 且大于等于 '''-0.5''' 时，'''Math.round(x)''' 返回 '''-0'''，而 '''Math.floor(x+0.5)''' 返回 '''+0'''。除了这种情况之外 '''Math.round(x)''' 的返回值与 '''Math.floor(x+0.5)''' 的返回值相同。}}


==== {{anchor|x15.8.2.16}}sin (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.16}}

返回 <var>x</var> 的正弦的依赖实现的近似值。参数被当做是弧度值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#197|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''+0'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''-0'''，返回结果是 '''-0'''。
* 若 <var>x</var> 是 '''+∞''' 或 '''-∞'''，返回结果是 '''NaN'''。


==== {{anchor|x15.8.2.17}}sqrt (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.17}}

返回 <var>x</var> 的平方根的依赖实现的近似值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#203|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 小于 '''0'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''+0'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''-0'''，返回结果是 '''-0'''。
* 若 <var>x</var> 是 '''+∞'''，返回结果是 '''+∞'''。


==== {{anchor|x15.8.2.18}}tan (x) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.8.2.18}}

返回 <var>x</var> 的正切的依赖实现的近似值。参数被当做是弧度值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/math.js?r{{=}}13187#209|Function Def}}

* 若 <var>x</var> 是 '''NaN'''，返回结果是 '''NaN'''。
* 若 <var>x</var> 是 '''+0'''，返回结果是 '''+0'''。
* 若 <var>x</var> 是 '''-0'''，返回结果是 '''-0'''。
* 若 <var>x</var> 是 '''+∞''' 或 '''-∞'''，返回结果是 '''NaN'''。

== {{anchor|x15.9}}Date 对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.9}}


=== {{anchor|x15.9.1}}Date 对象的概述和抽象操作的定义 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1}}

下面的抽象操作函数用来操作时间值（{{toanchor|15.9.1.1}} 定义）。注：任何情况下，如果这些函数之一的任意参数是 '''NaN'''，则结果将是 '''NaN'''。


==== {{anchor|x15.9.1.1}}时间值和时间范围 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.1}}

一个 '''Date''' 对象包含一个表示特定时间瞬间的毫秒的数字值。这样的数字值叫做<b title="time value">时间值</b>。一个时间值也可以是 '''NaN'''，说明这个 '''Date''' 对象不表示特定时间瞬间。

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

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

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


==== {{anchor|x15.9.1.2}}{{anchor|TimeWithinDay}}天数和天内时间 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.2}}

{{anchor|Day}}一个给定时间值 <var>t</var> 所属的天数是 {{extra note||从协调世界时的1970年1月1日开始的天数，1970年1月1日计为0，此之前的为负值。}}

  '''Day'''(<var>t</var>) = [[ES5/notation#floor|floor]](<var>t</var> / {{toanchor|msPerDay}})

{{anchor|msPerDay}}其中每天的毫秒数是

  '''msPerDay''' = '''86400000''' {{v8|https://github.com/v8/v8/blob/3.22/src/macros.py#L65|v8在macros.py中把这些东西定义成了宏。}}

余数叫做天内时间 

  '''TimeWithinDay'''(<var>t</var>) = <var>t</var> [[ES5/notation#modulo|modulo]] {{toanchor|msPerDay}}


==== {{anchor|x15.9.1.3}}年数 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3}}

{{anchor|DaysInYear}}ECMAScript 使用一个推算公历系统，来将一个天数映射到一个年数，并确定在那年的月份的日期。在这个系统中，闰年是且仅是（可被 '''4''' 整除）且（（不可被 '''100''' 整除）或（可被 '''400''' 整除））的年份。因此，<var>y</var> 年的天的数目定义为 

  '''DaysInYear'''(<var>y</var>) = '''365''' { 如果 (<var>y</var> [[ES5/notation#modulo|modulo]] '''4''') ≠ 0 }
                  = '''366''' { 如果 (<var>y</var> [[ES5/notation#modulo|modulo]] '''4''') = '''0''' 且 (<var>y</var> [[ES5/notation#modulo|modulo]] '''100''') ≠ '''0''' }
                  = '''365''' { 如果 (<var>y</var> [[ES5/notation#modulo|modulo]] '''100''') = '''0''' 且 (<var>y</var> [[ES5/notation#modulo|modulo]] '''400''') ≠ '''0''' }
                  = '''366''' { 如果 (<var>y</var> [[ES5/notation#modulo|modulo]] '''400''') = '''0''' }

{{anchor|DayFromYear}}所有非闰年有 '''365''' 天，其中每月的天的数目是常规的。闰年的二月里有个多出来的一天。 <var>y</var> 年第一天的天数是 : {{extra note||由于天数是从协调世时的1970年1月1日开始计的，所以这里的计算方法看起来有点诡异。}}

  '''DayFromYear'''(<var>y</var>) = '''365''' × (<var>y</var> - '''1970''') + [[ES5/notation#floor|floor]]((<var>y</var> - '''1969''') / '''4''') - [[ES5/notation#floor|floor]]((<var>y</var> - '''1901''') / '''100''') + [[ES5/notation#floor|floor]]((<var>y</var> - '''1601''')/'''400''')

{{anchor|TimeFromYear}}<var>y</var> 年的起始时间值是：

  '''TimeFromYear'''(<var>y</var>) = {{toanchor|msPerDay}} × {{toanchor|DayFromYear}}(<var>y</var>)

{{anchor|YearFromTime}}一个时间值决定的年数是：

  '''YearFromTime'''(<var>t</var>) = 满足条件 {{toanchor|TimeFromYear}}(<var>y</var>) ≤ <var>t</var> 的最大整数 <var>y</var> （接近正无穷）

{{anchor|InLeapYear}}若时间值在闰年内，闰年函数返回 '''1'''，否则返回 '''0'''：

  '''InLeapYear'''(<var>t</var>) = '''0''' { 如果 {{toanchor|DaysInYear}}({{toanchor|YearFromTime}}(<var>t</var>)) = '''365''' }
                = '''1''' { 如果 {{toanchor|DaysInYear}}({{toanchor|YearFromTime}}(<var>t</var>)) = '''366''' }


==== {{anchor|x15.9.1.4}}月数 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.4}}

{{anchor|MonthFromTime}}月份是由闭区间 '''0''' 到 '''11''' 内的一个整数确定。一个时间值 <var>t</var> 到一个月数的映射 '''MonthFromTime'''(<var>t</var>) 的定义为：

  '''MonthFromTime'''(<var>t</var>) = '''0''' 如果 '''0''' ≤ {{toanchor|DayWithinYear}}(<var>t</var>) < '''31'''
                     = '''1''' 如果 '''31''' ≤ {{toanchor|DayWithinYear}} (<var>t</var>) < '''59''' + {{toanchor|InLeapYear}}(<var>t</var>)
                     = '''2''' 如果 '''59''' + {{toanchor|InLeapYear}}(<var>t</var>) ≤ {{toanchor|DayWithinYear}} (<var>t</var>) < '''90''' + {{toanchor|InLeapYear}}(<var>t</var>)
                     = '''3''' 如果 '''90''' + {{toanchor|InLeapYear}}(<var>t</var>) ≤ {{toanchor|DayWithinYear}} (<var>t</var>) < '''120''' + {{toanchor|InLeapYear}}(<var>t</var>)
                     = '''4''' 如果 '''120''' + {{toanchor|InLeapYear}}(<var>t</var>) ≤ {{toanchor|DayWithinYear}} (<var>t</var>) < '''151''' + {{toanchor|InLeapYear}}(<var>t</var>)
                     = '''5''' 如果 '''151''' + {{toanchor|InLeapYear}}(<var>t</var>) ≤ {{toanchor|DayWithinYear}} (<var>t</var>) < '''181''' + {{toanchor|InLeapYear}}(<var>t</var>)
                     = '''6''' 如果 '''181''' + {{toanchor|InLeapYear}}(<var>t</var>) ≤ {{toanchor|DayWithinYear}} (<var>t</var>) < '''212''' + {{toanchor|InLeapYear}}(<var>t</var>)
                     = '''7''' 如果 '''212''' + {{toanchor|InLeapYear}}(<var>t</var>) ≤ {{toanchor|DayWithinYear}} (<var>t</var>) < '''243''' + {{toanchor|InLeapYear}}(<var>t</var>)
                     = '''8''' 如果 '''243''' + {{toanchor|InLeapYear}}(<var>t</var>) ≤ {{toanchor|DayWithinYear}} (<var>t</var>) < '''273''' + {{toanchor|InLeapYear}}(<var>t</var>)
                     = '''9''' 如果 '''273''' + {{toanchor|InLeapYear}}(<var>t</var>) ≤ {{toanchor|DayWithinYear}} (<var>t</var>) < '''304''' + {{toanchor|InLeapYear}}(<var>t</var>)
                     = '''10''' 如果 '''304''' + {{toanchor|InLeapYear}}(<var>t</var>) ≤ {{toanchor|DayWithinYear}} (<var>t</var>) < '''334''' + {{toanchor|InLeapYear}}(<var>t</var>)
                     = '''11''' 如果 '''334''' + {{toanchor|InLeapYear}}(<var>t</var>) ≤ {{toanchor|DayWithinYear}} (<var>t</var>) < '''365''' + {{toanchor|InLeapYear}}(<var>t</var>)

{{anchor|DayWithinYear}}其中 

  '''DayWithinYear'''(<var>t</var>) = {{toanchor|Day}}(<var>t</var>) - {{toanchor|DayFromYear}}({{toanchor|YearFromTime}}(<var>t</var>))

月数值 '''0''' 指一月；'''1''' 指二月；'''2''' 指三月；'''3''' 指四月；'''4''' 指五月；'''5''' 指六月；'''6''' 指七月；'''7''' 指八月；'''8''' 指九月；'''9''' 指十月；'''10''' 指十一月；'''11''' 指十二月。注：{{toanchor|MonthFromTime}}('''0''') = '''0'''，对应 '''1970 年 1 月 1 日'''，星期四。


==== {{anchor|x15.9.1.5}}{{anchor|DateFromTime}}日期数 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.5}}

一个日期数用闭区间 '''1''' 到 '''31''' 内的一个整数标识。从一个时间值 <var>t</var> 到一个日期数的映射 '''DateFromTime'''(<var>t</var>) 的定义为：
  '''DateFromTime'''(<var>t</var>) = {{toanchor|DayWithinYear}}(<var>t</var>) + '''1''' 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''0'''
    = {{toanchor|DayWithinYear}}(<var>t</var>) - '''30''' 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''1'''
    = {{toanchor|DayWithinYear}}(<var>t</var>) - '''58''' - {{toanchor|InLeapYear}}(<var>t</var>) 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''2'''
    = {{toanchor|DayWithinYear}}(<var>t</var>) - '''89''' - {{toanchor|InLeapYear}}(<var>t</var>) 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''3'''
    = {{toanchor|DayWithinYear}}(<var>t</var>) - '''119''' - {{toanchor|InLeapYear}}(<var>t</var>) 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''4'''
    = {{toanchor|DayWithinYear}}(<var>t</var>) - '''150''' - {{toanchor|InLeapYear}}(<var>t</var>) 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''5'''
    = {{toanchor|DayWithinYear}}(<var>t</var>) - '''180''' - {{toanchor|InLeapYear}}(<var>t</var>) 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''6'''
    = {{toanchor|DayWithinYear}}(<var>t</var>) - '''211''' - {{toanchor|InLeapYear}}(<var>t</var>) 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''7'''
    = {{toanchor|DayWithinYear}}(<var>t</var>) - '''242''' - {{toanchor|InLeapYear}}(<var>t</var>) 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''8'''
    = {{toanchor|DayWithinYear}}(<var>t</var>) - '''272''' - {{toanchor|InLeapYear}}(<var>t</var>) 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''9'''
    = {{toanchor|DayWithinYear}}(<var>t</var>) - '''303''' - {{toanchor|InLeapYear}}(<var>t</var>) 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''10'''
    = {{toanchor|DayWithinYear}}(<var>t</var>) - '''333''' - {{toanchor|InLeapYear}}(<var>t</var>) 如果 {{toanchor|MonthFromTime}}(<var>t</var>) = '''11'''


==== {{anchor|x15.9.1.6}}星期数 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.6}}

{{anchor|WeekDay}}特定时间值 <var>t</var> 对应的星期数的定义为：

  '''WeekDay'''(<var>t</var>) = ({{toanchor|Day}}(<var>t</var>) + '''4''') [[ES5/notation#modulo|modulo]] '''7'''

星期数的值 '''0''' 指星期日；'''1''' 指星期一；'''2''' 指星期二；'''3''' 指星期三；'''4''' 指星期四；'''5''' 指星期五；'''6''' 指星期六。注：{{toanchor|WeekDay}}('''0''') = '''4'''，对应 '''1970 年 1 月 01 日''' 星期四。


==== {{anchor|LocalTZA}}{{anchor|x15.9.1.7}}本地时区校准 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.7}}

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


==== {{anchor|DaylightSavingTA}}{{anchor|x15.9.1.8}}夏令时校准 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.8}}

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

（1）自本年开始以来的时间 

  <var>t</var> - {{toanchor|TimeFromYear}}({{toanchor|YearFromTime}}(<var>t</var>))

（2）<var>t</var> 是否在闰年内 

  {{toanchor|InLeapYear}}(<var>t</var>)

（3）本年第一天的星期数 

  {{toanchor|WeekDay}}({{toanchor|TimeFromYear}}({{toanchor|YearFromTime}}(<var>t</var>))

（4）地理位置。

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


==== {{anchor|x15.9.1.9}}本地时间 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.9}}

{{anchor|LocalTime}}从协调世界时到本地时间的转换，定义为 

  '''LocalTime'''(<var>t</var>) = <var>t</var> + {{toanchor|LocalTZA}} + {{toanchor|DaylightSavingTA}}(<var>t</var>)

{{anchor|UTC}}从本地时间到协调世界时的转换，定义为 

  '''UTC'''(<var>t</var>) = <var>t</var> - {{toanchor|LocalTZA}} - {{toanchor|DaylightSavingTA}}(<var>t</var> - {{toanchor|LocalTZA}})

{{note| '''UTC'''('''LocalTime'''(<var>t</var>)) 不一定总是等于 <var>t</var>。}}


==== {{anchor|x15.9.1.10}}小时、分钟、秒、毫秒 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10}}

{{anchor|HourFromTime}}{{anchor|MinFromTime}}{{anchor|SecFromTime}}{{anchor|msFromTime}}以下函数用于分解时间值：

  '''HourFromTime'''(<var>t</var>) = [[ES5/notation#floor|floor]](<var>t</var> / {{toanchor|msPerHour}}) [[ES5/notation#modulo|modulo]] {{toanchor|HoursPerDay}}
  '''MinFromTime'''(<var>t</var>) = [[ES5/notation#floor|floor]](<var>t</var> / {{toanchor|msPerMinute}}) [[ES5/notation#modulo|modulo]] {{toanchor|MinutesPerHour}}
  '''SecFromTime'''(<var>t</var>) = [[ES5/notation#floor|floor]](<var>t</var> / {{toanchor|msPerSecond}}) [[ES5/notation#modulo|modulo]] {{toanchor|SecondsPerMinute}}
  '''msFromTime'''(<var>t</var>) = <var>t</var> [[ES5/notation#modulo|modulo]] {{toanchor|msPerSecond}}

{{anchor|HoursPerDay}}{{anchor|MinutesPerHour }}{{anchor|SecondsPerMinute }}{{anchor|msPerSecond }}{{anchor|msPerMinute }}{{anchor|msPerHour}}其中 {{v8|https://github.com/v8/v8/blob/3.22/src/macros.py#L58|这些常量被使用py定义在宏中。}}

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


==== {{anchor|x15.9.1.11}}{{anchor|MakeTime}}MakeTime (hour, min, sec, ms) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.11}}

'''MakeTime''' 抽象操作用它的四个参数算出一个毫秒数，参数必须是 ECMAScript 数字值。此抽象操作运行如下：{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#72|Function Def}}

# 如果 <var>hour</var> 不是有限的或 <var>min</var> 不是有限的或 <var>sec</var> 不是有限的或 <var>ms</var> 不是有限的，返回 '''NaN'''。
# 令 <var>h</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>hour</var>)。
# 令 <var>m</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>min</var>)。
# 令 <var>s</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>sec</var>)。
# 令 <var>milli</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>ms</var>)。
# 令 <var>t</var> 为 <var>h</var> × {{toanchor|msPerHour}} + <var>m</var> × {{toanchor|msPerMinute}} + <var>s</var> × {{toanchor|msPerSecond}} + <var>milli</var>，执行的四则运算根据 IEEE 754 规则（这就像使用 ECMAScript 运算符 × 和 + 一样）。
# 返回 <var>t</var>。


==== {{anchor|x15.9.1.12}}{{anchor|MakeDay}}MakeDay (year, month, date) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.12}}

'''MakeDay''' 抽象操作用它的三个参数算出一个天数，参数必须是 ECMAScript 数字值。此抽象操作运行如下：{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#96|Function Def}}

# 如果 <var>year</var> 不是有限的或 <var>month</var> 不是有限的或 <var>date</var> 不是有限的，返回 '''NaN'''。
# 令 <var>y</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>year</var>)。
# 令 <var>m</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>month</var>)。
# 令 <var>dt</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>date</var>)。
# 令 <var>ym</var> 为 <var>y</var> + [[ES5/notation#floor|floor]](<var>m</var> / '''12''')。
# 令 <var>mn</var> 为 <var>m</var> [[ES5/notation#modulo|modulo]] '''12'''。
# 找一个满足 {{toanchor|YearFromTime}}(<var>t</var>) == <var>ym</var> 且 {{toanchor|MonthFromTime}}(<var>t</var>) == <var>mn</var> 且 {{toanchor|DateFromTime}}(<var>t</var>) == '''1''' 的 <var>t</var> 值；但如果这些条件是不可能的（因为有些参数超出了范围），返回 '''NaN'''。
# 返回 {{toanchor|Day}}(<var>t</var>) + <var>dt</var> - '''1'''。


==== {{anchor|x15.9.1.13}}{{anchor|MakeDate}}MakeDate (day, time) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.13}}

'''MakeDate''' 抽象操作用它的两个参数算出一个毫秒数，参数必须是 ECMAScript 数字值。此抽象操作运行如下：{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#115|Function Def}}

# 如果 <var>day</var> 不是有限的或 <var>time</var> 不是有限的，返回 '''NaN'''。
# 返回 <var>day</var> × {{toanchor|msPerDay}} + <var>time</var>。


==== {{anchor|x15.9.1.14}}{{anchor|TimeClip}}TimeClip (time) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.14}}

'''TimeClip''' 抽象操作用它的参数算出一个毫秒数，参数必须是 ECMAScript 数字值。此抽象操作运行如下：{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#128|Function Def}}

# 如果 <var>time</var> 不是有限的 , 返回 '''NaN'''。
# 如果 [[ES5/notation#abs|abs]](<var>time</var>) > '''8.64×10<sup>15</sup>''', 返回 '''NaN'''。
# 返回 [[ES5/conversion#ToInteger|ToInteger]](<var>time</var>) 和 [[ES5/conversion#ToInteger|ToInteger]](<var>time</var>) + ('''+0''') 之一，这依赖于实现 ( 加正一是为了将 '''-0''' 转换成 '''+0''' )。

{{note| '''第3步'''的重点是说允许实现自行选择时间值的内部表示形式，如64位有符号整数或64位浮点数。根据不同的实现，这个内部表示可能区分也可能无法区分 '''-0''' 和 '''+0'''。}}


==== {{anchor|x15.9.1.15}}日期时间字符串格式 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.15}}

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

其中个字段为：

{| border="0" cellspacing="0" cellpadding="5"
| '''YYYY'''
| 是公历中年的十进制数字。
|-
| '''-'''
| 在字符串中直接以'''“-”'''（连字符）出现两次。
|-
| '''MM'''
| 是一年中的月份，从 '''01'''（一月）到 '''12'''（十二月）。
|-
| '''DD'''
| 是月份中的日期，从 '''01''' 到 '''31'''。
|-
| '''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

所有数字必须是十进制的。如果缺少 '''MM''' 或 '''DD''' 字段，用 '''“01”''' 作为它们的值。如果缺少 '''mm''' 或 '''ss''' 字段，用 '''“00”''' 作为它们的值，对于缺少的 '''sss''' 用 '''“000”''' 作为它的值。对于缺少的时区偏移量用 '''“Z”'''。

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

{{note| 由于每天的开始和结束都在午夜，俩符号 '''00:00''' 和 '''24:00''' 可区分这样的可以是同一时间的两个午夜。这意味着两个符号 1995-02-04T24:00 和 1995-02-05T00:00 精准的指向同一时刻。}}

{{note| 不存在用来规范像 CET，EST 这样的民间时区缩写的国际标准。有时相同的缩写甚至使用不同的时区。出于这个原因，ISO 8601 和这里的格式指定数字来表示时区。}}


===== {{anchor|x15.9.1.15.1}}扩展的年 =====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.1.15.1}}

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


=== {{anchor|x15.9.2}}作为函数调用 Date 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.2}}

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

{{note| 函数调用 '''Date(…)''' 的结果和用相同参数调用表达式 '''new Date(…)''' 创建的对象是不同的。}}


==== {{anchor|x15.9.2.1}}Date ( [ year [, month [, date [, hours [, minutes [, seconds [, ms ] ] ] ] ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.2.1}}

所有参数都是可选的；接受提供的任何参数，但被完全忽略。返回一个仿佛是用表达式 '''(new Date()).toString()''' 创建的字符串，这里的 '''Date''' 是标准内置构造器，'''toString''' 是标准内置方法 '''Date.prototype.toString'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#145|Function Def}}


=== {{anchor|x15.9.3}}Date 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.3}}

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


==== {{anchor|x15.9.3.1}}new Date (year, month [, date [, hours [, minutes [, seconds [, ms ] ] ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.3.1}}

当用二到七个参数调用 '''Date''' 构造器，它用 <var>year</var>、<var>month</var> 还有（可选的）<var>date</var>、<var>hours</var>、<var>minutes</var>、<var>seconds</var>、<var>ms</var> 来计算时间。

新构造对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性设定为原始的时间原型对象，它是 [[#x15.9.4.1|Date.prototype]] 的初始值。

新构造对象的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性设定为 '''"Date"'''。

新构造对象的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性设定为 '''ture'''。

新构造对象的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性按照以下步骤设定：

# 令 <var>y</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>year</var>)。
# 令 <var>m</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>month</var>)。
# 如果提供了 <var>date</var>，则令 <var>dt</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>date</var>)；否则令 <var>dt</var> 为 '''1'''。
# 如果提供了 <var>hours</var>，则令 <var>h</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>hours</var>)；否则令 <var>h</var> 为 '''0'''。
# 如果提供了 <var>minutes</var>，则令 <var>min</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>minutes</var>)；否则令 <var>min</var> 为 '''0'''。
# 如果提供了 <var>seconds</var>，则令 <var>s</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>seconds</var>)；否则令 <var>s</var> 为 '''0'''。
# 如果提供了 <var>ms</var>，则令 <var>milli</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>ms</var>)；否则令 <var>milli</var> 为 '''0'''。
# 如果 <var>y</var> 不是 '''NaN''' 且 '''0''' ≤ [[ES5/conversion#ToInteger|ToInteger]](<var>y</var>) ≤ '''99'''，则令 <var>yr</var> 为 '''1900'''+[[ES5/conversion#ToInteger|ToInteger]](<var>y</var>)；否则令 <var>yr</var> 为 <var>y</var>。
# 令 <var>finalDate</var> 为 {{toanchor|MakeDate}}({{toanchor|MakeDay}}(<var>yr</var>, <var>m</var>, <var>dt</var>), {{toanchor|MakeTime}}(<var>h</var>, <var>min</var>, <var>s</var>, <var>milli</var>))。
# 设定新构造对象的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 {{toanchor|TimeClip}}({{toanchor|UTC}}(finalDate))。


==== {{anchor|x15.9.3.2}}new Date (value) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.3.2}}

新构造对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性设定为原始的时间原型对象，它是 [[#x15.9.4.1|Date.prototype]] 的初始值。

新构造对象的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性设定为 '''"Date"'''。

新构造对象的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性设定为 '''ture'''。

新构造对象的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性按照以下步骤设定：

# 令 <var>v</var> 为 [[ES5/conversion#ToPrimitive|ToPrimitive]](<var>value</var>)。
# 如果 [[ES5/types#Type|Type]](<var>v</var>) 是 '''String'''，则 
## 用与 '''parse''' 方法 ([[#x15.9.4.2|15.9.4.2]]) 完全相同的方式将 <var>v</var> 解析为一个日期时间；令 <var>V</var> 为这个日期时间的时间值。
# 否则，令 <var>V</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>v</var>)。
# 设定新构造对象的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 {{toanchor|TimeClip}}(<var>V</var>)，并返回这个值。


==== {{anchor|x15.9.3.3}}new Date ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.3.3}}

新构造对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性设定为原始的时间原型对象，它是 [[#x15.9.4.1|Date.prototype]] 的初始值。

新构造对象的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性设定为 '''"Date"'''。

新构造对象的 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 内部属性设定为 '''ture'''。

新构造对象的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性设定为表示当前时间的时间值（协调世界时）。


=== {{anchor|x15.9.4}}Date 构造器的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.4}}

'''Date''' 构造器的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性的值是 [[#x15.3.4|Function 原型对象]]。

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


==== {{anchor|x15.9.4.1}}Date.prototype ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.4.1}}

'''Date.prototype''' 的初始值是内置的 [[#x15.9.5|Date''' 原型对象]]。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#205|Set Prototype}}

此属性有特性 <nowiki>{ [[Writable]]: </nowiki>'''false'''<nowiki>, [[Enumerable]]: </nowiki>'''false'''<nowiki>, [[Configurable]]: </nowiki>'''false''' <nowiki>}</nowiki>。

==== {{anchor|x15.9.4.2}}Date.parse (string) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.4.2}}

'''parse''' 函数对它的参数应用 [[ES5/conversion#ToString|ToString]] 操作并将结果字符串解释为一个日期和时间；返回一个数字值，是对应这个日期时间的 UTC 时间值。字符串可解释为本地时间，UTC 时间，或某个其他时区的时间，这取决于字符串里的内容。此函数首先尝试根据日期时间字符串格式（[[#x15.9.1.15|15.9.1.15]]）里的规则来解析字符串的格式。如果字符串不符合这个格式此函数可回退，用任意实现定义的试探方式或日期格式。无法识别的字符串或日期时间包含非法元素值，将导致 '''Date.parse''' 返回 '''NaN'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#277|Function Def}}

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

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

然而，表达式 

  Date.parse( x.toLocaleString())

是不需要产生与前面三个表达参数相同的数字值。通常，在给定的字符串不符合日期时间字符串格式（[[#x15.9.1.15|15.9.1.15]]）时，'''Date.parse''' 的产生值是依赖于实现，并且在同一实现中 '''toString''' 或 '''toUTCString''' 方法不能产生不符合日期时间字符串格式的字符串。


==== {{anchor|x15.9.4.3}}Date.UTC (year, month [, date [, hours [, minutes [, seconds [, ms ] ] ] ] ]) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.4.3}}

当用少于两个的参数调用 '''UTC''' 函数时，它的行为是依赖于实现的。当用二到七个参数调用 '''UTC''' 函数，它从 <var>year</var>、<var>month</var> 和（可选的）<var>date</var>、<var>hours</var>、<var>minutes</var>、<var>seconds</var>、<var>ms</var> 计算出日期时间。采用以下步骤：{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#294|Function Def}}

# 令 <var>y</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>year</var>)。
# 令 <var>m</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>month</var>)。
# 如果提供了 <var>date</var>，则令 <var>dt</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>date</var>)；否则令 <var>dt</var> 为 '''1'''。
# 如果提供了 <var>hours</var>，则令 <var>h</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>hours</var>)；否则令 <var>h</var> 为 '''0'''。
# 如果提供了 <var>minutes</var>，则令 <var>min</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>minutes</var>)；否则令 <var>min</var> 为 '''0'''。
# 如果提供了 <var>seconds</var>，则令 <var>s</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>seconds</var>);；否则令 <var>s</var> 为 '''0'''。
# 如果提供了 <var>ms</var>，则令 <var>milli</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>ms</var>)；否则令 <var>milli</var> 为 '''0'''。
# 如果 <var>y</var> 不是 '''NaN''' 且 '''0''' ≤ [[ES5/conversion#ToInteger|ToInteger]](<var>y</var>) ≤ '''99'''，则令 <var>yr</var> 为 '''1900''' + [[ES5/conversion#ToInteger|ToInteger]](<var>y</var>)；否则令 <var>yr</var> 为 <var>y</var>。
# 返回 {{toanchor|TimeClip}}({{toanchor|MakeDate}}({{toanchor|MakeDay}}(<var>yr</var>, <var>m</var>, <var>dt</var>), {{toanchor|MakeTime}}(<var>h</var>, <var>min</var>, <var>s</var>, <var>milli</var>)))。

'''UTC''' 函数的 '''length''' 属性是 '''7'''。


{{ note| '''UTC''' 函数与 '''Date''' 构造器的不同点有：它返回一个时间值，而不是创建 '''Date''' 对象，还有它将参数解释为 '''UTC'''，而不是本地时间。}}

==== {{anchor|x15.9.4.4}}Date.now ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.4.4}}

'''now''' 函数返回一个数字值，它表示调用 '''now''' 时的 '''UTC''' 日期时间的时间值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#314|Function Def}}


=== {{anchor|x15.9.5}}Date 原型对象的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5}}

'''Date''' 原型对象自身是一个 '''Date''' 对象（其 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 是 '''"Date"'''），其 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 是 '''NaN''' {{ie partial||IE9之前的版本这个值为0。}}。

'''Date''' 原型对象的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 内部属性的值是标准内置 [[#x15.2.4|Object''' 原型对象]]。

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


==== {{anchor|x15.9.5.1}}Date.prototype.constructor ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.1}}

'''Date.prototype.constructor''' 的初始值是内置 '''Date''' 构造器。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#778|Set Prototype.constructor}}


==== {{anchor|x15.9.5.2}}Date.prototype.toString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.2}}

此函数返回一个字符串值。字符串中内容是依赖于实现的，但目的是用一种方便，人类可读的形式表示当前时区的时间。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#320|Function Def}}

{{ note| 对毫秒数为零的任意 '''Date''' 值 '''''d'''''，'''Date.parse(d.toString())''' 和 '''d.valueOf()''' 的结果相同。见 15.9.4.2}}

==== {{anchor|x15.9.5.3}}Date.prototype.toDateString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.3}}

此函数返回一个字符串值。字符串中内容是依赖于实现的，但目的是用一种方便，人类可读的形式表示当前时区时间的“日期”部分。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#329|Function Def}}


==== {{anchor|x15.9.5.4}}Date.prototype.toTimeString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.4}}

此函数返回一个字符串值。字符串中内容是依赖于实现的，但目的是用一种方便，人类可读的形式表示当前时区时间的“时间”部分。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#337|Function Def}}


==== {{anchor|x15.9.5.5}}Date.prototype.toLocaleString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.5}}

这个函数返回一个 String 值。String 的内容由实现决定，但它的目的是使用一种与宿主环境的语言习惯对应的人类可读形式来方便地表述当前时区中的 Date。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#346|Function Def}}

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


==== {{anchor|x15.9.5.6}}Date.prototype.toLocaleDateString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.6}}

这个函数返回一个 String 值。String 的内容由实现决定，但它的目的是使用一种与宿主环境的语言习惯对应的人类可读形式来方便地表述当前时区中的 Date 的日期部分。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#352|Function Def}}

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


==== {{anchor|x15.9.5.7}}Date.prototype.toLocaleTimeString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.7}}

这个函数返回一个 String 值。String 的内容由实现决定，但它的目的是使用一种与宿主环境的语言习惯对应的人类可读形式来方便地表述当前时区中的 Date 的时间部分。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#360|Function Def}}

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


==== {{anchor|x15.9.5.8}}Date.prototype.valueOf ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.8}}

'''valueOf''' 函数返回一个数字值，它是 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#368|Function Def}}


==== {{anchor|x15.9.5.9}}Date.prototype.getTime ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.9}}

# 返回 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#374|Function Def}}


===={{anchor|x15.9.5.10}}Date.prototype.getFullYear ( ) {{extra note|ES5/annexB#Date.prototype.getYear|<nowiki>还有个Date.prototype.getYear方法，这在ES5的附录中定义。</nowiki>}}====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.10}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#380|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|YearFromTime}}({{toanchor|LocalTime}}(<var>t</var>))。 


==== {{anchor|x15.9.5.11}}Date.prototype.getUTCFullYear ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.11}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#386|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|YearFromTime}}(<var>t</var>)。


==== {{anchor|x15.9.5.12}}Date.prototype.getMonth ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.12}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#392|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|MonthFromTime}}({{toanchor|LocalTime}}(<var>t</var>))。


==== {{anchor|x15.9.5.13}}Date.prototype.getUTCMonth ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.13}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#398|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|MonthFromTime}}(<var>t</var>)。


==== {{anchor|x15.9.5.14}}Date.prototype.getDate ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.14}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#404|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|DateFromTime}}({{toanchor|LocalTime}}(<var>t</var>))。


==== {{anchor|x15.9.5.15}}Date.prototype.getUTCDate ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.15}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#410|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|DateFromTime}}(<var>t</var>)。


==== {{anchor|x15.9.5.16}}Date.prototype.getDay ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.16}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#416|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|WeekDay}}({{toanchor|LocalTime}}(<var>t</var>))。


==== {{anchor|x15.9.5.17}}Date.prototype.getUTCDay ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.17}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#422|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|WeekDay}}(<var>t</var>)。


==== {{anchor|x15.9.5.18}}Date.prototype.getHours ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.18}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#428|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|HourFromTime}}({{toanchor|LocalTime}}(<var>t</var>))。


==== {{anchor|x15.9.5.19}}Date.prototype.getUTCHours ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.19}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#434|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|HourFromTime}}(<var>t</var>)。


==== {{anchor|x15.9.5.20}}Date.prototype.getMinutes ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.20}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#440|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|MinFromTime}}({{toanchor|LocalTime}}(<var>t</var>))。


==== {{anchor|x15.9.5.21}}Date.prototype.getUTCMinutes ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.21}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#446|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|MinFromTime}}(<var>t</var>)。


==== {{anchor|x15.9.5.22}}Date.prototype.getSeconds ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.22}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#452|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|SecFromTime}}({{toanchor|LocalTime}}(<var>t</var>))。


==== {{anchor|x15.9.5.23}}Date.prototype.getUTCSeconds ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.23}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#458|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|SecFromTime}}(<var>t</var>)。


==== {{anchor|x15.9.5.24}}Date.prototype.getMilliseconds ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.24}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#464|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|msFromTime}}({{toanchor|LocalTime}}(<var>t</var>))。


==== {{anchor|x15.9.5.25}}Date.prototype.getUTCMilliseconds ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.25}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#458|Function Def}}
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 {{toanchor|msFromTime}}(<var>t</var>)。


==== {{anchor|x15.9.5.26}}Date.prototype.getTimezoneOffset ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.26}}

返回本地时间和 UTC 时间之间相差的分钟数。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#476|Function Def}}

# 令 <var>t</var> 为 '''this 时间值'''。
# 如果 <var>t</var> 是 '''NaN'''，返回 '''NaN'''。
# 返回 ( <var>t</var> - {{toanchor|LocalTime}}(<var>t</var>) ) / {{toanchor|msPerMinute}} )。


==== {{anchor|x15.9.5.27}}Date.prototype.setTime (time) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.27}}

# 令 <var>v</var> 为 {{toanchor|TimeClip}}([[ES5/conversion#ToNumber|ToNumber]](<var>time</var>))。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#482|Function Def}}
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>v</var>。
# 返回 <var>v</var>。


==== {{anchor|x15.9.5.28}}Date.prototype.setMilliseconds (ms) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.28}}

# 令 <var>t</var> 为 {{toanchor|LocalTime}}('''this 时间值''') 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#490|Function Def}}
# 令 <var>time</var> 为 {{toanchor|MakeTime}}({{toanchor|HourFromTime}}(<var>t</var>), {{toanchor|MinFromTime}}(<var>t</var>), {{toanchor|SecFromTime}}(<var>t</var>), [[ES5/conversion#ToNumber|ToNumber]](<var>ms</var>))。
# 令 <var>u</var> 为 {{toanchor|TimeClip}}({{toanchor|UTC}}({{toanchor|MakeDate}}({{toanchor|Day}}(<var>t</var>), <var>time</var>)))。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>u</var>。
# 返回 <var>u</var>。


==== {{anchor|x15.9.5.29}}Date.prototype.setUTCMilliseconds (ms) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.29}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#499|Function Def}}
# 令 <var>time</var> 为 {{toanchor|MakeTime}}({{toanchor|HourFromTime}}(<var>t</var>), {{toanchor|MinFromTime}}(<var>t</var>), {{toanchor|SecFromTime}}(<var>t</var>), [[ES5/conversion#ToNumber|ToNumber]](<var>ms</var>))。
# 令 <var>v</var> 为 {{toanchor|TimeClip}}({{toanchor|MakeDate}}({{toanchor|Day}}(<var>t</var>), <var>time</var>))。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>v</var>。
# 返回 <var>v</var>。


==== {{anchor|x15.9.5.30}}Date.prototype.setSeconds (sec [, ms ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.30}}

没指定 <var>ms</var> 参数时的行为是，仿佛 <var>ms</var> 被指定为调用 [[#x15.9.5.24|getMilliseconds]]() 的结果一样。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#511|Function Def}}

# 令 <var>t</var> 为 {{toanchor|LocalTime}}( '''this 时间值''' ) 的结果。
# 令 <var>s</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>sec</var>)。
# 如果没指定 <var>ms</var>，则令 <var>milli</var> 为 {{toanchor|msFromTime}}(<var>t</var>)；否则，令 <var>milli</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>ms</var>)。
# 令 <var>date</var> 为 {{toanchor|MakeDate}}({{toanchor|Day}}(<var>t</var>), {{toanchor|MakeTime}}({{toanchor|HourFromTime}}(<var>t</var>), {{toanchor|MinFromTime}}(<var>t</var>), <var>s</var>, <var>milli</var>))。
# 令 <var>u</var> 为 {{toanchor|TimeClip}}({{toanchor|UTC}}(<var>date</var>))。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>u</var>。
# 返回 <var>u</var>。

'''setSeconds''' 方法的 '''length''' 属性是 '''2'''。


==== {{anchor|x15.9.5.31}}Date.prototype.setUTCSeconds (sec [, ms ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.31}}

没指定 <var>ms</var> 参数时的行为是，仿佛 <var>ms</var> 被指定为调用 [[#x15.9.5.25|getUTCMilliseconds]]() 的结果一样。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#521|Function Def}}

# 令 <var>t</var> 为 '''this 时间值'''。
# 令 <var>s</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>sec</var>)。
# 如果没指定 <var>ms</var>，则令 <var>milli</var> 为 {{toanchor|msFromTime}}(<var>t</var>)；否则，令 milli 为 [[ES5/conversion#ToNumber|ToNumber]](<var>ms</var>)。
# 令 <var>date</var> 为 {{toanchor|MakeDate}}({{toanchor|Day}}(<var>t</var>), {{toanchor|MakeTime}}({{toanchor|HourFromTime}}(<var>t</var>), {{toanchor|MinFromTime}}(<var>t</var>), <var>s</var>, <var>milli</var>))。
# 令 <var>v</var> 为 {{toanchor|TimeClip}}(<var>date</var>)。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>v</var>。
# 返回 <var>v</var>。

'''setUTCSeconds''' 方法的 '''length''' 属性是 '''2'''。


==== {{anchor|x15.9.5.32}}Date.prototype.setMinutes (min [, sec [, ms ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.32}}

没指定 <var>sec</var> 参数时的行为是，仿佛 <var>sec</var> 被指定为调用 [[#x15.9.5.22|getSeconds]]() 的结果一样。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#531|Function Def}}

没指定 <var>ms</var> 参数时的行为是，仿佛 <var>ms</var> 被指定为调用 [[#x15.9.5.24|getMilliseconds]]() 的结果一样。

# 令 <var>t</var> 为 {{toanchor|LocalTime}}( '''this 时间值''' ) 的结果。
# 令 <var>m</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>min</var>)。
# 如果没指定 <var>sec</var>，则令 <var>s</var> 为 {{toanchor|SecFromTime}}(<var>t</var>)；否则，令 <var>s</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>sec</var>)。
# 如果没指定 <var>ms</var>，则令 <var>milli</var> 为 {{toanchor|msFromTime}}(<var>t</var>)；否则，令 <var>milli</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>ms</var>)。
# 令 <var>date</var> 为 {{toanchor|MakeDate}}({{toanchor|Day}}(<var>t</var>)，{{toanchor|MakeTime}}({{toanchor|HourFromTime}}(<var>t</var>), <var>m</var>, <var>s</var>, <var>milli</var>))。
# 令 <var>u</var> 为 {{toanchor|TimeClip}}({{toanchor|UTC}}(<var>date</var>))。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>u</var>。
# 返回 <var>u</var>。

'''setMinutes''' 方法的 '''length''' 属性是 '''3'''。


==== {{anchor|x15.9.5.33}}Date.prototype.setUTCMinutes (min [, sec [, ms ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.33}}

没指定 <var>sec</var> 参数时的行为是，仿佛 <var>sec</var> 被指定为调用 [[#x15.9.5.23|getUTCSeconds]]() 的结果一样。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#543|Function Def}}

没指定 <var>ms</var> 参数时的行为是，仿佛 <var>ms</var> 被指定为调用 [[#x15.9.5.25|getUTCMilliseconds]]() 的结果一样。

# 令 <var>t</var> 为 '''this 时间值'''。
# 令 <var>m</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>min</var>)。
# 如果没指定 <var>sec</var>，则令 <var>s</var> 为 {{toanchor|SecFromTime}}(<var>t</var>)；否则，令 <var>s</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>sec</var>)。
# 如果没指定 <var>ms</var>，则令 <var>milli</var> 为 {{toanchor|msFromTime}}(<var>t</var>)；否则，令 <var>milli</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>ms</var>)。
# 令 <var>date</var> 为 {{toanchor|MakeDate}}({{toanchor|Day}}(<var>t</var>)，{{toanchor|MakeTime}}({{toanchor|HourFromTime}}(<var>t</var>), <var>m</var>, <var>s</var>, <var>milli</var>))。
# 令 <var>v</var> 为 {{toanchor|TimeClip}}(<var>date</var>)。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>v</var>。
# 返回 <var>v</var>。

'''setUTCMinutes''' 方法的 '''length''' 属性是 '''3'''。


==== {{anchor|x15.9.5.34}}Date.prototype.setHours (hour [, min [, sec [, ms ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.34}}

没指定 <var>min</var> 参数时的行为是，仿佛 <var>min</var> 被指定为调用 [[#x15.9.5.20|getMinutes]]() 的结果一样。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#555|Function Def}}

没指定 <var>sec</var> 参数时的行为是，仿佛 <var>sec</var> 被指定为调用 [[#x15.9.5.22|getSeconds]]() 的结果一样。

没指定 <var>ms</var> 参数时的行为是，仿佛 <var>ms</var> 被指定为调用 [[#x15.9.5.24|getMilliseconds]]() 的结果一样。

# 令 <var>t</var> 为 {{toanchor|LocalTime}}( '''this 时间值''' ) 的结果。
# 令 <var>h</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>hour</var>)。
# 如果没指定 <var>min</var>，则令 <var>m</var> 为 {{toanchor|MinFromTime}}(<var>t</var>)；否则，令 <var>m</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>min</var>)。
# 如果没指定 <var>sec</var>，则令 <var>s</var> 为 {{toanchor|SecFromTime}}(<var>t</var>)；否则，令 <var>s</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>sec</var>)。
# 如果没指定 <var>ms</var>，则令 <var>milli</var> 为 {{toanchor|msFromTime}}(<var>t</var>)；否则，令 <var>milli</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>ms</var>)。
# 令 <var>date</var> 为 {{toanchor|MakeDate}}({{toanchor|Day}}(<var>t</var>), {{toanchor|MakeTime}}(<var>h</var>, <var>m</var>, <var>s</var>, <var>milli</var>))。
# 令 <var>u</var> 为 {{toanchor|TimeClip}}({{toanchor|UTC}}(<var>date</var>))。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>u</var>。
# 返回 <var>u</var>。

'''setHours''' 方法的 '''length''' 属性是 '''4'''。


==== {{anchor|x15.9.5.35}}Date.prototype.setUTCHours (hour [, min [, sec [, ms ] ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.35}}

没指定 <var>min</var> 参数时的行为是，仿佛 <var>min</var> 被指定为调用 [[#x15.9.5.21|getUTCMinutes]]() 的结果一样。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#568|Function Def}}

没指定 <var>sec</var> 参数时的行为是，仿佛 <var>sec</var> 被指定为调用 [[#x15.9.5.23|getUTCSeconds]]() 的结果一样。

没指定 <var>ms</var> 参数时的行为是，仿佛 <var>ms</var> 被指定为调用 [[#x15.9.5.25|getUTCMilliseconds]]() 的结果一样。

# 令 <var>t</var> 为 '''this 时间值'''。
# 令 <var>h</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>hour</var>)。
# 如果没指定 <var>min</var>，则令 <var>m</var> 为 {{toanchor|MinFromTime}}(<var>t</var>)；否则，令 <var>m</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>min</var>)。
# 如果没指定 <var>sec</var>，则令 <var>s</var> 为 {{toanchor|SecFromTime}}(<var>t</var>)；否则，令 <var>s</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>sec</var>)。
# 如果没指定 <var>ms</var>，则令 <var>milli</var> 为 {{toanchor|msFromTime}}(<var>t</var>)；否则，令 <var>milli</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>ms</var>)。
# 令 <var>date</var> 为 {{toanchor|MakeDate}}({{toanchor|Day}}(<var>t</var>), {{toanchor|MakeTime}}(<var>h</var>, <var>m</var>, <var>s</var>, <var>milli</var>))。
# 令 <var>v</var> 为 {{toanchor|TimeClip}}(<var>date</var>)。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>v</var>。
# 返回 <var>v</var>。

'''setUTCHours''' 方法的 '''length''' 属性是 '''4'''。


==== {{anchor|x15.9.5.36}}Date.prototype.setDate (date) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.36}}

# 令 <var>t</var> 为 {{toanchor|LocalTime}}( '''this 时间值''' ) 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#581|Function Def}}
# 令 <var>dt</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>date</var>)。
# 令 <var>newDate</var> 为 {{toanchor|MakeDate}}({{toanchor|MakeDay}}({{toanchor|YearFromTime}}(<var>t</var>), {{toanchor|MonthFromTime}}(<var>t</var>), <var>dt</var>), {{toanchor|TimeWithinDay}}(<var>t</var>))。
# 令 <var>u</var> 为 {{toanchor|TimeClip}}({{toanchor|UTC}}(<var>newDate</var>))。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>u</var>。
# 返回 <var>u</var>。


==== {{anchor|x15.9.5.37}}Date.prototype.setUTCDate (date) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.37}}

# 令 <var>t</var> 为 '''this 时间值'''。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#590|Function Def}}
# 令 <var>dt</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>date</var>)。
# 令 <var>newDate</var> 为 {{toanchor|MakeDate}}({{toanchor|MakeDay}}({{toanchor|YearFromTime}}(<var>t</var>), {{toanchor|MonthFromTime}}(<var>t</var>), <var>dt</var>), {{toanchor|TimeWithinDay}}(<var>t</var>))。
# 令 <var>v</var> 为 {{toanchor|TimeClip}}(<var>newDate</var>)。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>v</var>。
# 返回 <var>v</var>。


==== {{anchor|x15.9.5.38}}Date.prototype.setMonth (month [, date ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.38}}

没指定 <var>date</var> 参数时的行为是，仿佛 <var>date</var> 被指定为调用 [[#x15.9.5.14|getDate]]() 的结果一样。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#599|Function Def}}

# 令 <var>t</var> 为 {{toanchor|LocalTime}}( '''this 时间值''' ) 的结果。
# 令 <var>m</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>month</var>)。
# 如果没指定 <var>date</var>，则令 <var>dt</var> 为 {{toanchor|DateFromTime}}(<var>t</var>)；否则，令 <var>dt</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>date</var>)。
# 令 <var>newDate</var> 为 {{toanchor|MakeDate}}({{toanchor|MakeDay}}({{toanchor|YearFromTime}}(<var>t</var>), <var>m</var>, <var>dt</var>), {{toanchor|TimeWithinDay}}(<var>t</var>))。
# 令 <var>u</var> 为 {{toanchor|TimeClip}}({{toanchor|UTC}}(<var>newDate</var>))。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>u</var>。
# 返回 <var>u</var>。

'''setMonth''' 方法的 '''length''' 属性是 '''2'''。


==== {{anchor|x15.9.5.39}}Date.prototype.setUTCMonth (month [, date ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.39}}

没指定 date 参数时的行为是，仿佛 date 被指定为调用 [[#x15.9.5.15|getUTCDate]]() 的结果一样。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#609|Function Def}}

# 令 <var>t</var> 为 '''this 时间值'''。
# 令 <var>m</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>month</var>)。
# 如果没指定 <var>date</var>，则令 <var>dt</var> 为 {{toanchor|DateFromTime}}(t)；否则，令 <var>dt</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>date</var>)。
# 令 <var>newDate</var> 为 {{toanchor|MakeDate}}({{toanchor|MakeDay}}({{toanchor|YearFromTime}}(<var>t</var>), <var>m</var>, <var>dt</var>), {{toanchor|TimeWithinDay}}(<var>t</var>))。
# 令 <var>v</var> 为 {{toanchor|TimeClip}}(<var>newDate</var>)。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>v</var>。
# 返回 <var>v</var>。

'''setUTCMonth''' 方法的 '''length''' 属性是 '''2'''。


==== {{anchor|x15.9.5.40}}Date.prototype.setFullYear (year [, month [, date ] ] ) {{extra note|ES5/annexB#Date.prototype.setYear|<nowiki>还有个Date.prototype.setYear方法，这在ES5的附录中定义。</nowiki>}} ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.40}}

没指定 <var>month</var> 参数时的行为是，仿佛 <var>month</var> 被指定为调用 [[#x15.9.5.12|getMonth]]() 的结果一样。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#619|Function Def}}

没指定 <var>date</var> 参数时的行为是，仿佛 <var>date</var> 被指定为调用 [[#x15.9.5.14|getDate]]() 的结果一样。

# 令 <var>t</var> 为 {{toanchor|LocalTime}}( '''this 时间值''' ) 的结果；但如果 '''this 时间值''' 是 '''NaN'''，则令 <var>t</var> 为 '''+0'''。
# 令 <var>y</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>year</var>)。
# 如果没指定 <var>month</var>，则令 <var>m</var> 为 {{toanchor|MonthFromTime}}(<var>t</var>)；否则，令 <var>m</var> 为 [[ES5/conversion#ToNumber|ToNumber]](month)。
# 如果没指定 <var>date</var>，则令 <var>dt</var> 为 {{toanchor|DateFromTime}}(<var>t</var>)；否则，令 <var>dt</var> 为 [[ES5/conversion#ToNumber|ToNumber]](date)。
# 令 <var>newDate</var> 为 {{toanchor|MakeDate}}({{toanchor|MakeDay}}(<var>y</var>, <var>m</var>, <var>dt</var>), {{toanchor|TimeWithinDay}}(t))。
# 令 <var>u</var> 为 {{toanchor|TimeClip}}({{toanchor|UTC}}(<var>newDate</var>))。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>u</var>。
# 返回 <var>u</var>。

'''setFullYear''' 方法的 '''length''' 属性是 '''3'''。


==== {{anchor|x15.9.5.41}}Date.prototype.setUTCFullYear (year [, month [, date ] ] ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.41}}

没指定 <var>month</var> 参数时的行为是，仿佛 <var>month</var> 被指定为调用 [[#x15.9.5.13|getUTCMonth]]() 的结果一样。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#639|Function Def}}

没指定 <var>date</var> 参数时的行为是，仿佛 <var>date</var> 被指定为调用 [[#x15.9.5.15|getUTCDate]]() 的结果一样。

# 令 <var>t</var> 为 '''this 时间值'''；但如果 '''this 时间值''' 是 '''NaN'''，则令 <var>t</var> 为 '''+0'''。
# 令 <var>y</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>year</var>)。
# 如果没指定 <var>month</var>，则令 <var>m</var> 为 {{toanchor|MonthFromTime}}(<var>t</var>)；否则，令 <var>m</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>month</var>)。
# 如果没指定 <var>date</var>，则令 <var>dt</var> 为 {{toanchor|DateFromTime}}(<var>t</var>)；否则，令 <var>dt</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>date</var>)。
# 令 <var>newDate</var> 为 {{toanchor|MakeDate}}({{toanchor|MakeDay}}(<var>y</var>, <var>m</var>, <var>dt</var>), {{toanchor|TimeWithinDay}}(<var>t</var>))。
# 令 <var>v</var> 为 {{toanchor|TimeClip}}(<var>newDate</var>)。
# 设定 '''this Date 对象''' 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性为 <var>v</var>。
# 返回 <var>v</var>。

'''setUTCFullYear''' 方法的 '''length''' 属性是 '''3'''。


==== {{anchor|x15.9.5.42}}Date.prototype.toUTCString ( ) {{extra note|ES5/annexB#Date.prototype.toGMTString|<nowiki>还有个Date.prototype.toGMTString方法，这在ES5的附录中定义。</nowiki>}} ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.42}}

此函数返回一个字符串值。字符串中内容是依赖于实现的，但目的是用一种方便，人类可读的形式表示 UTC 时间。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#659|Function Def}}

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


==== {{anchor|x15.9.5.43}}Date.prototype.toISOString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.43}}

此函数返回一个代表 '''this Date 对象'''表示的时间实例 的字符串。字符串的格式是 [[#x15.9.1.15|15.9.1.15]] 定义的日期时间字符串格式。字符串中包含所有的字段。字符串表示的时区总是 UTC，用后缀 '''Z''' 标记。如果 '''this''' 对象的时间值不是有限的数字值，抛出一个 '''RangeError''' 异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#719|Function Def}}


==== {{anchor|x15.9.5.44}}Date.prototype.toJSON ( key ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.5.44}}

此函数为 '''JSON.stringify''' ([[#x15.12.3|15.12.3]]) 提供 '''Date''' 对象的一个字符串表示。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/date.js?r{{=}}13187#744|Function Def}}

当用参数 <var>key</var> 调用 '''toJSON''' 方法，采用以下步骤：

# 令 <var>O</var> 为 以 '''this''' 值为参数调用 [[ES5/conversion#ToObject|ToObject]] 的结果。
# 令 <var>tv</var> 为 [[ES5/conversion#ToPrimitive|ToPrimitive]](<var>O</var>, '''暗示 Number''')。
# 如果 <var>tv</var> 是一个数字值且不是有限的，返回 '''null'''。
# 令 <var>toISO</var> 为以 '''"toISOString"''' 为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 如果 [[ES5/conversion#IsCallable|IsCallable]](<var>toISO</var>) 是 '''false'''，抛出一个 '''TypeError''' 异常。
# <var>O</var> 作为以 '''this''' 值并用空参数列表调用 <var>toISO</var> 的 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 内部方法，返回结果。

{{note| 参数是被忽略的。{{question||为什么？}}}}

{{note| '''toJSON''' 函数是故意设计成通用的；它不需要其 '''this''' 值必须是一个 '''Date''' 对象。因此，它可以作为方法转移到其他类型的对象上。但转移到的对象必须有 '''toISOString''' 方法。对象可自由使用参数 '''''key''''' 来过滤字符串化的方式。}}


=== {{anchor|x15.9.6}}Date 实例的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.9.6}}

'''Date''' 实例从 '''Date''' 原型对象继承属性，'''Date''' 实例的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性值是 '''"Date"'''。'''Date''' 实例还有一个 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性。

[[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性是代表 '''this Date 对象''' 的时间值。


== {{anchor|x15.10}}RegExp 对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.10}}

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

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


=== {{anchor|x15.10.1}}模式（Patterns） ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.1}}

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

语法：

  ''<b id="Pattern">Pattern</b>'' :: {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L4981|}}
    ''{{toanchor|Disjunction}}''

  ''<b id="Disjunction">Disjunction</b>'' :: {{V8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5003|}}
    ''{{toanchor|Alternative}}''
    ''{{toanchor|Alternative}}'' '''|''' ''{{toanchor|Disjunction}}'' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5058|}}

  ''<b id="Alternative">Alternative</b>'' :: 
    &#91;[[ES5/notation#empty|empty]]]
    ''{{toanchor|Alternative}}'' ''{{toanchor|Term}}''

  ''<b id="Term">Term</b>'' ::
    ''{{toanchor|Assertion}}''
    ''{{toanchor|Atom}}''
    ''{{toanchor|Atom}}'' ''{{toanchor|Quantifier}}''

  ''<b id="Assertion">Assertion</b>'' ::
    '''^''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5067|}}
    '''$''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5079|}}
    '''\ b''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5142|}}
    '''\ B''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5147|}}
    '''(''' '''?''' '''=''' ''{{toanchor|Disjunction}}'' ''')''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5105|}}
    '''(''' '''?''' '''!''' ''{{toanchor|Disjunction}}'' ''')''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5108|}}

  ''<b id="Quantifier">Quantifier</b>'' ::
    ''{{toanchor|QuantifierPrefix}}''
    ''{{toanchor|QuantifierPrefix}}'' '''?''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5315|}}

  ''<b id="QuantifierPrefix">QuantifierPrefix</b>'' ::
    '''*''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5286|}}
    '''+''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5291|}}
    '''?''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5296}}
    '''{''' ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' '''}''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5449|}}
    '''{''' ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' ''',''' '''}''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5454|}}
    '''{''' ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' ''',''' ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' '''}''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5457|}}

  ''<b id="Atom">Atom</b>'' ::
    ''{{toanchor|PatternCharacter}}''
    '''.''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5087|}}
    '''\''' ''{{toanchor|AtomEscape}}''
    ''{{toanchor|CharacterClass}}'' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5131|}}
    '''(''' ''{{toanchor|Disjunction}}'' ''')''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5116|}}
    '''(''' '''?''' ''':''' ''{{toanchor|Disjunction}}'' ''')''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5102|}}

  ''<b id="PatternCharacter">PatternCharacter</b>'' ::
    ''[[ES5#SourceCharacter|SourceCharacter]]'' '''but not one of'''
    '''^ $ \ . * + ? ( ) [ ] { } |'''

  ''<b id="AtomEscape">AtomEscape</b>'' ::
    ''{{toanchor|DecimalEscape}}'' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5167|}}
    ''{{toanchor|CharacterEscap}}''
    ''{{toanchor|CharacterClassEscape}}'' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5157|}}

  ''<b id="CharacterEscape">CharacterEscape</b>'' ::
    ''{{toanchor|ControlEscape}}''
    '''c''' ''{{toanchor|ControlLetter}}'' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5220|}}
    ''[[ES5/lexical#HexEscapeSequence|HexEscapeSequence]]'' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5248|}}
    ''[[ES5/lexical#UnicodeEscapeSequence|UnicodeEscapeSequence]]'' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5238|}}
    ''{{toanchor|IdentityEscape}}'' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5258|}}

  ''<b id="ControlEscape">ControlEscape</b>'' :: '''one of'''
    '''f n r t v''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5198|原子中的控制字符转义}} {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5534|ControlEscape中的控制字符转义}}

  ''<b id="ControlLetter">ControlLetter</b>'' :: '''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'''

  ''<b id="IdentityEscape">IdentityEscape</b>'' ::
    ''[[ES5#SourceCharacter|SourceCharacter]]'' '''but not''' ''[[ES5/lexical#IdentifierPart|IdentifierPart]]''
    <ZWJ>
    <ZWNJ>

  ''<b id="DecimalEscape">DecimalEscape</b>'' ::
    ''[[ES5/lexical#DecimalIntegerLiteral|DecimalIntegerLiteral]]'' &#91;[[ES5/notation#lookahead-not-in|lookahead ∉]] ''[[#ES5/lexical#DecimalDigit|DecimalDigit]]'']

  ''<b id="CharacterClassEscape">CharacterClassEscape</b>'' :: '''one of'''
    '''d D s S w W''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5157|}}

  ''<b id="CharacterClass">CharacterClass</b>'' :: {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5647|}}
    '''[''' &#91;[[ES5/notation#lookahead-not-in|lookahead ∉]] {'''^'''}] ''{{toanchor|ClassRanges}}'' ''']'''
    '''[''' '''^''' ''{{toanchor|ClassRanges}}'' ''']''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5654|}}

  ''<b id="ClassRanges">ClassRanges</b>'' ::
    &#91;[[ES5/notation#empty|empty]]]
    ''{{toanchor|NonemptyClassRanges}}''

  ''<b id="NonemptyClassRanges">NonemptyClassRanges</b>'' ::
    ''{{toanchor|ClassAtom}}''
    ''{{toanchor|ClassAtom}}'' ''{{toanchor|NonemptyClassRangesNoDash}}''
    ''{{toanchor|ClassAtom}}'' - ''{{toanchor|ClassAtom}}'' ''{{toanchor|ClassRanges}}'' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5663|}}

  ''<b id="NonemptyClassRangesNoDash">NonemptyClassRangesNoDash</b>'' ::
    ''{{toanchor|ClassAtom}}''
    ''{{toanchor|ClassAtomNoDash}}'' ''{{toanchor|NonemptyClassRangesNoDash}}''
    ''{{toanchor|ClassAtomNoDash}}'' - ''{{toanchor|ClassAtom}}'' ''{{toanchor|ClassRanges}}''

  ''<b id="ClassAtom">ClassAtom</b>'' ::
    '''-'''
    ''{{toanchor|ClassAtomNoDash}}''

  ''<b id="ClassAtomNoDash">ClassAtomNoDash</b>'' :: {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5607|}}
    ''[[ES5#SourceCharacter|SourceCharacter]]'' '''but not''' '''\'''、''']'''、'''- '''
    '''\''' ''{{toanchor|ClassEscape}}''

  ''<b id="ClassEscape">ClassEscape</b>'' ::
    ''{{toanchor|DecimalEscape}}''
    '''b''' {{v8|https://github.com/v8/v8/blob/3.22/src/parser.cc#L5531|}}
    ''{{toanchor|CharacterEscap}}''
    ''{{toanchor|CharacterClassEscape}}''


=== {{anchor|x15.10.2}}模式语义（Pattern Semantics） ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2}}

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


==== {{anchor|MatchResult}}{{anchor|x15.10.2.1}}表示法（Notation） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.1}}

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

* {{toanchor|Input}}，是正则表达式模式要匹配的字符串。符号 '''Input['''<var>n</var>''']''' 表示 '''Input''' 的第 <var>n</var> 个字符，这里的 <var>n</var> 可以是 '''0'''（包括）和 '''InputLength'''（不包括）之间的。
* {{toanchor|InputLength}}，是 {{toanchor|Input}} 字符串里的字符数目。
* <b id="NcapturingParens">NcapturingParens</b>，是在模式中左捕获括号的总数（即，''{{toanchor|Atom}}'' :: '''(''' ''{{toanchor|Disjunction}}'' ''')''' 产生式被展开的总次数）。一个左捕获括号是匹配产生式 ''{{toanchor|Atom}}'' :: '''(''' ''{{toanchor|Disjunction}}'' ''')''' 中的 终结符 '''(''' 的任意 '''(''' 模式字符。
* <b id="IgnoreCase">IgnoreCase</b>，是 '''RegExp''' 对象的 '''ignoreCase''' 属性的设定值。
* <b id="Multiline">Multiline</b>，是 '''RegExp''' 对象的 '''multiline''' 属性的设定值。

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

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


===={{anchor|x15.10.2.2}}模式（{{toanchor|Pattern}}）====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.2}}

产生式 ''{{toanchor|Pattern}}'' :: ''{{toanchor|Disjunction}}'' 按照以下方式解释执行 :

# 解释执行 ''{{toanchor|Disjunction}}'' ，获得一个 {{toanchor|Matcher}} <var>m</var>。
# 返回一个需要两个参数的内部闭包，一个字符串 <var>str</var> 和一个整数 <var>index</var>，执行方式如下：
## 令 {{toanchor|Input}} 为给定的字符串 <var>str</var>。[[#x15.10.2|15.10.2]] 中的算法都将用到此变量。
## 令 {{toanchor|InputLength}} 为 {{toanchor|Input}} 的长度。[[#x15.10.2|15.10.2]] 中的算法都将用到此变量。
## 令 <var>c</var> 为 一个 {{toanchor|Continuation}}，它始终对它的任何 {{toanchor|State}} 参数都返回成功匹配的 {{toanchor|MatchResult}}。
## 令 <var>cap</var> 为一个有 {{toanchor|NcapturingParens}} 个 '''undefined''' 值的内部数组，索引是从 '''1''' 到 {{toanchor|NcapturingParens}}。
## 令 <var>x</var> 为 {{toanchor|State}}(<var>index</var>, <var>cap</var>)。
## 调用 <var>m</var>(<var>x</var>, <var>c</var>)，并返回结果。

{{note| 一个模式解释执行（“编译”）为一个内部程序值。'''RegExp.prototype.exec''' 可将这个内部程序应用于一个字符串和字符串的一个偏移位，来确定从这个偏移位开始 , 模式是否能够匹配，如果能匹配，将返回捕获括号的值。15.10.2 中的算法被设计为只在编译一个模式时可抛出一个 '''SyntaxError''' 异常；反过来说，一旦模式编译成功，应用编译生成的内部程序在字符串中寻找匹配结果时不可抛出异常（除非是宿主定义的可在任何时候出现的异常，如内存不足）。}}


===={{anchor|x15.10.2.3}}析取（{{toanchor|Disjunction}}）====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.3}}

产生式 ''{{toanchor|Disjunction}}'' :: ''{{toanchor|Alternative}}'' 的解释执行，是解释执行 ''{{toanchor|Alternative}}'' 来获得 {{toanchor|Matcher}} 并返回这个 {{toanchor|Matcher}}。

产生式 ''{{toanchor|Disjunction}}'' :: ''{{toanchor|Alternative}}'' '''|''' ''{{toanchor|Disjunction}}'' 按照以下方式解释执行：

# 解释执行 ''{{toanchor|Alternative}}'' 来获得一个 {{toanchor|Matcher}} <var>m1</var>。
# 解释执行 ''{{toanchor|Disjunction}}'' 来获得一个 {{toanchor|Matcher}} <var>m2</var>。
# 返回一个需要两个参数的内部闭包 {{toanchor|Matcher}}，参数分别是一个 {{toanchor|State}} <var>x</var> 和一个 {{toanchor|Continuation}} <var>c</var>，此内部闭包的执行方式如下：
## 调用 <var>m1</var>(<var>x</var>, <var>c</var>) 并令 <var>r</var> 为其结果。
## 如果 <var>r</var> 不是 '''failure'''，返回 <var>r</var>。
## 调用 <var>m2</var>(<var>x</var>, <var>c</var>) 并返回其结果。


{{note | 正则表达式运算符 '''<nowiki>|</nowiki>''' 用来分隔两个选择项。模式首先尝试去匹配左侧的 '''''Alternative'''''（紧跟着是正则表达式的后续匹配结果）；如果失败，尝试匹配右侧的 '''''Disjunction'''''（紧跟着是正则表达式的后续匹配结果）。如果左侧的 '''''Alternative'''''，右侧的 '''''Disjunction'''''，还有后续匹配结果，全都有可选的匹配位置，则后续匹配结果的所有可选位置是在左侧的 '''''Alternative''''' 移动到下一个可选位置之前确定的。如果左侧 '''''Alternative''''' 的可选位置被用尽了，右侧 '''''Disjunction''''' 试图替代左侧 '''''Alternative'''''。一个模式中任何被 '''<nowiki>|</nowiki>''' 跳过的捕获括号参数 '''undefined''' 值还代替字符串。因此，如：

  <nowiki>/a|ab/.exec("abc")</nowiki>

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

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

返回的数组是 

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

而不是 

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


==== {{anchor|x15.10.2.4}}选择项（{{toanchor|Alternative}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.4}}

产生式 ''{{toanchor|Alternative}}'' :: &#91;[[ES5/notation#empty|empty]]] 解释执行返回一个 {{toanchor|Matcher}}，它需要两个参数，一个 {{toanchor|State}} <var>x</var> 和 一个 {{toanchor|Continuation}} <var>c</var>，并返回调用 <var>c</var>(<var>x</var>) 的结果。

产生式 ''{{toanchor|Alternative}}'' :: ''{{toanchor|Alternative}}'' ''{{toanchor|Term}}'' 按照如下方式解释执行：
# 解释执行 ''{{toanchor|Alternative}}'' 来获得一个 {{toanchor|Matcher}} <var>m1</var>。
# 解释执行 ''{{toanchor|Term}}'' 来获得一个 {{toanchor|Matcher}} <var>m2</var>。
# 返回一个内部闭包 {{toanchor|Matcher}}，它需要两个参数，一个 {{toanchor|State}} <var>x</var> 和一个 {{toanchor|Continuation}} <var>c</var>，执行方式如下 :
## 创建一个 {{toanchor|Continuation}} <var>d</var>，它需要一个 {{toanchor|State}} 参数 <var>y</var>，返回调用 <var>m2</var>(<var>y</var>，<var>c</var>) 的结果。
## 调用 <var>m1</var>(<var>x</var>, <var>d</var>) 并返回结果。

{{note| 连续的 '''''Term''''' 试着同时去匹配连续输入字符串的连续部分。如果左侧的 '''''Alternative''''' ，右侧的 '''''Term''''' ，还有后续匹配结果，全都有可选的匹配位置，则后续匹配结果的所有可选位置是在右侧的 '''''Term''''' 移动到下一个可选位置之前确定的，并且则右侧的 '''''Term''''' 的所有可选位置是在左侧的 '''''Alternative''''' 移动到下一个可选位置之前确定的。}}


==== {{anchor|x15.10.2.5}}匹配项（{{toanchor|Term}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.5}}

产生式 ''{{toanchor|Term}}'' :: ''{{toanchor|Assertion}}'' 解释执行，返回一个需要两个参数 {{toanchor|State}} <var>x</var> 和 {{toanchor|Continuation}} <var>c</var> 的内部闭包 {{toanchor|Matcher}}，它的执行方式如下：

# 解释执行 ''{{toanchor|Assertion}}'' 来获得一个 {{toanchor|AssertionTester}} <var>t</var>。
# 调用 <var>t</var>(<var>x</var>) 并令 <var>r</var> 为调用结果布尔值。
# 如果 <var>r</var> 是 '''false'''，返回 '''failure'''。
# 调用 <var>c</var>(<var>x</var>) 并返回结果。

产生式 ''{{toanchor|Term}}'' :: ''{{toanchor|Atom}}'' 的解释执行方式是，解释执行 ''{{toanchor|Atom}}'' 来获得一个 {{toanchor|Matcher}} 并返回这个 {{toanchor|Matcher}}。

产生式 ''{{toanchor|Term}}'' :: ''{{toanchor|Atom}}'' ''{{toanchor|Quantifier}}'' 的解释执行方式如下 :

# 解释执行 ''{{toanchor|Atom}}'' 来获得一个 {{toanchor|Matcher}} <var>m</var>。
# 解释执行 ''{{toanchor|Quantifier}}'' 来获得三个结果值：一个整数 <var>min</var>，一个整数（或 '''∞'''）<var>max</var>，和一个布尔值 <var>greedy</var>。
# 如果 <var>max</var> 是有限的 且小于 <var>min</var>，则抛出一个 '''SyntaxError''' 异常。
# 令 <var>parenIndex</var> 为整个正则表达式中在此产生式 ''{{toanchor|Term}}'' 展开形式左侧出现的左匹配括号的数目。这是此产生式 ''{{toanchor|Term}}'' 前面展开的 ''{{toanchor|Atom}}'' :: '''(''' ''{{toanchor|Disjunction}}'' ''')''' 产生式总数与此 ''{{toanchor|Term}}'' 里面的 ''{{toanchor|Atom}}'' :: '''(''' ''{{toanchor|Disjunction}}'' ''')''' 产生式总数之和。
# 令 <var>parenCount</var> 为在展开的 ''{{toanchor|Atom}}'' 产生式里的左捕获括号数目。这是 ''{{toanchor|Atom}}'' 产生式里面 ''{{toanchor|Atom}}'' :: '''(''' ''{{toanchor|Disjunction}}'' ''')''' 产生式的总数。
# 返回一个需要两个参数 {{toanchor|State}} <var>x</var> 和 {{toanchor|Continuation}} <var>c</var> 的内部闭包 {{toanchor|Matcher}}，执行方式如下：
## 调用 {{toanchor|RepeatMatcher}}(<var>m</var>, <var>min</var>, <var>max</var>, <var>greedy</var>, <var>x</var>, <var>c</var>, <var>parenIndex</var>, <var>parenCount</var>)，并返回结果。

{{anchor|RepeatMatcher}}抽象操作 '''RepeatMatcher''' 需要八个参数，一个 {{toanchor|Matcher}} <var>m</var>，一个整数 <var>min</var>，一个整数（或 '''∞'''）<var>max</var>，一个布尔值 <var>greedy</var>，一个 {{toanchor|State}} <var>x</var>，一个 {{toanchor|Continuation}} <var>c</var>，一个整数 <var>parenIndex</var>，一个整数 <var>parenCount</var>，执行方式如下：

# 如果 <var>max</var> 是零，则调用 <var>c</var>(<var>x</var>)，并返回结果。
# 创建需要一个 {{toanchor|State}} 参数 <var>y</var> 的内部 {{toanchor|Continuation}} 闭包 <var>d</var>，执行方式如下：
## 如果 <var>min</var> 是零 且 <var>y</var> 的 <var>endIndex</var> 等于 <var>x</var> 的 <var>endIndex</var>，则返回 '''failure'''。
## 如果 <var>min</var> 是零，则令 <var>min2</var> 为零；否则令 <var>min2</var> 为 <var>min</var>-'''1'''。
## 如果 <var>max</var> 是 '''∞'''，则令 <var>max2</var> 为 '''∞'''；否则令 <var>max2</var> 为 <var>max</var>-'''1'''。
## 调用 '''RepeatMatcher'''(<var>m</var>, <var>min2</var>, <var>max2</var>, <var>greedy</var>, <var>y</var>, <var>c</var>, <var>parenIndex</var>, <var>parenCount</var>)，并返回结果。
# 令 <var>cap</var> 为 <var>x</var> 的捕获内部数组的一个拷贝。
# 对所有满足条件 <var>parenIndex</var> < <var>k</var> 且 <var>k</var> ≤ <var>parenIndex</var>+<var>parenCount</var> 的整数 <var>k</var>，设定 <var>cap</var>[<var>k</var>] 为 <var>undefined</var>。
# 令 <var>e</var> 为 <var>x</var> 的 <var>endIndex</var>。
# 令 <var>xr</var> 为 {{toanchor|State}} 值 (<var>e</var>, <var>cap</var>)。
# 如果 <var>min</var> 不是零，则调用 <var>m</var>(<var>xr</var>, <var>d</var>)，并返回结果。
# 如果 <var>greedy</var> 是 <var>false</var>，则 
## 令 <var>z</var> 为调用 <var>c</var>(<var>x</var>) 的结果。
## 如果 <var>z</var> 不是 '''failure'''，返回 <var>z</var>。
## 调用 <var>m</var>(<var>xr</var>, <var>d</var>)，并返回结果。
# 令 <var>z</var> 为调用 <var>m</var>(<var>xr</var>, <var>d</var>) 的结果。
# 如果 <var>z</var> 不是 '''failure'''，返回 <var>z</var>。
# 调用 <var>c</var>(<var>x</var>)，并返回结果。


==== {{anchor|x15.10.2.6}}断言（{{toanchor|Assertion}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.6}}

产生式 ''{{toanchor|Assertion}}'' :: '''^''' 解释执行返回一个 {{toanchor|AssertionTester}}，它需要1个参数 {{toanchor|State}} <var>x</var>，并按如下算法执行：

# 使 <var>e</var> 为 <var>x</var>的 '''endIndex'''。
# 若 <var>e</var> = '''0'''，返回 '''true'''。
# 若 '''Multiline''' 为 '''false'''，返回 '''false'''。
# 若 {{toanchor|Input}}[<var>e</var> - '''1'''] 的字符为 ''[[ES5/lexical#LineTerminator|LineTerminator]]''，返回 '''true'''。
# 返回 '''false'''。

产生式 ''{{toanchor|Assertion}}'' :: '''$''' 解释执行返回一个 {{toanchor|AssertionTester}}，它需要1个参数 {{toanchor|State}} <var>x</var>，并按如下算法执行：

# 使 <var>e</var> 为 <var>x</var> 的 '''endIndex'''
# 若 <var>e</var> = {{toanchor|InputLength}}，返回 '''true'''。
# 若 '''Multiline''' 为 '''false'''，返回 '''false'''。
# 若 {{toanchor|Input}}[<var>e</var>] 的字符为 ''[[ES5/lexical#LineTerminator|LineTerminator]]''，返回 '''true'''。
# 返回 '''false'''。

产生式 ''{{toanchor|Assertion}}'' :: '''\ b''' 解释执行返回一个 {{toanchor|AssertionTester}}，它需要1个参数 {{toanchor|State}} <var>x</var>，并按如下算法执行：

# 使 <var>e</var> 为 <var>x</var> 的 '''endIndex'''。
# 调用 {{toanchor|IsWordChar}}(<var>e</var> - '''1''')，返回 '''Boolean''' 值赋给 <var>a</var>。
# 调用 {{toanchor|IsWordChar}}(<var>e</var>)，返回 '''Boolean''' 值赋给 <var>b</var>。
# 若 <var>a</var> 为 '''true'''，<var>b</var> 为 '''false'''，返回 '''true'''。
# 若 <var>a</var> 为 '''false'''，<var>b</var> 为 '''true'''，返回 '''true'''。
# 返回 '''false'''。

产生式 ''{{toanchor|Assertion}}'' :: '''\ B''' 解释执行返回一个 {{toanchor|AssertionTester}}，它需要1个参数 {{toanchor|State}} <var>x</var>，并按如下算法执行：

# 使 <var>e</var> 为 <var>x</var> 的 '''endIndex'''。
# 调用 {{toanchor|IsWordChar}}(<var>e</var> - '''1''')，返回 '''Boolean''' 值赋给 <var>a</var>。
# 调用 {{toanchor|IsWordChar}}(<var>e</var>)，返回 '''Boolean''' 值赋给 <var>b</var>。
# 若 <var>a</var> 为 '''true'''，<var>b</var> 为 '''false'''，返回 '''false'''。
# 若 <var>a</var> 为 '''false'''，<var>b</var> 为 '''true'''，返回 '''false'''。
# 返回 '''true'''。

产生式 ''{{toanchor|Assertion}}'' :: '''(? =''' ''{{toanchor|Disjunction}}'' ''')''' 按如下算法执行：

# 执行 ''{{toanchor|Disjunction}}''，得到 {{toanchor|Matcher}} <var>m</var>。
# 返回一个需要两个参数的内部闭包 {{toanchor|Matcher}}，参数分别是一个 {{toanchor|State}} <var>x</var> 和一个 {{toanchor|Continuation}} <var>c</var>，此内部闭包的执行方式如下：
## 使 <var>d</var> 为一个{{toanchor|Continuation}}，它始终对它的任何 {{toanchor|State}} 参数都返回成功匹配的 {{toanchor|MatchResult}}。
## 调用 <var>m</var>(<var>x</var>, <var>d</var>)，令 <var>r</var> 为其结果。
## 若 <var>r</var> 为 '''failure'''，返回 '''failure'''。
## 使 <var>y</var> 为 <var>r</var> 的 {{toanchor|State}}。
## 使 <var>cap</var> 为 <var>r</var> 的'''captures'''。
## 使 <var>xe</var> 为 <var>r</var> 的'''endIndex'''。
## 使 <var>z</var> 为 {{toanchor|State}} (<var>xe</var>, <var>cap</var>)。
## 调用 <var>c</var>(<var>z</var>)，返回结果。

产生式 ''{{toanchor|Assertion}}'' :: '''(? !''' ''{{toanchor|Disjunction}}'' ''')''' 按如下算法执行：
# 执行 ''{{toanchor|Disjunction}}''，得到 {{toanchor|Matcher}} <var>m</var>。
# 返回一个需要两个参数的内部闭包 {{toanchor|Matcher}}，参数分别是一个 {{toanchor|State}} <var>x</var> 和一个 {{toanchor|Continuation}} <var>c</var>，此内部闭包的执行方式如下：
## 使 <var>d</var> 为一个 {{toanchor|Continuation}}，它始终对它的任何 {{toanchor|State}} 参数都返回成功匹配的 {{toanchor|MatchResult}}。
## 调用 <var>m</var>(<var>x</var>, <var>d</var>)，令 <var>r</var> 为其结果。
## 若r为'''failure'''，返回 '''failure'''。
## 调用 <var>c</var>(<var>z</var>)，返回结果。

{{anchor|IsWordChar}}抽象操作 '''IsWordChar'''，拥有一个整数类型的参数 <var>e</var>，按如下方式执行：{{extra note||它不识别汉字，仅识别\w字符。}}
# 若 <var>e</var> == '''-1''' 或 <var>e</var> == {{toanchor|InputLength}}，返回 '''false'''。
# 令 <var>c</var> 为 {{toanchor|Input}}[<var>e</var>]。
# 若 <var>c</var> 为 以下63个字符，返回 '''true'''<br/>'''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'''<br/>'''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'''<br/>'''0 1 2 3 4 5 6 7 8 9 _'''。
# 返回 '''false'''。


==== {{anchor|x15.10.2.7}}量词（{{toanchor|Quantifier}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.7}}

产生式 ''{{toanchor|Quantifier}}'' :: ''{{toanchor|QuantifierPrefix}}'' 按如下方式执行：

# 执行 ''{{toanchor|QuantifierPrefix}}'' 得到 '''2''' 个数 <var>min</var> 和 <var>max</var>（或 '''∞'''）。
# 返回 <var>min</var>、<var>max</var>、'''true'''。

产生式 ''{{toanchor|Quantifier}}'' :: ''{{toanchor|QuantifierPrefix}}'' '''?''' 按如下方式执行：

# 执行 ''{{toanchor|QuantifierPrefix}}'' 得到 '''2''' 个数 <var>min</var> 和 <var>max</var>（或 '''∞'''）。
# 返回 <var>min</var>、<var>max</var>、'''false'''。

产生式 ''{{toanchor|Quantifier}}'' :: '''*''' 返回 '''0''' 和 '''∞'''

产生式 ''{{toanchor|Quantifier}}'' :: '''+''' 返回 '''1''' 和 '''∞'''

产生式 ''{{toanchor|Quantifier}}'' :: '''?''' 返回 '''0''' 和 '''1'''

产生式 ''{{toanchor|Quantifier}}'' :: '''{''' ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' '''}''' 按如下方式执行：
# 令 <var>i</var> 为 ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' 的数学值。
# 返回 <var>i</var>、<var>i</var>。

产生式 ''{{toanchor|Quantifier}}'' :: '''{''' ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' ''',''' '''}''' 按如下方式执行：
# 令 <var>i</var> 为 ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' 的数学值。
# 返回 <var>i</var>、'''∞'''。

产生式 ''{{toanchor|Quantifier}}'' :: '''{''' ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' ''',''' ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' '''}''' 按如下方式执行：
# 令 <var>i</var> 为 ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' 的数学值。
# 令 <var>j</var> 为 ''[[#ES5/lexical#DecimalDigits|DecimalDigits]]'' 的数学值。
# 返回 <var>i</var>、<var>j</var>。


===={{anchor|x15.10.2.8}}原子（{{toanchor|Atom}}）====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.8}}

产生式 ''{{toanchor|Atom}}'' :: ''{{toanchor|PatternCharacter}}'' 执行方式如下：

# 令 <var>ch</var> 为 ''{{toanchor|PatternCharacter}}'' 表示的字符。
# 令 <var>A</var> 为单元素 {{toanchor|CharSet}}，包含 <var>ch</var>。
# 调用 {{toanchor|CharacterSetMatcher}}(<var>A</var>, '''false''')，返回 {{toanchor|Matcher}}。

产生式 {{toanchor|Atom}} :: '''.''' 执行方式如下 

# 令 <var>A</var> 为 除去 ''[[ES5/lexical#LineTerminator|LineTerminator]]'' 外的所有字符。
# 调用 {{toanchor|CharacterSetMatcher}}(<var>A</var>, '''false''')，返回 {{toanchor|Matcher}}。
 
产生式 ''{{toanchor|Atom}}'' :: '''\''' ''{{toanchor|AtomEscape}}'' 通过执行 ''{{toanchor|AtomEscape}}'' 返回 {{toanchor|Matcher}}。

产生式 ''{{toanchor|Atom}}'' :: ''{{toanchor|CharacterClass}}'' 执行方式如下：

# 执行 ''{{toanchor|CharacterClass}}'' 得到 {{toanchor|CharSet}} <var>A</var> 和 '''Boolean''' <var>invert</var>。
# 调用 {{toanchor|CharacterSetMatcher}}(<var>A</var>, '''false''')，返回 {{toanchor|Matcher}}。

产生式 ''{{toanchor|Atom}}'' :: '''(''' ''{{toanchor|Disjunction}}'' ''')''' 执行方式如下：

# 执行 ''{{toanchor|Disjunction}}'' 得到 {{toanchor|Matcher}}。
# 令 '''parenIndex''' 为 在整个正则表达式中从产生式展开初始化左括号时，当前展开左捕获括号的索引。'''parenIndex''' 为在产生式的 ''{{toanchor|Atom}}'' 被展开之前，''{{toanchor|Atom}}'' :: '''(''' ''{{toanchor|Disjunction}}'' ''')''' 产生式被展开的次数，加上 ''{{toanchor|Atom}}'' :: '''(''' ''{{toanchor|Disjunction}}'' ''')''' 闭合 这个 ''{{toanchor|Atom}}'' 的次数。
# 返回一个内部闭包 {{toanchor|Matcher}}，拥有2个参数：一个 {{toanchor|State}} <var>x</var> 和 {{toanchor|Continuation}} <var>c</var>，执行方式如下：
## 创建内容闭包 {{toanchor|Continuation}} <var>d</var>，参数为{{toanchor|State}} <var>y</var>，并按如下方式执行：
### 令 <var>cap</var> 为 <var>y</var> 的 '''capture''' 数组的一个拷贝。
### 令 <var>xe</var> 为 x 的 '''endIndex'''。
### 令 <var>ye</var> 为 <var>y</var> 的 '''endIndex'''。
### 令 <var>s</var> 为 {{toanchor|Input}} 从索引 <var>xe</var>（包括）至 <var>ye</var>（不包括）范围的新创建的字符串。
### 令 <var>s</var> 为 <var>cap</var>[<var>parenIndex</var> + '''1''']。
### 令 <var>z</var> 为 {{toanchor|State}} (<var>ye</var>, <var>cap</var>)。
### 调用 <var>c</var>(<var>z</var>)，返回其结果。
## 执行 <var>m</var>(<var>x</var>, <var>d</var>)，返回其结果。

产生式  ''{{toanchor|Atom}}'' :: '''( ? :''''' {{toanchor|Disjunction}}'' ''')''' 通过执行 ''{{toanchor|Disjunction}}'' 得到并返回一个 {{toanchor|Matcher}}。

{{anchor|CharacterSetMatcher}}抽象操作 '''CharacterSetMatcher'''，拥有2个参数：一个 {{toanchor|CharSet}} <var>A</var> 和 '''Boolean''' <var>invert</var> 标志，按如下方式执行：

# 返回一个内部闭包 {{toanchor|Matcher}}，拥有2个参数：一个 {{toanchor|State}} <var>x</var> 和 {{toanchor|Continuation}} <var>c</var>，执行方式如下：
## 令 <var>e</var> 为 <var>x</var> 的 '''endIndex'''。
## 若 <var>e</var> == {{toanchor|InputLength}}，返回 '''failure'''。
## 令 <var>ch</var> 为字符{{toanchor|Input}}[<var>e</var>]。
## 令 <var>cc</var> 为 {{toanchor|Canonicalize}}(<var>ch</var>) 的结果。
## 若 <var>invert</var> 为'''false'''，如果 <var>A</var> 中不存在 <var>a</var> 使得 {{toanchor|Canonicalize}}(<var>a</var>) == <var>cc</var>，返回'''failure'''。
## 若 <var>invert</var> 为'''true'''，如果 <var>A</var> 中存在 <var>a</var> 使得 {{toanchor|Canonicalize}}(<var>a</var>) == <var>cc</var>，返回'''failure'''。
## 令 <var>cap</var> 为 <var>x</var> 的内部 '''captures''' 数组。
## 令 <var>y</var> 为 {{toanchor|State}} (<var>e</var> + '''1''', <var>cap</var>)。
## 调用 <var>c</var>(<var>y</var>)，返回结果。

{{anchor|Canonicalize}}抽象操作 '''Canonicalize'''，拥有一个字符参数 <var>ch</var>，按如下方式执行：

# 若 {{toanchor|IgnoreCase}} 为 '''false'''，返回 <var>ch</var>。
# 令 <var>u</var> 为 <var>ch</var> 转换为大写后的结果，仿佛通过调用标准内置方法 [[ES5/builtins#x15.5.4.18|String.prototype.toUpperCase]]。
# 若 <var>u</var> 不含单个字符，返回 <var>ch</var>。
# 令 <var>cu</var> 为 <var>u</var> 的字符。
# 若 <var>ch</var> 的单位代码值 >= '''128''' 且 <var>cu</var> 的单位代码值 <= '''128'''，返回<var>ch</var>。
# 返回 <var>cu</var>。

{{note| '''( ''Disjunction'' )''' 的括号 用来组合 '''''Disjunction''''' 模式，并保存匹配结果。该结果可以通过后向引用（一个非零数，前置 '''\''' ），在一个替换字符串中的引用，或者作为正则表达式内部匹配过程的部分结果。使用'''(?: ''Disjunction'' )'''来避免括号的捕获行为。}}

例如，
  <nowiki>/(?=(a+))/.exec("baaabac")</nowiki>
会匹配第一个b后的空白字符串，得到：
  <nowiki>["", "aaa"]</nowiki>
为了说明预查不会回溯，
  <nowiki>/(?=(a+))a*b\1/.exec("baaabac")</nowiki>
得到：
  <nowiki>["aba", "a"]</nowiki>
而不是：
  <nowiki>["aaaba", "a"]</nowiki>

{{note| '''(?! ''Disjunction'' )''' 指定一个零宽正向否定预查。为了保证匹配成功，其 '''''Disjunction''''' 必须首先能够匹配失败，但在匹配后续字符前，其当前位置会不变。'''''Disjunction''''' 能含有捕获括号，但是对这些捕获分组的后向引用只在 '''''Disjunction''''' 中有效。在当前模式的其他位置后向引用捕获分组都会返回 '''undefined'''。因为否定预查必须满足预查失败来保证模式成功匹配。}}

{{note| '''(? {{=}} ''Disjunction'' )''' 指定一个零宽正向预查。为了保证匹配成功，其 '''''Disjunction''''' 必须首先能够匹配成功，但在匹配后续字符前，其当前位置会不变。如果 '''''Disjunction''''' 能在当前位置以多种方式匹配，那么只会取第一次匹配的结果。不像其他正则表达式运算符，'''(?{{=}}''' 内部不会回溯（这个特殊的行为是从 Perl 继承过来的）。在 '''''Disjunction''''' 含有捕获括号，模式的后续字符包括后向引用时匹配结果会有影响。}}

例如，
  <nowiki>/(.*?)a(?!(a+)b\2c)\2(.*)/.exec("baaabaac")</nowiki>
搜索 '''a'''，其后有 <var>n</var> 个 '''a'''，一个 '''b'''， <var>n</var> 个 '''a'''（'''\2''' 指定）和一个 '''c'''。第二个 '''\2''' 位于负向预查模式的外部，因此它匹配 '''undefined'''，且总是成功的。整个表达式返回一个数组：
  <nowiki>["baaabaac", "ba", undefined, "abaac"]</nowiki>

在大小写不敏感的匹配中，所有字符都在它们参与比较之前隐式转换成大写的。然而，如果把一个字符转换成大写会产生多个字符（例如 '''"&#223;"'''（'''\u00DF'''） 转换到 '''"SS"'''），那么字符将保持不变。如果一个字符是非 ASCII 字符，但却会因大小写转换而变成 ASCII 字符，那么在匹配中它也会保持不变。这个规定阻止了一些如 '''\u0131''' 和 '''\u017F''' 之类的 Unicode 字符 {{extra note||这两个字符toUpperCase后得到的是ASCII字符的I和S。}} 被 '''/[a-z]/i''' 这样的正则表达式匹配，这样的正则表达式被故意设计成只匹配 ASCII 字符。此外，倘若从 Unicode 到 ASCII 的转换被允许，将会造成 '''/[^\W]/i''' 可以匹配 '''a'''、'''b'''、'''…'''、'''h'''，但无法匹配 '''i''' 或 '''s'''。


==== {{anchor|x15.10.2.9}}转义原子（{{toanchor|AtomEscape}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.9}}

产生式 ''{{toanchor|AtomEscape}}'' :: ''{{toanchor|DecimalEscape}}'' 执行方式如下：

# 执行 ''{{toanchor|DecimalEscape}}'' 得到 ''{{toanchor|EscapeValue}}'' <var>E</var>。
# 如果 <var>E</var> 为一个字符，
## 令 <var>ch</var> 为 <var>E</var> 的字符。
## 令 <var>A</var> 为包含 <var>ch</var> 字符的单元素字符集 {{toanchor|CharSet}}。
## 调用 {{toanchor|CharacterSetMatcher}}(<var>A</var>, '''false''') 返回 {{toanchor|Matcher}} 结果。
# <var>E</var> 必须是一个数。令 <var>n</var> 为该数。
# 如果 <var>n</var> = '''0''' 或 <var>n</var> > {{toanchor|NcapturingParens}}，抛出 '''SyntaxError''' 异常。
# 返回一个内部闭包 {{toanchor|Matcher}}，拥有2个参数：一个 {{toanchor|State}} <var>x</var> 和 {{toanchor|Continuation}} <var>c</var>，执行方式如下：
## 令 <var>cap</var> 为 <var>x</var> 的 '''captures''' 内部数组。
## 令 <var>s</var> 为 <var>cap</var>[<var>n</var>]。
## 如果 <var>s</var> 为 '''undefined'''，调用 <var>c</var>(<var>x</var>)，返回结果
## 令 <var>e</var> 为 <var>x</var> 的 <var>endIndex</var>。
## 令 <var>len</var> 为 <var>s</var> 的 <var>length</var>。
## 令 <var>f</var> 为 <var>e</var> + <var>len</var>。
## 如果 <var>f</var> > {{toanchor|InputLength}}，返回 '''failure'''。
## 如果存在位于 '''0'''（包括）到 <var>len</var>（不包括）的整数 <var>i</var> 使得 {{toanchor|Canonicalize}}(<var>s</var>[<var>i</var>]) 等于 {{toanchor|Canonicalize}}({{toanchor|Input}}[<var>e</var> + <var>i</var>])，那么返回'''failure'''。
## 令 <var>y</var> 为{{toanchor|State}} (<var>f</var>, <var>cap</var>)。
## 调用 <var>c</var>(<var>y</var>)，返回结果。

产生式 ''{{toanchor|AtomEscape}}'' :: ''{{toanchor|CharacterEscap}}'' 执行方式如下：
# 执行 ''{{toanchor|CharacterEscap}}'' 得到一个 <var>ch</var> 字符。
# 令 <var>A</var> 为包含 <var>ch</var> 字符的单元素字符集 {{toanchor|CharSet}}。
# 调用 {{toanchor|CharacterSetMatcher}}(<var>A</var>, '''false''') 返回 {{toanchor|Matcher}} 结果。

产生式 ''{{toanchor|AtomEscape}}'' :: {{toanchor|CharacterClassEscape}} 执行方式如下：
# 执行 ''{{toanchor|CharacterClassEscape}}'' 得到一个{{toanchor|CharSet}} <var>A</var>。
# 调用 ''{{toanchor|CharacterSetMatcher}}''(<var>A</var>, '''false''') 返回 {{toanchor|Matcher}} 结果。

{{note| 格式 '''\''' 后为非零数 '''''n''''' 的转义序列匹配捕获分组的第 '''''n''''' 次匹配结果。如果正则表达式少于 '''''n''''' 个捕获括号，会报错。如果正则表达式大于等于 '''''n''''' 个捕获括号，由于没有捕获到任何东西，导致第 '''''n''''' 个捕获分组结果为'''undefined'''，那么后向引用总是成功的。}}


==== {{anchor|x15.10.2.10}}转义字符（{{toanchor|CharacterEscap}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.10}}

产生式 ''{{toanchor|CharacterEscap}}'' :: {{toanchor|ControlEscape}} 执行返回一个根据 '''表23''' 定义的字符：

{| border="1" cellpadding="5" style="border-collapse:collapse"
|+ 表23 - ControlEscape 的字符值
|- style="background:#EEE"
! ControlEscape
! 单位代码
! 名称
! 记号
|-
| t
| \u0009
| 水平制表符
| <HT>
|-
| n
| \u000A
| 换行符
| <LF>
|-
| v
| \u000B
| 垂直制表符
| <VT>
|-
| f
| \u000C
| 换页符
| <FF>
|-
| r
| \u000D
| 回车符
| <CR>
|}

产生式 ''{{toanchor|CharacterEscap}}'' :: '''c''' <var>ControlLetter</var> 执行过程如下：
# 令 <var>ch</var> 为通过 <var>ControlLetter</var> 表示的字符
# 令 <var>i</var> 为 <var>ch</var> 的单位代码值
# 令 <var>j</var> 为 <var>i</var>/'''32''' 的余数
# 返回 <var>j</var>

产生式 ''{{toanchor|CharacterEscap}}'' :: ''[[ES5/lexical#HexEscapeSequence|HexEscapeSequence]]'' 执行 ''[[ES5/lexical#HexEscapeSequence|HexEscapeSequence]]'' 的字符值，返回其字符结果。

产生式 ''{{toanchor|CharacterEscap}}'' :: ''[[ES5/lexical#UnicodeEscapeSequence|UnicodeEscapeSequence]]'' 执行 ''[[ES5/lexical#UnicodeEscapeSequence|UnicodeEscapeSequence]]'' 的字符值，返回其字符结果。

产生式 ''{{toanchor|CharacterEscap}}'' :: ''{{toanchor|IdentityEscape}}'' 执行返回由 ''{{toanchor|IdentityEscape}}'' 表示的字符。


==== {{anchor|x15.10.2.11}}转义十进制（{{toanchor|DecimalEscape}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.11}}

产生式 ''{{toanchor|DecimalEscape}}'' :: ''[[ES5/lexical#DecimalIntegerLiteral|DecimalIntegerLiteral]]'' &#91;[[ES5/notation#lookahead-not-in|lookahead ∉]] ''[[#ES5/lexical#DecimalDigit|DecimalDigit]]''] 按如下方式执行：

# 令 <var>i</var> 为 ''[[ES5/lexical#DecimalIntegerLiteral|DecimalIntegerLiteral]]'' 的字符值
# 如果 <var>i</var> 为 '''0'''，返回包含一个 '''<NUL>''' 字符（Unicode 值为 '''0000'''）的 ''{{toanchor|EscapeValue}}''
# 返回包含整数 <var>i</var> 的 ''{{toanchor|EscapeValue}}''

''[[ES5/lexical#DecimalIntegerLiteral|DecimalIntegerLiteral]]'' 的数学值在 [[ES5/lexical#x7.8.3|7.8.3]] 节定义。

{{note| 如果 '''\''' 后面是一个数字，且首位为 '''0'''，那么，该转义序列被认为是一个后向引用。如果 '''''n''''' 比在整个正则表达式左捕获括号个数大，那么会出错。'''\0''' 表示 '''<NUL>''' 字符，其后不能再有数字。}}


===={{anchor|x15.10.2.12}}转义字符类（{{toanchor|CharacterClassEscape}}）====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.12}}

产生式 ''{{toanchor|CharacterClassEscape}}'' :: '''d''' 执行返回包含'''0'''到'''9'''之间的十元素字符集。

产生式 ''{{toanchor|CharacterClassEscape}}'' :: '''D''' 执行返回不包括 {{toanchor|CharacterClassEscape}} :: '''d''' 的字符集。

产生式 ''{{toanchor|CharacterClassEscape}}'' :: '''s''' 执行返回包含 ''[[ES5/lexical#WhiteSpace|WhiteSpace]]'' 或 ''[[ES5/lexical#LineTerminator|LineTerminator]]'' 产生式右部分字符的字符集。

产生式 ''{{toanchor|CharacterClassEscape}}'' :: '''S''' 执行返回不包括 {{toanchor|CharacterClassEscape}} :: '''s''' 的字符集。

产生式 ''{{toanchor|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 _'''

产生式 ''{{toanchor|CharacterClassEscape}}'' :: '''W''' 执行返回不包括 ''{{toanchor|CharacterClassEscape}}'' :: '''w''' 的字符集。


==== {{anchor|x15.10.2.13}}字符类（{{toanchor|CharacterClass}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.13}}

产生式 ''{{toanchor|CharacterClass}}'' :: '''[''' &#91;[[ES5/notation#lookahead-not-in|lookahead ∉]] {'''^'''}] ''{{toanchor|ClassRanges}}'' ''']''' 通过执行 ''{{toanchor|ClassRanges}}'' 获得并返回这个 {{toanchor|CharSet}} 和 '''Boolean false'''。

产生式 ''{{toanchor|CharacterClass}}'' :: '''[ ^''' ''{{toanchor|ClassRanges}}'' ''']''' 通过执行 ''{{toanchor|ClassRanges}}'' 获得并返回这个 {{toanchor|CharSet}} 和 '''Boolean true'''。


==== {{anchor|x15.10.2.14}}字符范围集（{{toanchor|ClassRanges}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.14}}

产生式 ''{{toanchor|ClassRanges}}'' :: &#91;[[ES5/notation#empty|empty]]] 执行返回一个空的 {{toanchor|CharSet}}。

产生式 ''{{toanchor|ClassRanges}}'' :: ''{{toanchor|NonemptyClassRanges}}'' 通过执行 ''{{toanchor|NonemptyClassRanges}}'' 获得并返回这个 {{toanchor|CharSet}}。


==== {{anchor|x15.10.2.15}}非空字符范围集（{{toanchor|NonemptyClassRanges}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.15}}

产生式 ''{{toanchor|NonemptyClassRanges}}'' :: ''{{toanchor|ClassAtom}}'' 通过执行 ''{{toanchor|ClassAtom}}'' 获得一个 {{toanchor|CharSet}} 并返回这个{{toanchor|CharSet}}。

产生式 ''{{toanchor|NonemptyClassRanges}}'' :: ''{{toanchor|ClassAtom}}'' ''{{toanchor|NonemptyClassRangesNoDash}}'' 按如下方式执行：

# 执行 ''{{toanchor|ClassAtom}}'' 得到一个 {{toanchor|CharSet}} <var>A</var>。
# 执行 ''{{toanchor|NonemptyClassRangesNoDash}}'' 得到一个 {{toanchor|CharSet}} <var>B</var>。
# 返回 <var>A</var> 与 <var>B</var> 的并集。

产生式 ''{{toanchor|NonemptyClassRanges}}'' :: ''{{toanchor|ClassAtom}}'' - ''{{toanchor|ClassAtom}}'' ''{{toanchor|ClassRanges}}'' 按如下方式执行：

# 执行第一个 ''{{toanchor|ClassAtom}}'' 得到一个 {{toanchor|CharSet}} <var>A</var>。
# 执行第二个 ''{{toanchor|ClassAtom}}'' 得到一个 {{toanchor|CharSet}} <var>B</var>。
# 执行 ''{{toanchor|ClassRanges}}'' 得到一个{{toanchor|CharSet}} <var>C</var>。
# 调用 ''{{toanchor|CharacterRange}}''(<var>A</var>, <var>B</var>)，令D为其结果 {{toanchor|CharSet}}。
# 返回 <var>D</var> 与 <var>C</var> 的并集。

{{anchor|CharacterRange}}抽象操作 '''CharacterRange'''，拥有2个 {{toanchor|CharSet}} 参数 <var>A</var> 和 <var>B</var>，执行方式如下：

# 如果 <var>A</var> 或 <var>B</var> 为空，抛出 '''SyntaxError''' 异常。
# 令 <var>a</var> 为 {{toanchor|CharSet}} <var>A</var> 的一个字符。
# 令 <var>b</var> 为 {{toanchor|CharSet}} <var>B</var> 的一个字符。
# 令 <var>i</var> 为 <var>a</var> 的单位代码值。
# 令 <var>j</var> 为 <var>b</var> 的单位代码值。
# 如果 <var>i</var> > <var>j</var>，抛出 '''SyntaxError''' 异常。
# 返回位于在 <var>i</var> 到 <var>j</var>（包括边界）之间的所有字符的字符集。


==== {{anchor|x15.10.2.16}}无连接符非空字符范围集（{{toanchor|NonemptyClassRangesNoDash}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.16}}

产生式 ''{{toanchor|NonemptyClassRangesNoDash}}'' :: ''{{toanchor|ClassAtom}}'' 执行一个 ''{{toanchor|ClassAtom}}'' 获取结果 {{toanchor|CharSet}} 并返回。

产生式 ''{{toanchor|NonemptyClassRangesNoDash}}'' :: ''{{toanchor|ClassAtomNoDash}}'' ''{{toanchor|NonemptyClassRangesNoDash}}'' 的结果根据以下步骤:

#执行 ''{{toanchor|ClassAtomNoDash}}'' 得到一个 {{toanchor|CharSet}} <var>A</var>。
#执行 ''{{toanchor|NonemptyClassRangesNoDash}}'' 得到一个 {{toanchor|CharSet}} <var>B</var>。
#返回 {{toanchor|CharSet}} <var>A</var> 和 {{toanchor|CharSet}} <var>B</var> 的并集。

产生式 ''{{toanchor|NonemptyClassRangesNoDash}}'' :: ''{{toanchor|ClassAtomNoDash}}'' '''-''' ''{{toanchor|ClassAtom}}'' ''{{toanchor|ClassRanges}}'' 按下面的步骤执行:

#执行 ''{{toanchor|ClassAtomNoDash}}'' 得到一个 {{toanchor|CharSet}} <var>A</var>。
#执行 ''{{toanchor|ClassAtom}}'' 得到一个 {{toanchor|CharSet}} <var>B</var>。
#执行 ''{{toanchor|ClassRanges}}'' 得到一个 {{toanchor|CharSet}} <var>C</var>
#令 <var>D</var> 为调用方法 {{toanchor|CharacterRange}}(<var>A</var>, <var>B</var>) 返回的 {{toanchor|CharSet}}。
#返回 {{toanchor|CharSet}} <var>D</var> 和 {{toanchor|CharSet}} <var>C</var> 的并集。

{{note| '''''ClassRanges''''' 可以扩展到单独的 '''''ClassAtoms''''' 及 '''/''' 或 两个 '''''ClassAtom''''' 的范围，用横杆隔开。
后面的情况中 '''''ClassRanges''''' 包含从第一个 '''''ClassAtom''''' 与第二个 '''''ClassAtom''''' 之间的所有字符。
如果其中一个 '''''ClassAtom''''' 不描述单一字符（例如'''\w'''）或如果第一个 '''''ClassAtom''''' 的单位代码值大于第二个 '''''ClassAtom'''''，则产生一个错误。}}
{{note| 如果模式语句无视大小写，那么范围两端的特征决定这个范围包含那些字符。
因此，例如这个模式语句是 '''/[E-F]/i''' 可以匹配的字符只有 '''E'''、'''F'''、'''e'''、'''f'''，如果模式语句是 '''/E-f/i''' 就可以匹配所有大小写字母和这些特殊符号：'''['''、'''\'''、''']'''、'''^'''、'''_'''、'''`'''。}}
{{note| '''"-"''' 可以作为字符处理，也可以指定一个范围。
如果它是 '''''ClassRange''''' 的第一个或最后一个字符、范围规范的开始或结束限制、或直接跟上一个范围规范，那么它被作为字符处理。}}


==== {{anchor|x15.10.2.17}}字符类原子（{{toanchor|ClassAtom}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.17}}

产生式 ''{{toanchor|ClassAtom}}'' :: '''-''' 执行返回包含单个字符 '''-''' 的字符集。

产生式 ''{{toanchor|ClassAtom}}'' :: ''{{toanchor|ClassAtomNoDash}}'' 通过执行 ''{{toanchor|ClassAtomNoDash}}'' 获得并返回这个 {{toanchor|CharSet}}。


==== {{anchor|x15.10.2.18}}非连接符字符类原子（{{toanchor|ClassAtomNoDash}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.18}}

产生式 ''{{toanchor|ClassAtomNoDash}}'' :: ''[[ES5#SourceCharacter|SourceCharacter]]'' 不包括 '''\'''、''']'''、'''-''' 执行返回包含由 [[ES5#SourceCharacter|SourceCharacter]] 表示的字符的单元素字符集。

产生式 ''{{toanchor|ClassAtomNoDash}}'' :: '''\''' ''{{toanchor|ClassEscape}}'' 通过执行 ''{{toanchor|ClassEscape}}'' 得到并返回这个 {{toanchor|CharSet}}。


==== {{anchor|x15.10.2.19}}字符类可用转义（{{toanchor|ClassEscape}}） ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.2.19}}

产生式 ''{{toanchor|ClassEscape}}'' :: ''{{toanchor|DecimalEscape}}'' 按如下方式执行：

# 执行 ''{{toanchor|DecimalEscape}}'' 得到 ''{{toanchor|EscapeValue}}'' <var>E</var>
# 如果 <var>E</var> 不是一个字符，抛出 '''SyntaxError''' 异常。
# 令 <var>ch</var> 为 <var>E</var> 的字符。
# 返回包含字符 <var>ch</var> 的单元素 {{toanchor|CharSet}}。

产生式 ''{{toanchor|ClassEscape}}'' :: '''b''' 执行返回包含一个 '''<BS>''' 字符（Unicode 值 '''0008'''）的字符集。

产生式 ''{{toanchor|ClassEscape}}'' :: ''{{toanchor|CharacterEscap}}'' 通过执行 ''{{toanchor|CharacterEscap}}'' 获得一个字符 {{toanchor|CharSet}} 并返回包含该字符的单元素字符集 {{toanchor|CharSet}}。

产生式 ''{{toanchor|ClassEscape}}'' :: ''{{toanchor|CharacterClassEscape}}'' 通过执行 ''{{toanchor|CharacterClassEscape}}'' 获得并返回这个{{toanchor|CharSet}}。

{{note| '''''ClassAtom''''' 可以使用除'''\b'''、'''\B'''、'''后向引用'''，以外的转义序列。在 '''''CharacterClass''''' 中，'''\b''' 表示退格符。而，'''\B''' 和'''后向引用'''会报错。同样，在一个 '''''ClassAtom''''' 中使用后向引用会报错。}}


=== {{anchor|x15.10.3}}RegExp 构造器作为函数调用 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.3}}


==== {{anchor|x15.10.3.1}}RegExp(pattern, flags) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.3.1}}

如果 <var>pattern</var> 是一个对象 <var>R</var>，其内部属性 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 为 '''"RegExp"''' 且 <var>flags</var> 为 '''undefined'''，返回 <var>R</var>。否则，调用内置'''RegExp'''构造器，通过表达式 '''new RegExp('''<var>pattern</var>, <var>flags</var>''')''' 返回由该构造器构造的对象。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/regexp.js?r{{=}}13202#86|RegExpConstructor}}


=== {{anchor|x15.10.4}}RegExp 构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.4}}

当'''RegExp'''作为 '''new''' 表达式一部分调用时，它是一个构造器，用来初始化一个新创建的对象。


==== {{anchor|x15.10.4.1}}new RegExp(pattern, flags) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.4.1}}

如果 <var>pattern</var> 是一个对象且它的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性为 '''"RegExp"'''，则令 <var>R</var> 为 <var>pattern</var>。接着，如果 <var>flags</var> 是 '''undefined'''，则令 <var>P</var> 为构造 <var>R</var> 时使用的 <var>pattern</var>，令 <var>F</var> 为构造 <var>R</var> 时使用的 <var>flags</var>，否则抛出'''TypeError'''异常。对于其它情况，如果 <var>pattern</var> 为 '''undefined'''，则令 <var>P</var> 为空字符串，否则令 <var>P</var> 为 [[ES5/conversion#ToString|ToString]](<var>pattern</var>)，如果 <var>flags</var>  为 '''undefined'''，则令 <var>F</var> 为空字符串，否则令 <var>F</var> 为 [[ES5/conversion#ToString|ToString]](<var>flags</var>)。

如果字符 <var>P</var> 不满足 ''{{toanchor|Pattern}}'' 句法，那么抛出 '''SyntaxError''' 异常。否则，令新构造的对象拥有内部 [[ES5/types#Match|<nowiki>[[Match]]</nowiki>]] 属性，该属性通过执行（编译）字符 <var>P</var> 作为在 [[#15.10.2|15.10.2]] 节描述的 ''{{toanchor|Pattern}}''。

如果 <var>F</var> 含有除 '''"g"'''、'''"i"'''、'''"m"''' 外的任意字符，或者 <var>F</var> 中包括出现多次的字符，那么，抛出'''SyntaxError'''异常。 {{v8|https://github.com/v8/v8/blob/3.22/src/regexp.js#L57|}}

如果 '''SyntaxError''' 异常未抛出，那么：

令 <var>S</var> 为一个字符串，其等价于 <var>P</var> 表示的 ''{{toanchor|Pattern}}''，<var>S</var> 中的字符按如下描述进行转义。这样，<var>S</var> 可能或者不会与 <var>P</var> 或者 ''{{toanchor|Pattern}}'' 相同；然而，由执行 <var>S</var> 作为一个 ''{{toanchor|Pattern}}'' 的内部处理程序必须和通过构造对象的内部 [[ES5/types#Match|<nowiki>[[Match]]</nowiki>]] 属性的内部处理程序完全相同。

如果 ''{{toanchor|Pattern}}'' 里存在字符 '''/''' 或者 '''\''' ，那么这些字符应该被转义，以确保由 '''"/"'''、<var>S</var>、'''"/"''' 构成的字符串的 <var>S</var> 值有效，而且 <var>F</var> 能被解析（在适当的词法上下文中）为一个与构造的正则表达式行为完全相同的 ''[[ES5/lexical#RegularExpressionLiteral|RegularExpressionLiteral]]'' 。例如，如果 <var>P</var> 是'''"/"'''，那么 <var>S</var> 应该为 '''"\/"''' 或 '''"\u002F"'''，而不是 '''"/"'''，因为 <var>F</var> 后的 '''///''' 会被解析为一个 ''[[ES5/lexical#SingleLineComment|SingleLineComment]]''，而不是一个 ''[[ES5/lexical#RegularExpressionLiteral|RegularExpressionLiteral]]''。 如果 <var>P</var> 为空字符串，那么该规范定义为令 <var>S</var> 为 '''"(?:)"'''。

这个新构造对象的如下属性为数据属性，其特性在 [[#x15.10.7|15.10.7]] 中定义。各属性的 [[ES5/types#Value|<nowiki>[[Value]]</nowiki>]] 值按如下方式设置：

其 '''source''' 属性置为 <var>S</var>。

其 '''global''' 属性置为一个 '''Boolean''' 值。当 <var>F</var> 含有字符 '''g''' 时，为 '''true'''，否则，为 '''false'''。

其 '''IgnoreCase''' 属性置为一个 '''Boolean''' 值。当 <var>F</var> 含有字符 '''i''' 时，为 '''true'''，否则，为 '''false'''。

其 '''multiline''' 属性置为一个 '''Boolean''' 值。当 <var>F</var> 含有字符 '''m''' 时，为 '''true'''，否则，为 '''false'''。

其 '''lastIndex''' 属性置为 '''0'''。

其内部 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 属性置为 [[#x15.10.6|15.10.6]] 中定义的内置 '''RegExp''' 原型对象。

其内部 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 属性置为 '''"RegExp"'''。

{{note| 如果 '''''Pattern''''' 为 '''''StringLiteral'''''，一般的转义字符替换发生在被 '''RegExp''' 处理前。如果 '''''Pattern''''' 必须含有 '''RegExp''' 识别的转义字符，那么当构成 '''''StringLiteral''''' 的内容时，为了防止被移除 '''\''' 被移除，在 '''''StringLiteral''''' 中的任何 '''\''' 必须被转义}}


=== {{anchor|x15.10.5}}RegExp构造器的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.5}}

'''RegExp''' 构造器的[[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]]值为内置 '''Function''' 的原型（[[#x15.3.4|15.3.4]]）。

除了内部的一些属性和 '''length''' 属性（其值为'''2'''），'''RegExp''' 构造器还有如下属性：


==== {{anchor|x15.10.5.1}}RegExp.prototype ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.5.1}}

'''RegExp.prototype'''的初始值为'''RegExp'''的原型（[[#x15.10.6|15.10.6]]）。

该属性有这些特性： { <nowiki>[[Writable]]</nowiki>: '''false''', <nowiki>[[Enumerable]]</nowiki>: '''false''', <nowiki>[[Configurable]]</nowiki>: '''false''' }。


=== {{anchor|x15.10.6}}RegExp.Prototype的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.6}}

'''RegExp''' 的原型的内部 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 属性为 '''Object''' 的原型（[[#x15.2.4|15.2.4]]）。'''RegExp''' 的原型为其本身的一个普通的正则表达式对象；它的[[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 为 '''"RegExp"'''。'''RegExp''' 的原型对象的数据式属性的初始值被设置为仿佛由内置 '''RegExp''' 构造器深生成的表达式 '''new RegExp()''' 创建的对象。

'''RegExp'' 的原型本身没有 '''valueOf''' 属性；然而，该 '''valueOf''' 属性是继承至 '''Object''' 的原型。

在作为 '''RegExp''' 原型对象的属性的如下函数描述中，'''"this RegExp object"''' 是指函数激活时 '''this''' 对象；如果 '''this''' 值不是一个对象，或者一个其内部 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 属性值不是 '''"RegExp"''' 的对象，那么一个 '''TypeError''' 会抛出。


==== {{anchor|x15.10.6.1}}RegExp.prototype.constructor ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.6.1}}

'''RegExp.prototype.constructor''' 的初始值为内置 '''RegExp''' 构造器。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/regexp.js?r{{=}}13202#407|Set Prototype.constructor}}


==== {{anchor|x15.10.6.2}}RegExp.prototype.exec(string) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.6.2}}
# 令 <var>R</var> 为该 '''RegExp''' 对象。
# 令 <var>S</var> 为[[ES5/conversion#ToString|ToString]](<var>string</var>)的值。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/regexp.js?r{{=}}13202#175|ToString}}
# 令 <var>length</var> 为 <var>S</var> 的长度。
# 令 <var>lastIndex</var> 为以参数 '''"lastIndex"''' 调用 <var>R</var> 的内部方法 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 的结果。
# 令 <var>i</var> 为 [[ES5/conversion#ToInteger|ToInteger]](<var>lastIndex</var>) 的值。
# 令 <var>global</var> 为以参数 '''"global"''' 调用 <var>R</var> 的内部方法 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 的结果。
# 若 <var>global</var> 为 '''false'''，则令 <var>i</var> = '''0'''。
# 令 <var>matchSucceeded</var> 为'''false'''。
# 到 <var>matchSucceeded</var> 为'''false''' 前重复以下。
## 若 <var>i</var> < '''0''' 或者 <var>i</var> > <var>length</var>，则
### 以参数 '''"lastIndex"'''、'''0''' 和 '''true''' 调用 <var>R</var> 的内部方法[[ES5/types#Put|<nowiki>[[Put]]</nowiki>]]。
### 返回 '''null'''。
## 以参数 <var>S</var> 和 <var>i</var> 调用 <var>R</var> 的内部方法[[ES5/types#Match|<nowiki>[[Match]]</nowiki>]]。
## 若 [[ES5/types#Match|<nowiki>[[Match]]</nowiki>]] 返回失败，则
### 令 <var>i</var> = <var>i</var> + '''1'''。
## 否则
### 令 <var>r</var> 为调用 [[ES5/types#Match|<nowiki>[[Match]]</nowiki>]] 的结果 {{toanchor|State}}。
### 设 <var>matchSucceeded</var> 为 '''true'''。
# 令 <var>e</var> 为 <var>r</var> 的 <var>endIndex</var> 值。
# 若 <var>global</var> 为'''true''',
# 以参数 '''"lastIndex"'''、<var>e</var> 和 '''true''' 调用 <var>R</var> 的内部方法 [[ES5/types#Put|<nowiki>[[Put]]</nowiki>]]。
# 令 <var>n</var> 为 <var>r</var> 的捕获数组的长度。（这跟 [[#x15.10.2.1|15.10.2.1]] 的 {{toanchor|NcapturingParens}} 是同一个值）
# 令 <var>A</var> 为如同以表达式 '''new Array''' 创建的新数组，其中'''Array'''是这个名字的内置构造器。
# 令 <var>matchIndex</var> 为匹配到的子串在整个字符串 <var>S</var> 中的位置。
# 以参数 '''"index"'''，属性描述 <nowiki>{[[Value]]: </nowiki><var>matchIndex</var><nowiki>, [[Writable]: </nowiki>'''true'''<nowiki>, [[Enumerable]]: </nowiki>'''true'''<nowiki>, [[Configurable]]: </nowiki>'''true'''<nowiki>}</nowiki> 和 '''true''' 调用 <var>A</var> 的内部方法 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]]。
# 以参数 '''"input"'''，属性描述 {<nowiki>{[[Value]]:  </nowiki><var>S</var><nowiki>, [[Writable]: </nowiki>'''true'''<nowiki>, [[Enumerable]]: </nowiki>'''true'''<nowiki>, [[Configurable]]: </nowiki>'''true'''<nowiki>}</nowiki> 和 '''true''' 调用 <var>A</var> 的内部方法[[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]]。
# 以参数'''"length"'''，属性描述 {<nowiki>[[Value]]</nowiki>: <var>n</var> + 1} 和 '''true''' 调用 <var>A</var> 的内部方法[[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]]。
# 令 <var>matchedSubstr</var> 为匹配到的子串（例如：<var>S</var> 中从 <var>i</var> 位置<包含>到 <var>e</var> 位置<不包含>的部分 )。
# 以参数 '''"0"'''，属性描述 {<nowiki>{[[Value]]: </nowiki><var>matchedSubstr</var><nowiki>, [[Writable]: </nowiki>'''true'''<nowiki>, [[Enumerable]]: </nowiki>'''true'''<nowiki>, [[Configurable]]: </nowiki>'''true'''<nowiki>}</nowiki> 和 '''true''' 调用 <var>A</var> 的内部方法[[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]]。
# 对每一满足 <var>I</var> > '''0''' 且 <var>I</var> ≤ <var>n</var> 的整数 <var>i</var> 
## 令 <var>captureI</var> 为第 <var>i</var> 个捕获数组中的元素。
## 以参数 [[ES5/conversion#ToString|ToString]](<var>i</var>)，属性描述 <nowiki>{[[Value]]: </nowiki><var>captureI</var><nowiki>, [[Writable]: </nowiki>'''true'''<nowiki>, [[Enumerable]]: </nowiki>'''true'''<nowiki>, [[Configurable]]: </nowiki>'''true'''<nowiki>}</nowiki> 和 '''true''' 调用 <var>A</var> 的内部方法 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]]。
# 返回 <var>A</var>。


==== {{anchor|x15.10.6.3}}RegExp.prototype.test(string) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.6.3}}

采用如下步骤：

# 令 <var>match</var> 为在这个 '''RegExp''' 对象上使用 <var>string</var> 作为参数执行 [[#x15.10.6.2|RegExp.prototype.exec]] 的结果。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/regexp.js?r{{=}}13202#238|Exec}}

# 如果 <var>match</var> 不为 '''null'''，返回 '''true'''；否则返回 '''false'''。


==== {{anchor|x15.10.6.4}}RegExp.prototype.toString() ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.6.4}}

返回一个 '''String'''，由 '''"/"'''、'''RegExp''' 对象的 '''source''' 属性值、'''"/"''' 与 '''"g"'''（如果 '''global''' 属性为 '''true'''），'''"i"'''（如果 '''IgnoreCase''' 为'''true'''），'''"m"'''（如果 '''multiline''' 为'''true'''）通过连接组成。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/regexp.js?r{{=}}13202#286|Concat Strings}}

{{note| 如果返回的字符串包含一个 '''''RegularExpressionLiteral'''''，那么该 '''''RegularExpressionLiteral''''' 用同样的方式解释执行。}}


=== {{anchor|x15.10.7}}RegExp实例的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.7}}

'''RegExp''' 实例继承至 '''RegExp''' 原型对象，其 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性值为 '''"RegExp"'''。'''RegExp''' 实例也拥有一个 [[ES5/types#Match|<nowiki>[[Match]]</nowiki>]] 内部属性和一个 '''length''' 属性。

内部属性 [[ES5/types#Match|<nowiki>[[Match]]</nowiki>]] 的值是正则表达式对象的 ''{{toanchor|Pattern}}'' 的依赖实现的表示形式。

'''RegExp'''实例还有如下属性。


==== {{anchor|x15.10.7.1}}source ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.7.1}}

'''source''' 属性为构成正则表达式 ''{{toanchor|Pattern}}'' 的字符串。该属性拥有这些特性 { <nowiki>[[Writable]]</nowiki>: '''false''', <nowiki>[[Enumerable]]</nowiki>: '''false''', <nowiki>[[Configurable]]</nowiki>: '''false''' }。


==== {{anchor|x15.10.7.2}}global ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.7.2}}
'''global''' 属性是一个 '''Boolean''' 值，表示正则表达式 '''flags''' 是否有 '''"g"'''。该属性拥有这些特性 { <nowiki>[[Writable]]</nowiki>: '''false''', <nowiki>[[Enumerable]]</nowiki>: '''false''', <nowiki>[[Configurable]]</nowiki>: '''false''' }。


==== {{anchor|x15.10.7.3}}ignoreCase ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.7.3}}
'''ignoreCase''' 属性是一个 '''Boolean''' 值，表示正则表达式 '''flags''' 是否有 '''"i"'''。该属性拥有这些特性 { <nowiki>[[Writable]]</nowiki>: '''false''', <nowiki>[[Enumerable]]</nowiki>: '''false''', <nowiki>[[Configurable]]</nowiki>: '''false''' }。


==== {{anchor|x15.10.7.4}}multiline ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.7.4}}
'''multiline''' 属性是一个 '''Boolean''' 值，表示正则表达式 '''flags''' 是否有 '''"m"'''。该属性拥有这些特性 { <nowiki>[[Writable]]</nowiki>: '''false''', <nowiki>[[Enumerable]]</nowiki>: '''false''', <nowiki>[[Configurable]]</nowiki>: '''false''' }。


===={{anchor|x15.10.7.5}}lastIndex====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.10.7.5}}
'''lastIndex''' 属性指定从何处开始下次匹配的一个字符串类型的位置索引。当需要时该值会转换为一个整型数。该属性拥有这些特性 { <nowiki>[[Writable]]</nowiki>: '''true''', <nowiki>[[Enumerable]]</nowiki>: '''false''', <nowiki>[[Configurable]]</nowiki>: '''false''' }。
{{note| 不同于其他 '''RegExp''' 实例内置属性，'''lastIndex''' 是可写的。}}

== {{anchor|x15.11}}Error对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.11}}

'''Error''' 对象的实例在运行时遇到错误的情况下会被当做异常抛出。'''Error''' 对象也可以作为用户自定义异常类的基对象。


=== {{anchor|x15.11.1}}Error构造器作为函数调用===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.1}}
当 '''Error''' 被作为函数而不是构造器调用时，它创建并初始化一个新的 '''Error''' 对象。这样函数调用 '''Error(…)''' 与同样参数的对象创建表达式 '''new Error(…)''' 是等效的。


==== {{anchor|x15.11.1.1}}Error (message)====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.1.1}}

新构造的对象内部属性 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 会被设为原本的 '''Error''' 原型对象，也就是 '''Error.prototype''' 的初始值。([[#x15.11.3.1|15.11.3.1]]){{v8|http://code.google.com/p/v8/source/browse/trunk/src/messages.js?r{{=}}13187#1135|Set All Error Functions}}

新构造的对象内部属性 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 会被设为 '''"Error"'''。

新构造的对象内部属性 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 会被设为 '''true'''。

如果形参 <var>message</var> 不是 '''undefined'''，新构造的对象本身属性 <var>message</var> 则被设为 [[ES5/conversion#ToString|ToString]](<var>message</var>)。


=== {{anchor|x15.11.2}}Error构造器 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.2}}
当 '''Error''' 作为 '''new''' 表达式的一部分被调用时，它是一个构造器：它初始化新创建的对象。


==== {{anchor|x15.11.2.1}}new Error (message) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.2.1}}

新构造的对象内部属性 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 会被设为原本的 '''Error''' 原型对象，也就是 '''Error.prototype''' 的初始值。([[#x15.11.3.1|15.11.3.1]])

新构造的对象内部属性 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 会被设为'''"Error"'''。

新构造的对象内部属性 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 会被设为'''true'''。

如果形参 <var>message</var> 不是'''undefined'''，新构造的对象本身属性 <var>message</var> 则被设为[[ES5/conversion#ToString|ToString]](<var>message</var>)。


=== {{anchor|x15.11.3}}Error构造器的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.3}}

'''Error'''构造器的内部属性[[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]]值为'''Function'''原型对象([[#x15.3.4|15.3.4]])。

除内部属性和 '''length''' 属性（其值为'''1'''）以外，'''Error'''构造器还有以下属性：


==== {{anchor|x15.11.3.1}}Error.prototype ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.3.1}}

'''Error.prototype''' 的初始值为 '''Error''' 原型对象([[#x15.3.4|15.3.4]])。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/messages.js?r{{=}}13187#1128|Set Prototype}}

此属性有以下特性： <nowiki>{ [[Writable]]: </nowiki>'''false'''<nowiki>, [[Enumerable]]: </nowiki>'''false'''<nowiki>, [[Configurable]]: </nowiki>'''false'''<nowiki> }</nowiki>。


=== {{anchor|x15.11.4}}Error 原型对象的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.4}}

'''Error'''原型对象本身是一个'''Error'''对象（其[[ES5/types#Class|<nowiki>[[Class]]</nowiki>]]为'''"Error"'''）。

'''Error'''原型对象的内部属性 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 为标准内置的 [[#x15.2.4|Object 原型对象]]。


==== {{anchor|x15.11.4.1}}Error.prototype.constructor ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.4.1}}

'''Error.prototype.constructor''' 初始值为内置的 '''Error''' 构造器。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/messages.js?r{{=}}13187#1133|Set Prototype.constructor}}


==== {{anchor|x15.11.4.2}}Error.prototype.name ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.4.2}}

'''Error.prototype.name''' 初始值为 '''"Error"'''。


==== {{anchor|x15.11.4.3}}Error.prototype.message ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.4.3}}

'''Error.prototype.message''' 初始值为空字符串。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/messages.js?r{{=}}13187#1166|Set Prototype.message}}


==== {{anchor|x15.11.4.4}}Error.prototype.toString ( ) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.4.4}}

执行以下步骤

# 令 <var>O</var> 为 '''this''' 值
# 如果 [[ES5/types#Type|Type]](<var>O</var>) 不是对象，抛出一个'''TypeError'''异常。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/messages.js?r{{=}}13187#1214|Throw TypeError}}
# 令 <var>name</var> 为以'''"name"'''为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内置方法的结果。
# 如果 <var>name</var> 为'''undefined''', 令 <var>name</var> 为 '''"Error"'''；否则令 <var>name</var> 为[[ES5/conversion#ToString|ToString]](<var>name</var>)。
# 令 <var>msg</var> 为以'''"message"'''为参数调用 <var>O</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内置方法的结果。
# 如果 <var>msg</var> 为 '''undefined'''，令 <var>msg</var> 为空字符串；否则令 <var>msg</var> 为[[ES5/conversion#ToString|ToString]](<var>msg</var>)。
# 如果 <var>name</var> 与 <var>msg</var> 都是空字符串，返回'''"Error"'''。
# 如果 <var>name</var> 为空字符串，返回 <var>msg</var>。
# 如果 <var>msg</var> 为空字符串，返回 <var>name</var>。
# 返回拼接 <var>name</var>、":"、一个空格字符，以及 <var>msg</var> 的结果。


=== {{anchor|x15.11.5}}Error实例的属性 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.5}}

'''Error''' 实例从 '''Error''' 原型对象继承属性，且它们的内部属性 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 值为'''"Error"'''。'''Error'''实例没有特殊属性。


=== {{anchor|x15.11.6}}用于本标准的内部错误类型 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.6}}
以下原生 '''Error''' 对象之一会在运行时错误发生时被抛出。所有这些对象共享同样的结构，如 [[#x15.11.7|15.11.7]] 所述。


==== {{anchor|x15.11.6.1}}EvalError ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.6.1}}
本规范现在已经不再使用这个异常，这个对象保留用于跟规范之前版本的兼容性。


==== {{anchor|x15.11.6.2}}RangeError ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.6.2}}
表示一个数值超出了允许的范围，见 [[#x15.4.2.2|15.4.2.2]], [[#x15.4.5.1|15.4.5.1]], [[#x15.7.4.2|15.7.4.2]], [[#x15.7.4.5|15.7.4.5]], [[#x15.7.4.6|15.7.4.6]], [[#x15.7.4.7|15.7.4.7]], [[#x15.9.5.43|15.9.5.43]]。


==== {{anchor|x15.11.6.3}}ReferenceError ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.6.3}}

表示一个不正确的引用值被检测到。见 [[ES5/types#x8.7.1|8.7.1]], [[ES5/types#x8.7.2|8.7.2]], [[ES5/execution#x10.2.1|10.2.1]], [[ES5/execution#x10.2.1.1.4|10.2.1.1.4]], [[ES5/execution#x10.2.1.2.4|10.2.1.2.4]], [[ES5/execution#x11.13.1|11.13.1]]。


==== {{anchor|x15.11.6.4}}SyntaxError ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.6.4}}
表示一个解析错误发生。见 [[ES5/expressions#x11.1.5|11.1.5]], [[ES5/expressions#x11.3.1|11.3.1]], [[ES5/expressions#x11.3.2|11.3.2]], [[ES5/expressions#x11.4.1|11.4.1]], [[ES5/expressions#x11.4.4|11.4.4]], [[ES5/expressions#x11.4.5|11.4.5]], [[ES5/expressions#x11.13.1|11.13.1]], [[ES5/expressions#x11.13.2|11.13.2]], [[ES5/statements#x12.2.1|12.2.1]], [[ES5/statements#x12.10.1|12.10.1]], [[ES5/statements#x12.14.1|12.14.1]], [[ES5/functions#x13.1|13.1]], [[ES5/builtins#x15.1.2.1|15.1.2.1]], [[ES5/builtins#x15.3.2.1|15.3.2.1]], [[ES5/builtins#x15.10.2.2|15.10.2.2]], [[ES5/builtins#x15.10.2.5|15.10.2.5]], [[ES5/builtins#x15.10.2.9|15.10.2.9]], [[ES5/builtins#x15.10.2.15|15.10.2.15]], [[ES5/builtins#x15.10.2.19|15.10.2.19]], [[ES5/builtins#x15.10.4.1|15.10.4.1]], [[ES5/builtins#x15.12.2|15.12.2]]。


==== {{anchor|x15.11.6.5}}TypeError ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.6.5}}
表示一个操作数的真实类型与期望类型不符。见 [[ES5/types#x8.6.2|8.6.2]], [[ES5/types#x8.7.2|8.7.2]], [[ES5/types#x8.10.5|8.10.5]], [[ES5/types#x8.12.5|8.12.5]], [[ES5/types#x8.12.7|8.12.7]], [[ES5/types#x8.12.8|8.12.8]], [[ES5/types#x8.12.9|8.12.9]], [[ES5/conversion#x9.9|9.9]], [[ES5/conversion#x9.10|9.10]], [[ES5/execution#x10.2.1|10.2.1]], [[ES5/execution#x10.2.1.1.3|10.2.1.1.3]], [[ES5/execution#x10.6|10.6]], [[ES5/expressions#x11.2.2|11.2.2]], [[ES5/expressions#x11.2.3|11.2.3]], [[ES5/expressions#x11.4.1|11.4.1]], [[ES5/expressions#x11.8.6|11.8.6]], [[ES5/expressions#x11.8.7|11.8.7]], [[ES5/expressions#x11.3.1|11.3.1]], [[ES5/functions#x13.2|13.2]], [[ES5/functions#x13.2.3|13.2.3]], [[ES5/builtins#x15|15]], [[ES5/builtins#x15.2.3.2|15.2.3.2]], [[ES5/builtins#x15.2.3.3|15.2.3.3]], [[ES5/builtins#x15.2.3.4|15.2.3.4]], [[ES5/builtins#x15.2.3.5|15.2.3.5]], [[ES5/builtins#x15.2.3.6|15.2.3.6]], [[ES5/builtins#x15.2.3.7|15.2.3.7]], [[ES5/builtins#x15.2.3.8|15.2.3.8]], [[ES5/builtins#x15.2.3.9|15.2.3.9]], [[ES5/builtins#x15.9.5.44|15.9.5.44]], [[ES5/builtins#x15.2.3.11|15.2.3.11]], [[ES5/builtins#x15.2.3.12|15.2.3.12]], [[ES5/builtins#x15.2.3.13|15.2.3.13]], [[ES5/builtins#x15.2.3.14|15.2.3.14]], [[ES5/builtins#x15.2.4.3|15.2.4.3]], [[ES5/builtins#x15.3.4.2|15.3.4.2]], [[ES5/builtins#x15.3.4.3|15.3.4.3]], [[ES5/builtins#x15.3.4.4|15.3.4.4]], [[ES5/builtins#x15.3.4.5|15.3.4.5]], [[ES5/builtins#x15.3.4.5.2|15.3.4.5.2]], [[ES5/builtins#x15.3.4.5.3|15.3.4.5.3]], [[ES5/builtins#x15.3.5|15.3.5]], [[ES5/builtins#x15.3.5.3|15.3.5.3]], [[ES5/builtins#x15.3.5.4|15.3.5.4]], [[ES5/builtins#x15.4.4.3|15.4.4.3]], [[ES5/builtins#x15.4.4.11|15.4.4.11]], [[ES5/builtins#x15.4.4.16|15.4.4.16]], [[ES5/builtins#x15.4.4.17|15.4.4.17]], [[ES5/builtins#x11.4.1|11.4.1]], [[ES5/builtins#x15.4.4.19|15.4.4.19]], [[ES5/builtins#x15.4.4.20|15.4.4.20]], [[ES5/builtins#x15.4.4.21|15.4.4.21]], [[ES5/builtins#x15.4.4.22|15.4.4.22]], [[ES5/builtins#x15.4.5.1|15.4.5.1]], [[ES5/builtins#x15.5.4.2|15.5.4.2]], [[ES5/builtins#x15.5.4.3|15.5.4.3]], [[ES5/builtins#x15.6.4.2|15.6.4.2]], [[ES5/builtins#x15.6.4.3|15.6.4.3]], [[ES5/builtins#x15.7.4|15.7.4]], [[ES5/builtins#x15.7.4.2|15.7.4.2]], [[ES5/builtins#x15.7.4.4|15.7.4.4]], [[ES5/builtins#x15.7.4.8|15.7.4.8]], [[ES5/builtins#x15.9.5|15.9.5]], [[ES5/builtins#x15.9.5.44|15.9.5.44]], [[ES5/builtins#x15.10.4.1|15.10.4.1]], [[ES5/builtins#x15.10.6|15.10.6]], [[ES5/builtins#x15.11.4.4|15.11.4.4]], [[ES5/builtins#x15.12.3|15.12.3]]。


==== {{anchor|x15.11.6.6}}URIError ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.6.6}}

表示全局 URI 处理函数被以不符合其定义的方式使用。见 [[ES5/builtins#x15.1.3|15.1.3]]。


=== {{anchor|x15.11.7}}NativeError对象结构 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7}}
当 ECMAScript 实现探测到一个运行时错误时，它抛出一个 [[ES5/builtins#x15.11.6|15.11.6]] 所定义的 '''NativeError''' 对象的实例。每个这些对象都有如下所述结构，不同仅仅是在 <var>name</var> 属性中以构造器名称替换掉 '''NativeError'''，以及原型对象由实现自定义的 <var>message</var> 属性。

对于每个错误对象，定义中到 '''NativeError''' 的引用应当用 [[ES5/builtins#x15.11.6|15.11.6]] 中具体的对象名替换。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/messages.js?r{{=}}13202#212|IsNativeError}}


==== {{anchor|x15.11.7.1}}NativeError构造器作为函数调用 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7.1}}
当 '''NativeError''' 被作为函数而不是构造器调用时，它创建并初始化一个新的 '''NativeError''' 对象。这样函数调用 '''NativeError(…)''' 与同样参数的对象创建表达式 '''new NativeError(…)''' 是等效的。


==== {{anchor|x15.11.7.2}}NativeError (message) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7.2}}
新构造的对象内部属性 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 会被设为这一错误构造器附带的原型对象。（[[ES5/builtins#15.11.3.1|15.11.3.1]]）

新构造的对象内部属性 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 会被设为 '''"Error"'''。

新构造的对象内部属性 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 会被设为 '''true'''。

如果形参 <var>message</var> 不是 '''undefined'''，新构造的对象本身属性 <var>message</var> 则被设为[[ES5/conversion#ToString|ToString]](message)。


==== {{anchor|x15.11.7.3}}NativeError构造器 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7.3}}

当 '''NativeError''' 作为 '''new''' 表达式的一部分被调用时，它是一个构造器：它初始化新创建的对象。


==== {{anchor|x15.11.7.4}}New NativeError (message) ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7.4}}
新构造的对象内部属性[[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]]会被设为这一错误构造器附带的原型对象。([[ES5/builtins#15.11.3.1|15.11.3.1]])

新构造的对象内部属性[[ES5/types#Class|<nowiki>[[Class]]</nowiki>]]会被设为 '''"Error"'''。

新构造的对象内部属性[[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]]会被设为 '''true'''。

如果形参 <var>message</var> 不是'''undefined'''，新构造的对象本身属性 <var>message</var> 则被设为[[ES5/conversion#ToString|ToString]](<var>message</var>)。


==== {{anchor|x15.11.7.5}}NativeError构造器的属性 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7.5}}

'''NativeError'''构造器的内部属性[[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]]值为'''Function'''原型对象([[ES5/builtins#x15.3.4|15.3.4]])。

除内部属性和 '''length''' 属性（其值为'''1'''）以外，'''Error'''构造器还有以下属性：


==== {{anchor|x15.11.7.6}}NativeError.prototype ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7.6}}

'''NativeError.prototype''' 的初始值为一个 '''Error'''([[ES5/builtins#x15.11.4|15.11.4]])。

此属性有以下特性： <nowiki>{ [[Writable]]: </nowiki>'''false'''<nowiki>, [[Enumerable]]: </nowiki>'''false'''<nowiki>, [[Configurable]]: </nowiki>'''false'''<nowiki> }</nowiki>。


==== {{anchor|x15.11.7.7}}NativeError原型对象的属性 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7.7}}

每个 '''NativeError''' 的 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 的初始值为一个 '''Error'''（其[[ES5/types#Class|<nowiki>[[Class]]</nowiki>]]为'''"Error"'''）。

'''NativeError''' 原型对象的内部属性 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 为标准内置的 '''Error''' 对象([[ES5/builtins#x15.2.4|15.2.4]])。


==== {{anchor|x15.11.7.8}}NativeError.prototype.constructor ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7.8}}

对于特定的 '''NativeError'''，其 '''Error.prototype.constructor''' 初始值为 '''NativeError''' 构造器本身。


==== {{anchor|x15.11.7.9}}NativeError.prototype.name ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7.9}}

对于特定的 '''NativeError，Error.prototype.name''' 初始值为构造器的名字。


==== {{anchor|x15.11.7.10}}NativeError.prototype.message ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7.10}}

对于特定的 '''NativeError，NativeError.prototype.message''' 初始值为空字符串。


==== {{anchor|x15.11.7.11}}NativeError 实例的属性 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.11.7.11}}

'''NativeError''' 实例从 '''NativeError''' 原型对象继承属性，且它们的内部属性 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 值为 '''"Error"'''。'''Error''' 实例没有特殊属性。


== {{anchor|x15.12}}JSON 对象 ==
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.12}}
{{test262|http://hg.ecmascript.org/tests/test262/file/f2b232b08824/test/suite/ch15/15.12}}
'''JSON''' 对象是一个单一的对象，它包含两个函数，'''parse''' 和 '''stringify'''，是用于解析和构造 '''JSON''' 文本的。'''JSON''' 数据的交换格式在 [http://www.ietf.org/rfc/rfc4627.txt RFC4627] 里进行了描述。本规范里面的 '''JSON''' 交换格式会使用 [http://www.ietf.org/rfc/rfc4627.txt RFC4627] 里所描述的，以下两点除外：

* ECMAScript '''JSON''' 文法中的顶级 ''{{toanchor|JSONText}}'' 产生式是由 ''{{toanchor|JSONValue}}'' 构成，而不是 [http://www.ietf.org/rfc/rfc4627.txt RFC4627] 中限制成的 ''{{toanchor|JSONObject}}'' 或者 ''{{toanchor|JSONArray}}''。
* 确认 '''JSON.parse''' 和 '''JSON.stringify''' 的实现，它们必须准确的支持本规范描述的交换格式，而不允许对格式进行删除或扩展。这一点要区别于 [http://www.ietf.org/rfc/rfc4627.txt RFC4627]，它允许 '''JSON''' 解析器接受 '''non-JSON''' 的格式和扩展。

'''JSON''' 对象内部属性 [[ES5/types#Prototype|<nowiki>[[Prototype]]</nowiki>]] 的值是标准内建的 '''Object''' 原型对象（[[ES5/builtins#properties-of-the-object-prototype-object|15.2.4]]）。内部属性 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 的值是 '''"JSON"'''。内部属性 [[ES5/types#Extensible|<nowiki>[[Extensible]]</nowiki>]] 的值设置为 '''true'''。

'''JSON''' 对象没有内部属性 [[ES5/types#Construct|<nowiki>[[Construct]]</nowiki>]]；不能把 '''JSON''' 对象当作构造器来使用 '''new''' 操作符。

'''JSON''' 对象没有内部属性 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]]；不能把 '''JSON''' 对象当作函数来调用。


=== {{anchor|x15.12.1}}JSON 语法 ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.12.1}}

'''JSON.stringify''' 会产生一个符合 '''JSON''' 语法的字符串。'''JSON.parse''' 接受的是一个符合 '''JSON''' 语法的字符串。


==== {{anchor|x15.12.1.1}}JSON 词法 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.12.1.1}}

类似于 ECMAScript 源文本，'''JSON''' 是由一系列符合 [[ES5#SourceCharacter|''SourceCharacter'']] 规则的字符构成的。'''JSON''' 词法定义的 [[ES5/lexical#Token|Token]] 使得 '''JSON''' 文本类似于 ECMAScript 词法定义的 [[ES5/lexical#Token|Token]] 得到的 ECMAScript 源文本。'''JSON''' 词法仅能识别由 [[#JSONWhiteSpace|JSONWhiteSpace]] 产生式得到的空白字符。在语法上，所有非终止符均不是由 '''"JSON"''' 字符开始，而是由 ECMAScript 词法产生式定义的。

语法

    ''<b id="JSONWhiteSpace">JSONWhiteSpace</b>'' :: {{extra note||BOM不能作为JSON的空白字符，所以服务器生成JSON时候注意清除BOM。}}
        <TAB>
        <CR>
        <LF>
        <SP>

    ''<b id="JSONString">JSONString</b>'' ::
        '''"''' ''[[#JSONStringCharacters|JSONStringCharacters]]''{{opt}} '''"'''

    ''<b id="JSONStringCharacters">JSONStringCharacters</b>'' ::
        ''[[#JSONStringCharacter|JSONStringCharacter]]'' ''[[#JSONStringCharacters|JSONStringCharacters]]''{{opt}}

    ''<b id="JSONStringCharacter">JSONStringCharacter</b>'' ::
        [[ES5#SourceCharacter|''SourceCharacter'']] '''but not " or \ U+0000 or through U+001F'''
        '''\''' ''[[#JSONEscapeSequence|JSONEscapeSequence]]''

    ''<b id="JSONEscapeSequence">JSONEscapeSequence</b>'' ::
        ''[[#JSONEscapeCharacter|JSONEscapeCharacter]]''
        ''[[ES5/lexical#UnicodeEscapeSequence|''UnicodeEscapeSequence'']]''

    ''<b id="JSONEscapeCharacter">JSONEscapeCharacter</b>'' :: 以下之一 
        '''"''' '''/''' '''\''' '''b''' '''f''' '''n''' '''r''' '''t'''

    ''<b id="JSONNumber">JSONNumber</b>'' ::
        '''-'''{{opt}} [[ES5/lexical#DecimalIntegerLiteral|''DecimalIntegerLiteral'']] ''[[#JSONFraction|JSONFraction]]''{{opt}} [[ES5/lexical#ExponentPart|''ExponentPart'']]{{opt}}

    ''<b id="JSONFraction">JSONFraction</b>'' ::
        '''.''' [[ES5/lexical#DecimalDigits|''DecimalDigits'']]

    ''<b id="JSONNullLiteral">JSONNullLiteral</b>'' ::
        [[ES5/lexical#NullLiteral|''NullLiteral'']]

    ''<b id="JSONBooleanLiteral">JSONBooleanLiteral</b>'' ::
        [[ES5/lexical#BooleanLiteral|''BooleanLiteral'']]


==== {{anchor|x15.12.1.2}}JSON 句法 ====
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.12.1.2}}

根据 '''JSON''' 词法定义的 [[ES5/lexical#Token|Token]]，'''JSON''' 句法定义了一个合法的 '''JSON''' 文本。语法的目标符号是 '''JSONText'''。

语法 

    ''<b id="JSONText">JSONText</b>'' :
        ''[[#JSONValue|JSONValue]]''

    ''<b id="JSONValue">JSONValue</b>'' :
        [[#JSONNullLiteral|''JSONNullLiteral'']]
        [[#JSONBooleanLiteral|''JSONBooleanLiteral'']]
        ''[[#JSONObject|JSONObject]]''
        ''[[#JSONArray|JSONArray]]''
        [[#JSONString|''JSONString'']]
        [[#JSONNumber|''JSONNumber'']]

    ''<b id="JSONObject">JSONObject</b>'' :
        '''{''' '''}'''
        '''{''' ''[[#JSONMemberList|JSONMemberList]]'' '''}'''

    ''<b id="JSONMember">JSONMember</b>'' :
        [[#JSONString|''JSONString'']] ''':''' ''[[#JSONValue|JSONValue]]''

    ''<b id="JSONMemberList">JSONMemberList</b>'' :
        ''[[#JSONMember|JSONMember]]''
        ''[[#JSONMemberList|JSONMemberList]]'' ''',''' ''[[#JSONMember|JSONMember]]''

    ''<b id="JSONArray">JSONArray</b>'' :
        '''[''' ''']'''
        '''[''' ''[[#JSONElementList|JSONElementList]]'' ''']'''

    ''<b id="JSONElementList">JSONElementList</b>'' :
        ''[[#JSONValue|JSONValue]]''
        ''[[#JSONElementList|JSONElementList]]'' ''',''' ''[[#JSONValue|JSONValue]]''


=== {{anchor|x15.12.2}}parse ( text [ , reviver ] ) ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.12.2}}

'''parse''' 函数解析一段 '''JSON''' 文本（'''JSON''' 格式字符串），生成一个 ECMAScript 值。'''JSON''' 格式是ECMAScript直接量的受限模式。'''JSON''' 对象可以被理解为 ECMAScript 对象。'''JSON''' 数组可以被理解为 ECMAScript 数组。'''JSON''' 的字符串、数字、布尔值以及 '''null''' 可以被认为是 ECMAScript 字符串、数字、布尔值以及 '''null'''。'''JSON''' 使用受限更多的空白字符集合，并且允许 Unicode 码点 '''U+2028''' 和 '''U+2029'''直 接出现在 '''JSONString''' 直接量当中而无需使用转义序列。解析流程与 [[ES5/expressions#x11.1.4|11.1.4]] 和 [[ES5/expressions#x11.1.5|11.1.5]] 一样，但是由 '''JSON''' 语法限定。

可选参数 <var>reviver</var> 是一个接受两个参数的函数（<var>key</var> 和 <var>value</var>）。它可以过滤和转换结果。它在每个 '''key/value''' 对产生时被调用，它的返回值可以用于替代原本的值。如果它原样返回接收到的，那么结构不会被改变。如果它返回 '''undefined'''，那么属性会被从结果中删除。

# 令 <var>JText</var> 为 [[ES5/conversion#ToString|ToString]](<var>text</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/json.js?r{{=}}13202#56|ToString}}
# 以 [[ES5/builtins#x15.12.1|15.12.1]] 所述语法解析 <var>JText</var>。如果 <var>JText</var> 不能以 '''JSON''' 语法解析成 ''[[#JSONText|JSONText]]''，则抛出 '''SyntaxError''' 异常。
# 令 <var>unfiltered</var> 为按 ECMAScript 程序（但是用 ''[[#JSONString|JSONString]]'' 替换 ''[[ES5/lexical#StringLiteral|StringLiteral]]''）解析和执行 <var>JText</var> 的结果。注因 <var>JText</var> 符合'''JSON'''语法，这个结果要么是原始值类型要么是 ''[[ES5/expressions#inlineArrayLiteral|inlineArrayLiteral]]'' 或者 ''[[ES5/expressions#inlineObjectLiteral|ObjectLiteral]]'' 所定义的对象。
# 若 [[ES5/conversion#IsCallable|IsCallable]](<var>reviver</var>) 为 '''true''' 则
## 令 <var>root</var> 为由表达式 '''new Object()''' 创建的新对象，其中 '''Object''' 是以 '''Object''' 为名的标准内置的构造器。
## 以空字符串和属性描述 {<nowiki>[[Value]]</nowiki>: <var>unfiltered</var>, <nowiki>[[Writable]]</nowiki>: '''true''', <nowiki>[[Enumerable]]</nowiki>: '''true''', <nowiki>[[Configurable]]</nowiki>: '''true'''} 和 '''false''' 为参数调用 '''root''' 的 ''[[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]]'' 内置方法。
## 返回传入 <var>root</var> 和空字符串为参数调用抽象操作 [[#JSON-Walk|Walk]] 的结果，抽象操作 [[#JSON-Walk|Walk]] 如下文所定义。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/json.js?r{{=}}13202#58|ToString}}
# 否则，返回 <var>unfiltered</var>。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/json.js?r{{=}}13202#60|unfiltered}}

{{anchor|JSON-Walk}}抽象操作 '''Walk''' 是一个递归的抽象操作，它接受两个参数：一个 <var>holder</var> 对象和一个表示该对象的属性名的 '''String''' <var>name</var> 。'''Walk''' 使用最开始被传入 '''parse''' 函数的 <var>reviver</var> 的值。

# 令 <var>val</var> 为以参数 <var>name</var> 调用 <var>holder</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
# 若 <var>val</var> 为对象，则
## 若 <var>val</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性为 '''"Array"'''
### 设 <var>I</var> 为 '''0'''。
### 令 <var>len</var> 为以参数 '''"length"''' 调用 <var>val</var> 的 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]] 内部方法的结果。
### 当 <var>I</var> < <var>len</var> 时重复
#### 令 <var>newElement</var> 为调用抽象操作 [[#JSON-Walk|Walk]] 的结果，传入 <var>val</var> 和 [[ES5/conversion#ToString|ToString]](<var>I</var>) 为参数。
#### 若 <var>newElement</var> 为 '''undefined'''，则
##### 以 [[ES5/conversion#ToString|ToString]](<var>I</var>) 和 '''false''' 做参数，调用 <var>val</var> 的内部方法 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]]。
##### 否则，以[[ES5/conversion#ToString|ToString]](<var>I</var>)，属性描述 {<nowiki>[[Value]]</nowiki>: <var>newElement</var>, <nowiki>[[Writable]]</nowiki>: '''true''', <nowiki>[[Enumerable]]</nowiki>: '''true''', <nowiki>[[Configurable]]</nowiki>: '''true'''} 以及 '''false''' 做参数调用 <var>val</var> 的内部方法[[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]]。
#### 对 <var>I</var> 加 '''1'''。
## 否则
### 令 <var>keys</var> 为包含 <var>val</var> 所有的具有 [[ES5/types#Enumerable|<nowiki>[[Enumerable]]</nowiki>]] 特征的属性名 '''String''' 值的内部类型 [[ES5/types#List|List]]。字符串的顺序应当与内置函数 [[#x15.2.3.14|Object.keys]] 一致。
### 对每个 <var>keys</var> 中的字符串 <var>P</var> 做以下操作
#### 令 <var>newElement</var> 为调用抽象操作 [[#JSON-Walk|Walk]] 的结果，传入 <var>val</var> 和 <var>P</var> 为参数。
#### 若 <var>newElement</var> 为 '''undefined'''，则
##### 以 <var>P</var> 和 '''false''' 做参数，调用 <var>val</var> 的内部方法 [[ES5/types#Delete|<nowiki>[[Delete]]</nowiki>]]。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/json.js?r{{=}}13202#44|Delete}}
##### 否则，以 <var>P</var>，属性描述{<nowiki>[[Value]]</nowiki>: <var>newElement</var>, <nowiki>[[Writable]]</nowiki>: '''true''', <nowiki>[[Enumerable]]</nowiki>: '''true''', <nowiki>[[Configurable]]</nowiki>: '''true'''} 和 '''false''' 做参数调用调用 <var>val</var> 的内部方法 [[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]]。
#返回传入 <var>holder</var> 作为 '''this''' 值以及以 <var>name</var> 和 <var>val</var> 构成的参数列表调用 <var>reviver</var> 的[[ES5/types#Call|<nowiki>[[Call]]</nowiki>]]内部属性的结果。

实现不允许更改 '''JSON.parse''' 的实现以扩展 '''JSON''' 语法。如果一个实现想要支持更改或者扩展过的 '''JSON''' 交换格式它必须以定义一个不同的 '''parse''' 函数的方式做这件事。

{{note|在对象中存在同名字符串的情况下，同一 '''''key''''' 的值会被按照文本顺序覆盖掉。{{extra note||直接覆盖掉，不会为被覆盖掉的键值调用reviver。}}}}


=== {{anchor|x15.12.3}}stringify ( value [ , replacer [ , space ] ] ) ===
{{eng ver|http://ecma-international.org/ecma-262/5.1/#sec-15.12.3}}

'''stringify''' 函数返回一个 '''JSON''' 格式的字符串，用以表示一个ECMAScript值。它可以接受三个参数。第一个参数是必选的。<var>value</var> 参数是一个ECMAScript 值，它通常是对象或者数组，尽管它也可以是 '''String'''、'''Boolean'''、'''Number''' 或者是 '''null'''。可选的 <var>replacer</var> 参数要么是个可以修改对象和数组字符串化的方式的函数，要么是个扮演选择对象字符串化的属性的白名单这样的角色的 '''String''' 和 '''Number''' 组成的数组。可选的 <var>space</var> 参数是一个 '''String''' 或者 '''Number'''，可以允许结果中插入空白符以改善人类可读性。 {{v8|https://github.com/v8/v8/blob/3.22/src/json.js#L188|普通实现}} {{v8|https://github.com/v8/v8/blob/3.22/src/json-stringifier.h#L268|优化实现}}

以下为字符串化一对象的步骤：

# 令 <var>stack</var> 为空 [[ES5/types#List|List]]。
# 令 <var>indent</var> 为空 '''String'''。
# 令 <var>PropertyList</var> 和 <var>ReplacerFunction</var> 为 '''undefined'''。
# 若 [[ES5/types#Type|Type]](<var>replacer</var>) 为 '''Object'''，则
## 若 [[ES5/conversion#IsCallable|IsCallable]](<var>replacer</var>) 为 '''true'''，则
### 令 <var>ReplacerFunction</var> 为 <var>replacer</var>
## 否则若 <var>replacer</var> 的内部属性 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 为 '''"Array"'''，则
### 令 <var>PropertyList</var> 为一空内部类型 [[ES5/types#List|List]]
### 对于所有名是数组下标的 <var>replacer</var> 的属性 <var>v</var>。以数组下标递增顺序枚举属性
#### 令 <var>item</var> 为'''undefined'''
####  若 [[ES5/types#Type|Type]](<var>v</var>) 为 '''String''' 则令 <var>item</var> 为 <var>v</var>。
#### 否则若 [[ES5/types#Type|Type]](<var>v</var>) 为 '''Number''' 则令 <var>item</var> 为 [[ES5/conversion#ToString|ToString]](<var>v</var>)。
#### 否则若 [[ES5/types#Type|Type]](<var>v</var>) 为 '''Object''' 则，
##### 若 <var>v</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性为 '''"String"''' 或 '''"Number"''' 则令 <var>item</var> 为[[ES5/conversion#ToString|ToString]](<var>v</var>)。
#### 若 <var>item</var> 不是 '''undefined''' 且 <var>item</var> 不是 <var>PropertyList</var> 的元素。
##### 把 <var>item</var> 添加到 <var>PropertyList</var> 中。
# 若 [[ES5/types#Type|Type]](<var>space</var>) 为 '''Object''' 则，
## 若 <var>space</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性为 '''"Number"''' 则，
### 令 <var>space</var> 为 [[ES5/conversion#ToNumber|ToNumber]](<var>space</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/json.js?r{{=}}13202#188|ToNumber}}
## 否则若 <var>space</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性为 '''"String"''' 则，
### 令 <var>space</var> 为 [[ES5/conversion#ToString|ToString]](<var>space</var>)。{{v8|http://code.google.com/p/v8/source/browse/trunk/src/json.js?r{{=}}13202#190|ToString}}
# 若 [[ES5/types#Type|Type]](<var>space</var>) 为 '''Number'''。
## 令 <var>space</var> 为 [[ES5/builtins#x15.8.2.12|min]]('''10''', [[ES5/conversion#ToInteger|ToInteger]](<var>space</var>))。
## 设 <var>gap</var> 为一包含 <var>space</var> 个空格的 '''String'''。这将会是空 '''String''' 加入 <var>space</var> 小于'''1'''。
# 否则若 [[ES5/types#Type|Type]](<var>space</var>) 为'''String'''
## 若 <var>space</var> 中字符个数为 '''10''' 或者更小，设 <var>gap</var> 为 <var>space</var>，否则设 <var>gap</var> 为包含前 '''10''' 个 <var>space</var> 中字符的字符串。
# 否则设 <var>gap</var> 为空 '''String'''。
# 令 <var>wrapper</var> 为一个如同以表达式 '''new Object()''' 创建的新对象，其中 '''Object''' 是这个名字的标准内置构造器。
# 以参数空 '''String'''，属性描述{<nowiki>[[Value]]</nowiki>: <var>value</var>, <nowiki>[[Writable]]</nowiki>: '''true''', <nowiki>[[Enumerable]]</nowiki>: '''true''', <nowiki>[[Configurable]]</nowiki>: '''true'''} 和 '''false''' 调用 <var>wrapper</var> 的[[ES5/types#DefineOwnProperty|<nowiki>[[DefineOwnProperty]]</nowiki>]]内部方法。
#返回以空 '''String''' 和 <var>wrapper</var> 调用抽象方法 [[#JSON-Str|Str]] 的结果。


{{anchor|JSON-Str}}抽象操作 '''Str'''(<var>key</var>, <var>holder</var>) 可以访问调用它的 '''stringify''' 方法中的 <var>ReplacerFunction</var>。其算法如下：{{v8|https://github.com/v8/v8/blob/3.22/src/json.js#L149|}}
# 令 <var>value</var> 为以 <var>key</var> 为参数调用 <var>holder</var> 的内部方法[[ES5/types#Get|<nowiki>[[Get]]</nowiki>]]。
# 若 [[ES5/types#Type|Type]](<var>value</var>) 为 '''Object'''，则 {{extra note||虽然一般的对象并没有自带toJSON（除了Date对象），但是在调用JSON.stringify时总是会尝试调用toJSON。}} {{v8|https://github.com/v8/v8/blob/3.22/src/json.js#L151|}}
## 令 <var>toJSON</var> 为以 '''"toJSON"''' 为参数调用 <var>value</var> 的内部方法 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]]。
## 若 [[ES5/conversion#IsCallable|IsCallable]](<var>toJSON</var>) 为 '''true'''
### 令 <var>value</var> 为以调用 <var>toJSON</var> 的内部方法 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 的结果，传入 <var>value</var> 为'''this'''值以及由 <var>key</var> 构成的参数列表。
# 若 <var>ReplacerFunction</var> 不为 '''undefined''',则
## 令 <var>value</var> 为以调用 <var>ReplacerFunction</var> 的内部方法 [[ES5/types#Call|<nowiki>[[Call]]</nowiki>]] 的结果，传入 <var>holder</var> 为 '''this''' 值以及由 <var>key</var> 和 <var>value</var> 构成的参数列表。
# 若 [[ES5/types#Type|Type]](<var>value</var>) 为 '''Object''' 则，
## 若 <var>value</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性为 '''"Number"''' 则，
### 令 <var>value</var> 为[[ES5/conversion#ToNumber|ToNumber]](<var>value</var>)。
## 否则若 <var>value</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性为 '''"String"''' 则，
### 令 <var>value</var> 为 [[ES5/conversion#ToString|ToString]](<var>value</var>)
## 否则若 <var>value</var> 的 [[ES5/types#Class|<nowiki>[[Class]]</nowiki>]] 内部属性为 '''"Boolean"''' 则，
### 令 <var>value</var> 为 <var>value</var> 的 [[ES5/types#PrimitiveValue|<nowiki>[[PrimitiveValue]]</nowiki>]] 内部属性值
# 若 <var>value</var> 为 '''null''' 则 返回 '''"null"'''。
# 若 <var>value</var> 为 '''true''' 则 返回 '''"true"'''。
# 若 <var>value</var> 为 '''false''' 则 返回 '''"false"'''。
# 若 [[ES5/types#Type|Type]](<var>value</var>) 为 '''String'''，则返回以value调用[[#JONS-Quote|Quote]]抽象操作的结果。
# 若 [[ES5/types#Type|Type]](<var>value</var>) 为 '''Number'''
## 若 <var>value</var> 是有限的数字则 返回 [[ES5/conversion#ToString|ToString]](<var>value</var>)。
## 否则，返回 '''"null"'''。
# 若 [[ES5/types#Type|Type]](<var>value</var>) 为 '''Object''' 且 [[ES5/conversion#IsCallable|IsCallable]](<var>value</var>) 为 '''false'''
## 若 <var>value</var> 的[[ES5/types#Class|<nowiki>[[Class]]</nowiki>]]内部属性为 '''"Array"''' 则
### 返回以 <var>value</var> 为参数调用抽象方法 [[#JSON-JA|JA]] 的结果。
## 否则，返回以 <var>value</var> 为参数调用抽象方法 [[#JSON-JO|JO]] 的结果。
# 返回 '''undefined'''。


{{anchor|Quote}}抽象操作 '''Quote'''(<var>value</var>) 将一个 '''String''' 值封装在双引号中，并且对其中的字符转义。{{v8|https://github.com/v8/v8/blob/3.22/src/runtime.cc#L6186|}}

# 令 <var>product</var> 为双引号字符。
# 对 <var>value</var> 中的每一个字符 <var>C</var>
## 若 <var>C</var> 为双引号字符或者反斜杠字符
### 令 <var>product</var> 为 <var>product</var> 和反斜杠连接的结果。
### 令 <var>product</var> 为 <var>product</var> 与 <var>C</var> 的连接。
## 否则若 <var>C</var> 为退格符、换页符、换行符、回车符或制表符
### 令 <var>product</var> 为 <var>product</var> 与反斜杠字符的连接。
### 令 <var>abbrev</var> 为如下表所示 <var>C</var> 对应的字符:<br/>退格符 '''"b"'''<br/>换页符 '''"f"'''<br/>换行符 '''"n"'''<br/>回车符 '''"r"'''<br/>制表符 '''"t"'''
### 令 <var>product</var> 为 <var>product</var> 与 <var>abbrev</var> 的连接。
## 否则若 <var>C</var> 为代码值小于空白字符 {{extra note||也就是ASCII小于32的字符。}} 的控制字符。
### 令 <var>product</var> 为 <var>product</var> 与反斜杠字符的连接。
### 令 <var>product</var> 为 <var>product</var> 与 '''"u"''' 的连接。
### 令 <var>hex</var> 为转换 <var>C</var> 代码值按十六进制转换到四位字符串的结果。
### 令 <var>product</var> 为 <var>product</var> 与 <var>hex</var> 的连接。
## 否则
### 令 <var>product</var> 为 <var>product</var> 与 <var>C</var> 的连接。
# 令 <var>product</var> 为 <var>product</var> 与双引号字符的连接。
# 返回 <var>product</var>。


{{anchor|JOSN-JO}}抽象操作 '''JO'''(<var>value</var>) 序列化一个对象，它可以访问调用它的方法中的 <var>stack</var>、<var>indent</var>、<var>gap</var>、<var>PropertyList</var>、<var>ReplacerFunction</var> 以及 <var>space</var> {{bug||此抽象算法并不需要访问 space 变量。}}。 {{v8|https://github.com/v8/v8/blob/3.22/src/json.js#L101|}}

# 若 <var>stack</var> 包含 <var>value</var>，则抛出一个'''TypeError'''，因为对象结构中存在循环。 {{question||为什么此处对循环结构判断不在Str中执行，而要在JO和JA中分别重复定义呢？}}
# 将 <var>value</var> 添加到 <var>stack</var>。 {{question||为什么此处对stack操作不在Str中执行，而要在JO和JA中分别重复定义呢？}}
# 令 <var>stepback</var> 为 <var>indent</var>。
# 令 <var>indent</var> 为 <var>indent</var> 与 <var>gap</var> 的连接。
# 若 <var>PropertyList</var> 不为 '''undefined''' 则
## 令 <var>K</var> 为 <var>PropertyList</var>
# 否则
## 令 <var>K</var> 为 <var>value</var> 上所有 [[ES5/types#Enumerable|<nowiki>[[Enumerable]]</nowiki>]] 特性为 '''true''' 的自身属性名构成的内部字符串列表。其顺序应该和 [[#x15.2.3.14|Object.keys]] 标准内置函数得到的顺序相同。
# 令 <var>partial</var> 为空 [[ES5/types#List|List]]。
# 对于 <var>K</var> 的每一个元素 <var>P</var>
## 令 <var>strP</var> 为以 <var>P</var> 和 <var>value</var> 为参数调用抽象操作 <var>Str</var> 的结果。
## 若 <var>strP</var> 没有被定义
### 令 <var>member</var> 为以 <var>P</var> 为参数调用抽象操作P的结果。
### 令 <var>member</var> 为 <var>member</var> 与冒号字符的连接。
### 若 <var>gap</var> 不为空 '''String'''。
#### 令 <var>member</var> 为 <var>member</var> 与空格字符 {{bug||原文中此处的 space 为斜体应该是错误的。此处的 space 指的应该是空格字符而不是先前的 space 变量。}} 的连接。
### 令 <var>member</var> 为 <var>member</var> 与 <var>strP</var> 的连接。
### 将 <var>member</var> 添加到 <var>partial</var>。
# 若 <var>partial</var> 为 <var>empty</var>，则
## 令 <var>final</var> 为 '''"{}"'''。
# 否则
## 若 <var>gap</var> 为空 '''String'''
### 令 <var>properties</var> 为一个连接所有 <var>partial</var> 中的字符串而成的字符串，键值对之间用逗号分隔。第一个字符串之前和最后一个字符串之后没有逗号。
### 令 <var>final</var> 为连接 '''"{"'''、<var>properties</var>、和 '''"}"''' 的结果。
## 否则 <var>gap</var> 不是空 '''String'''
### 令 <var>separator</var> 为连接 逗号字符，换行字符以及 <var>indent</var> 而成的字符串。
### 令 <var>properties</var> 为一个连接所有 <var>partial</var> 中的字符串而成的字符串，键值对之间用 <var>separator</var> 分隔。第一个字符串之前和最后一个字符串之后没有 <var>separator</var>。
### 令 <var>final</var> 为连接 '''"{"'''、换行符、<var>indent</var>、<var>properties</var>、换行符、<var>stepback</var> 和 '''"}"''' 的结果。
# 移除 <var>stack</var> 中的最后一个元素。 {{question||为什么此处对stack操作不在Str中执行，而要在JO和JA中分别重复定义呢？}}
# 令 <var>indent</var> 为 <var>stepback</var>。
# 返回 <var>final</var>。


{{anchor|JSON-JA}}抽象操作 '''JA'''(<var>value</var>) 序列化一个数组。它可以访问调用它的 '''stringify''' 方法中的 <var>stack</var>、<var>indent</var>、<var>gap</var>、<var>PropertyList</var>、<var>ReplacerFunction</var> 以及 <var>space</var> {{bug||此抽象算法并不需要访问 space 变量。}}。数组的表示中仅包扩零到 '''array.length''' - '''1'''的区间。命名的属性将会被从字符串化操作中排除。数组字符串化成开头的左方括号，逗号分隔的元素，以及结束的右方括号。{{v8|https://github.com/v8/v8/blob/3.22/src/json.js#L71}}

# 若 <var>stack</var> 包含 <var>value</var>，则抛出一个'''TypeError'''，因为对象结构中存在循环。 {{question||为什么此处对循环结构判断不在Str中执行，而要在JO和JA中分别重复定义呢？}}
# 将 <var>value</var> 添加到 <var>stack</var>。 {{question||为什么此处对stack操作不在Str中执行，而要在JO和JA中分别重复定义呢？}}
# 令 <var>stepback</var> 为 <var>indent</var>。
# 令 <var>indent</var> 为 <var>indent</var> 与 <var>gap</var> 的连接。
# 令 <var>partial</var> 为空 [[ES5/types#List|List]]。
# 令 <var>len</var> 为以 '''"length"''' 为参数调用 <var>value</var> 的内部方法 [[ES5/types#Get|<nowiki>[[Get]]</nowiki>]]。
# 令 <var>index</var> 为 '''0'''。
# 当 <var>index</var> < <var>len</var> 时重复以下
## 令 <var>strP</var> 为传入 [[ES5/conversion#ToString|ToString]](<var>index</var>) 与 <var>value</var> 作为参数调用抽象方法 [[#JSON-Str|Str]] 的结果。
## 若 <var>strP</var> 是 '''undefined'''
### 添加 '''null''' 到 <var>partial</var>。
## 否则
### 添加 <var>strP</var> 到 <var>partial</var>。
## 使 <var>index</var> 增加'''1'''。
# 若 <var>partial</var> 为空，则
## 令 <var>final</var> 为 '''"[]"'''。
# 否则
## 若 <var>gap</var> 为空 '''String'''。
### 令 <var>properties</var> 为为一个连接所有 <var>partial</var> 中的字符串而成的字符串，键值对之间用逗号分隔。第一个字符串之前和最后一个字符串之后没有逗号。
### 令 <var>final</var> 为连接 '''"["'''、<var>properties</var> 和 '''"]"''' 的结果。
## 否则
### 令 <var>separator</var> 为逗号字符，换行字符以及 <var>indent</var> 而成的字符串。
### 令 <var>properties</var> 为一个连接所有 <var>partial</var> 中的字符串而成的字符串，键值对之间用 <var>separator</var> 分隔。第一个字符串之前和最后一个字符串之后没有 <var>separator</var>。
### 令 <var>final</var> 为连接 '''"["'''、换行符、<var>indent</var>、<var>properties</var>、换行符、<var>stepback</var> 和 '''"]"''' 的结果。
# 移除 <var>stack</var> 中的最后一个元素。 {{question||为什么此处对stack操作不在Str中执行，而要在JO和JA中分别重复定义呢？}}
# 令 <var>indent</var> 为 <var>stepback</var>。
# 返回 <var>final</var>。

{{note| '''JSON''' 结构允许任何深度的嵌套，但是不能够循环引用。若 '''''value''''' 是或者包含了一个循环结构，则 '''stringify''' 函数必须抛出一个 '''TypeError''' 异常。以下是一个不能够被字符串化的值的例子：
<pre>
a = [];
a[0] = a;
my_text = JSON.stringify(a); // This must throw an TypeError.
</pre>
}}
{{note|符号式简单值按以下方式表示：
# '''null''' 值在 '''JSON''' 文本中表示为 '''String''' '''null'''。
# '''undefined''' 值不出现。
# '''true''' 值在 '''JSON''' 文本中表示为 '''String''' '''true'''。
# '''false''' 值在 '''JSON''' 文本中表示为 '''String''' '''false'''。
}}

{{note| 字符串值用双引号括起。字符 '''"''' 和 '''\''' 会被转义成带 '''\''' 前缀的。控制字符用转义序列 '''\uHHHH''' 替换，或者使用简略形式 '''\b'''（退格符）、'''\f'''（换页符）、'''\n'''（换行符）、'''\r'''（回车符）、'''\t'''（制表符）。}}

{{note| 有穷的数字按照调用 '''ToString(''number'')''' 字符串化。'''NaN''' 和不论正负的 '''Infinity''' 都表示为字符串 '''null'''。}}

{{note| 没有 '''JSON''' 表示的值（如 '''undefined''' 和函数）不会产生字符串。而是会产生 '''undefined''' 值。在数组中这些值表示为字符串 '''null'''。在对象中不能表示的值会导致属性被排除在字符串化过程之外。}}

{{note| 对象表示为开头的左大括号跟着零个或者多个属性，以逗号分隔，以右大括号结束。属性是用用来表示 '''''key''''' 或者属性名的引号引起的字符串，冒号然后是字符串化的属性值。数组表示为开头的左方括号，后跟零个或者多个值，以逗号分隔，以右方括号结束。}}
Return to ES5/标准 ECMAScript 内置对象.
Retrieved from "https://www.w3.org/html/ig/zh/wiki/ES5/标准_ECMAScript_内置对象"
View source for ES5/标准 ECMAScript 内置对象

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Navigation

Tools
