ecma5

介紹

這一Ecma標準創建在一些本來的技術上，最爲著名的是JavaScript(網景)和JScript (微軟)。語言由網景的Brendan Eich發明而第一次出如今這個公司的Navigator 2.0瀏覽器上。它出如今全部Netscape後來的瀏覽器以及微軟從Internet Explorer 3.0以後的全部瀏覽器上。

這一標準的編制自1996年十一月開始。這一Ecma標準的第一個版本被1997年六月的Ecma General Assembly採納。

上述Ecma標準被以快速跟進流程提交至ISO/IEC JTC 1，並做爲於1998年四月做爲ISO/IEC 16262經過。1998年六月Ecma General Assembly經過了ECMA-262第二版以保持它與ISO/IEC 16262的徹底一致性。初版到第二版的變動僅僅是編輯性質的。

第三版標準引入了強大的正則表達式，更佳的字符串處理，新的控制語句，try/catch異常處理，更嚴密地錯誤定義，格式化的數字輸出以及一些爲國際化和將來語言成長預留的小變動。ECMAScript標準的第三版1999年十二月的Ecma General Assembly採納並於2002年六月做爲ISO/IEC 16262:2002發佈。

自第三版發佈以來，ECMAScript因其與萬維網的關聯而得到了普遍採用，它已經成爲全部web瀏覽器實質上都提供的一種編程語言。爲了編制第四版ECMAScript，有不少有意義的工做。儘管這工做沒能完成並且也沒有做爲ECMAScript的第四版發佈，它促進了語言的進化。ECMAScript第五版（發佈爲ECMA-262 5^th edition）紙面化了不少事實上已經在瀏覽器造成共識的語言規範解析而且增長了對自第三版發佈以來的新功能的支持。這些功能包括訪問器屬性，反射建立以及對象檢測，屬性特性的程序控制，新增的數組操做函數，JSON對象編碼格式，以及提供了改進的錯誤檢查以及程序安全性的嚴格模式。

這一ECMAScript 5.1版本標準徹底與國際標準ISO/IEC 16262:2011的第三版本一致。

ECMAScript是一個充滿活力的語言，並且語言的演進還沒有完成。有意義的技術性加強將會在將來版本的規範中持續進行。

這一Ecma規範由2011年六月Ecma General Assembly採納。

範圍

此標準定義了 ECMAScript 腳本語言。

一致性

符合標準的 ECMAScript 實現，必須提供並支持本規範描述的全部類型、值、對象、屬性、函數、程序語法和語義。

符合標準的 ECMAScript 實現，應當能解釋符合 Unic ode 標準3.0或更高版本，以 UCS-2 或 UTF-16 做爲編碼格式的 ISO/IEC 10646-1 第3級實現裏的字符。若是沒有額外指明採用的 ISO/IEC 10646-1 子集，則假定組號爲300的 BMP 子集。若是沒有額外指明採用的編碼格式，則假定編碼格式爲 UTF-16。

符合標準的 ECMAScript 實現，容許提供超出本規範描述的額外類型、值、對象、屬性、函數。 尤爲是本規範中描述的對象，是容許提供未在本規範中描述的屬性和屬性值的。

符合標準的 ECMAScript 實現，容許支持本規範未描述的程序語法和正則表達式語法。 尤爲是本規範 7.6.1.2 列出的「將來保留字」，是容許做爲程序語法的。

參考文獻

爲了實現符合本規範的應用程序，下列引用文檔是不可或缺的。對於標註了日期的文檔，僅適用標註的那個版本。 對於未標註日期的文檔，以文檔的最新版爲準（包括任何修訂版）。

ISO/IEC 9899:1996, Programming Languages – C, including amendment 1 and technical corrigenda 1 and 2

ISO/IEC 10646-1:1993, Information Technology – Universal Multiple-Octet Coded Character Set (UCS) plus its amendments and corrigenda

概述

本節包含對 ECMAScript 語言非規範性的概述。

ECMAScript 是在宿主環境中執行計算，處理對象的面向對象編程語言。這裏定義的 ECMAScript 並未打算要計算性自足；事實上，本規範沒有任何針對輸入外部數據或輸出計算結果的條文。相反，咱們指望 ECMAScript 程序的計算環境可提供本規範中描述的對象和其它設施以外的、某些特定環境下的 宿主 (host) 對象，除了說明宿主對象應該提供可被 ECMAScript 程序訪問的某些屬性，調用的某些方法外，關於它的其餘描述和行爲超出了本規範涉及的範圍。

腳本語言 是一種用於操做，自定義，自動化現有系統設施的編程語言。在這種系統中，已經能夠經過一個用戶界面使用可用功能，腳本語言是一種機制，暴漏這些功能給程序控制。這樣，現有系統能夠說給完善腳本語言能力須要的對象和設施提供了一個宿主環境。腳本語言被設計成專業和非專業程序員都能使用。

ECMAScript 最初被設計爲 Web 腳本語言 ，提供了一種機制，使瀏覽器裏的網頁更加活躍，成爲基於 Web 的客戶 - 服務器架構的一部分執行服務器計算。ECMAScript 能夠爲各類宿主環境提供核心的腳本功能，所以本文檔爲不依賴特定宿主環境的核心腳本語言做出規範。

ECMAScript 的一些機能和其餘編程語言的相似；特別是 Java™，Self，和 Scheme。如下文獻描述了他們：

Gosling, James, Bill Joy and Guy Steele. The Java™ Language Specification. Addison Wesley Publishing Co., 1996.

Ungar, David, and Smith, Randall B. Self: The Power of Simplicity. OOPSLA '87 Conference Proceedings, pp. 227–241, Orlando, FL, October 1987.

IEEE Standard for the Scheme Programming Language. IEEE Std 1178-1990.

Web 腳本語言

WEB 瀏覽器爲引入客戶端計算能力而提供 ECMAScript 宿主環境，例如，它提供的對象有：windows，menus，pop-ups，dialog boxes，text areas，anchors，frames，history，cookies 及輸入 / 輸出等等。進一步來講，WEB 瀏覽器中提供的這種宿主環境，它提供了一種方式，使得腳本代碼能夠去處理諸如改變焦點、頁面和圖片的加載、卸載、錯誤和放棄，選擇，表單提交和鼠標交互等等事件。腳本代碼出如今 HTML 中，顯示出來的頁面是一個用戶接口元素與固定的和計算出來的文本和圖片的集合。腳本代碼根據用戶的交互而作出反應，並不須要存在一個主程序。

WEB 服務器爲了服務端的計算則提供了一個徹底不同的宿主環境，包括的對象有：requests，clients，files 以及數據鎖定和分享的機制。經過瀏覽器端腳本及服務端腳本的配合使用，在爲基於 WEB 方式的應用程序提供定製的用戶接口時，能夠將計算分佈到客戶端和服務端進行。

每一種支持 ECMAScript 的 WEB 瀏覽器和服務器都將它們自身的宿主環境做爲 ECMAScript 的補充，以使得 ECMAScript 的執行環境變得完整。

語言概述

下面是非正式的 ECMAScript 概述 -- 並未描述語言的全部部分。此概述並不是標準的一部分。

ECMAScript 是基於對象的：基本語言和宿主設施都由對象提供，ECMAScript 程序是一組可通訊的對象。ECMAScript 對象 (objects) 是 屬性 (properties) 的集合，每一個屬性有零個或多個 特性 (attributes)，它肯定怎樣使用此屬性。例如，當設置一個屬性的 Writable 特性爲 false 時，任何試圖更改此屬性值的 ECMAScript 代碼的都會運行失敗。屬性是持有其餘 對象 (objects)， 原始值 (primitive values)， 函數 (functions) 的容器。原始值是如下內置類型之一的成員：Undefined，Null，Boolean，Number，String；對象是剩下的內置類型 Object 的成員；函數是可調用對象 (callable object)。方法 (method) 是經過屬性與對象關聯的函數。

ECMAScript 定義一組內置對象 (built-in objects)，勾勒出 ECMAScript 實體的定義。這些內置對象包括 全局對象 (global object) ，Object 對象 ，Function 對象 ，Array 對象 ，String 對象 ，Boolean 對象 ，Number 對象 ，Math 對象 ，Date 對象 ，RegExp 對象 ，JSON 對象，和 Error 對象： Error ，EvalError ，RangeError ，ReferenceError ，SyntaxError ，TypeError ，URIError 。

ECMAScript 中還定義一組內置運算符 (operators)。ECMAScript 運算符包括 一元運算符 ，乘法運算符 ，加法運算符 ，按位移位運算符 ，關係運算符 ，相等運算符 ，二進制位運算符 ，二進制邏輯運算符 ，賦值運算符 ，逗號運算符。

ECMAScript 語法有意設計成與 Java 語法相似。ECMAScript 的語法是鬆散的，使其可以做爲一個易於使用的腳本語言。例如，一個變量不須要有類型聲明，屬性也不須要與類型關聯，定義的函數也不須要聲明在函數調用詞句的前面。

對象

ECMAScript 不使用諸如 C++，Smalltalk，Java 中的類。相反，對象能夠經過各類方式建立，包括字面符號，或經過 構造器 建立對象而後運行代碼初始化其所有或部分屬性值，爲這些屬性分配初始值。每一個構造器是一個擁有名爲「prototype」的屬性的函數。此屬性用於實現 基於原型的繼承 和 共享屬性 。構造器經過 new 表達式建立對象：例如，new Date(2009,11) 建立一個新 Date 對象。不使用 new 調用一個構造器的結果，依賴構造器自己。例如，Date() 產生一個表示當前日期時間的字符串，而不是一個對象。

每一個由構造器建立的對象，都有一個隱式引用 ( 叫作對象的原型 ) 連接到構造器的「prototype」屬性值。再者，原型可能有一個非空 (non-null) 隱式引用連接到它本身的原型，以此類推，這叫作 原型鏈 。當向對象的一個屬性提出引用，引用會指向原型鏈中包含此屬性名的第一個對象的此屬性。換句話說，首先檢查直接說起的對象的同名屬性，若是對象包含同名的屬性，引用即指向此屬性，若是該對象不包含同名的屬性，則下一步檢查對象的原型；以此類推。

對象/原型關係

通常狀況下基於類的面嚮對象語言的實例擁有狀態，類擁有方法，而且只能繼承結構和行爲。在 ECMAScript 中，對象擁有狀態和方法，而且結構，行爲，狀態全均可繼承。

不直接包含原型中包含的特定屬性的全部對象會共享此屬性及屬性值。圖 1 說明了這一點：

CF 是一個構造器（也是一個對象）。五個對象已用 new 表達式建立 : cf1, cf2, cf3, cf4, cf5。每一個對象都有名爲 q1 和 q2 的屬性。虛線表示隱式原型關係；例如：cf3 的原型是 CFp。構造器 CF 本身有名爲 P1 和 P2 的兩個屬性 , 這對 CFp, cf1, cf2, cf3, cf4, cf5 是不可見的。CFp 的名爲 CFP1 的屬性共享給 cf1, cf2, cf3, cf4, cf5 ( 沒有 CF), 以及在 CFp 的隱式原型鏈中找不到任何名爲 q1, q2, 或 CFP1 的屬性。 請注意 ，CF 和 CFp 之間沒有隱式原型連接。

不一樣於基於類的對象語言，屬性能夠經過賦值的方式動態添加給對象。也就是說，構造器並非非要對構造的對象的所有或任何屬性命名或賦值。上圖中，能夠給 CFp 添加新屬性值的方式爲 cf1, cf2, cf3, cf4,cf5 添加一個新的共享屬性。

ECMAScript 的嚴格模式變體

ECMAScript 語言承認有些用戶但願限制使用語言中某些功能的可能性。他們這樣作多是爲了安全考慮，避免他們認爲是容易出錯的功能，得到加強的錯誤檢查，或其餘緣由。爲了支持這種可能性，ECMAScript 中定義了語言的嚴格變體。語言的嚴格變體，排除了 ECMAScript 語言的某些特定的語法和語義特徵，還修改了某些功能的詳細語義。嚴格變體還指定了必須拋出錯誤異常報告的額外錯誤條件，即便在非嚴格的語言形式下這些條件不屬於錯誤。

ECMAScript 的嚴格變體一般被稱爲語言的 嚴格模式 (strict mode)。嚴格模式選擇使用的 ECMAScript 嚴格模式的語法和語義，明確地適用於個別 ECMAScript 代碼單元級別。因爲嚴格模式適用於選擇的語法代碼單元級別，嚴格模式僅在這個代碼單元內施加有局部效果的限制。嚴格模式不限制或修改任何須須運行在多個代碼單元的 ECMAScript 語義層面。一個 ECMAScript 程序可由嚴格模式和非嚴格模式的代碼單元組成。在這種狀況下，嚴格的模式只適用於嚴格模式代碼單元內實際執行的代碼。

要符合這一規範，ECMAScript的實現必須同時實現未限制的ECMAScript語言和按照這個規範定義的ECMAScript的嚴格模式變體。此外，實現還必須支持未限制的和嚴格模式代碼單元的在同一個程序中混用。.

術語定義

本文檔將使用下列術語和定義。

類型 (type)

本規範第 8 章定義數據的集合。

原始值 (primitive value)

在本規範的第 8 章定義的未定義，空，布爾，數字，字符串類型之一的成員。

原始值直接表明語言實現的最底層的數據。

對象 (object)

對象類型的成員。

對象是屬性的集合，並有一個原型對象。原型能夠是空值。

構造器 (constructor)

建立和初始化對象的函數對象。

構造器的「prototype」屬性值是一個原型對象，它用來實現繼承和共享屬性。

原型 (prototype)

爲其餘對象提供共享屬性的對象。

當構造器建立一個對象，爲了解決對象的屬性引用，該對象會隱式引用構造器的「prototype」屬性。經過程序表達式 constructor.prototype 能夠引用到構造器的「prototype」屬性，而且添加到對象原型裏的屬性，會經過繼承與全部共享此原型的對象共享。另外，可以使用 Object.create 內置函數，經過明確指定原型來建立一個新對象。

原生對象 (native object)

ECMAScript 實現中，並不是由宿主環境，而是徹底由本規範定義其語義的對象。

標準的原生對象由本規範定義。一些原生對象是內置的，其餘的可在 ECMAScript 程序執行過程當中構建。

內置對象 (built-in object)

由 ECMAScript 實現提供，獨立於宿主環境的對象，ECMAScript 程序開始執行時就存在。

標準的內置對象由本規範定義，ECMAScript 實現能夠指定和定義其餘的。全部內置對象是原生對象。一個內置構造器 (built-in constructor) 是個內置對象，也是個構造器。

宿主對象 (host object)

由宿主環境提供的對象，用於完善 ECMAScript 執行環境。

任何對象，不是原生對象就是宿主對象。

未定義值 (undefined value)

說明一個變量沒有被分配值的一個原始值。

未定義類型 (Undefined type)

擁有惟一值「未定義值」的類型。

空值 (null value)

表明對象值故意留空的一個原始值。

空類型 (Null type)

擁有惟一值「空值」的類型。

布爾值 (Boolean value)

布爾類型的成員。

只有兩個布爾值，true 和 false 。

布爾類型 (Boolean type)

由原始值 true 和 false 組成的類型。

布爾對象 (Boolean object)

對象類型的成員，它是標準內置構造器 Boolean 的一個實例。

經過使用 new 表達式，以一個布爾值做爲參數調用 Boolean 構造器來建立布爾對象。由此產生的對象包含一個值爲此布爾值的內部屬性。一個 Boolean 對象能夠強制轉換爲布爾值。

字符串值 (String value)

原始值，它是零個或多個 16 位無符號整數組成的有限有序序列。

一個字符串值是字符串類型的成員。一般序列中的每一個整數值表明 UTF-16 文本的單個 16 位單元。然而，對於其值，ECMAScript 只要求必須是 16 位無符號整數，除此以外沒有任何限制或要求。

字符串類型 (String type)

全部可能的字符串值的集合。

字符串對象 (String object)

對象類型的成員，它是標準內置構造器 String 的一個實例。

經過使用 new 表達式，以一個字符串值爲參數調用 String 構造器來建立字符串對象。由此產生的對象包含一個值爲此字符串值的內部屬性。將 String 構造器做爲一個函數來調用，可將一個字符串對象強制轉換爲一個字符串值（15.5.1 ）。

數字值 (Number value)

原始值，對應一個 64 位雙精度二進制 IEEE754 值。

一個數字值是數字類型的成員，直接表明一個數字。

數字類型 (Number type)

全部可能的數字值的集合，包括特殊的「Not-a-Number」(NaN) 值，正無窮，負無窮。

數字對象 (Number object)

對象類型的成員，它是標準內置構造器 Number 的一個實例。

經過使用 new 表達式，以一個數字值爲參數調用 Number 構造器來建立數字對象。由此產生的對象包含一個值爲此數字值的內部屬性。將 Number 構造器做爲一個函數來調用，可將一個 Number 對象強制轉換爲一個數字值（15.7.1 ）。

無窮 (Infinity)

正無窮數字值。

NaN

值爲 IEEE 754「Not-a-Number」的數字值

函數 (function)

對象類型的成員，標準內置構造器 Function 的一個實例，而且可作爲子程序被調用。

函數除了擁有命名的屬性，還包含可執行代碼、狀態，用來肯定被調用時的行爲。函數的代碼不限於 ECMAScript。

內置函數 (built-in function)

做爲函數的內置對象。

如 parseInt 和 Math.exp 就是內置函數。一個實現能夠提供本規範沒有描述的依賴於實現的內置函數。

屬性 (property)

做爲對象的一部分聯繫名和值。

屬性可能根據屬性值的不一樣表現爲直接的數據值（原始值，對象，或一個函數對象）或間接的一對訪問器函數。

方法 (method)

做爲屬性值的函數。

當一個函數被做爲一個對象的方法調用，此對象將做爲 this 值傳遞給函數。

內置方法 (built-in method)

做爲內置函數的方法。

標準內置方法由本規範定義，一個 ECMAScript 實現可指定，提供其餘額外的內置方法。

特性 (attribute)

定義一個屬性的一些特性的內部值。

自身屬性 (own property)

對象直接擁有的屬性。

繼承屬性 (inherited property)

不是對象的自身屬性，可是是對象原型的屬性 ( 原型的自身屬性或繼承屬性 )。

記法約定

語法和詞法的文法

上下文無關文法

一個 上下文無關文法 由必定數量的 產生式 (productions) 組成。每一個產生式的 左邊 (left-hand side) 是一個被稱爲非終結符 (nonterminal) 的抽象符號， 右邊 (right-hand side) 是零或多個非終結符和 終結符 (terminal symbols) 的有序排列。任何文法，它的終結符都來自指定的字母集。

當從一個叫作 目標符 (goal symbol) 的特殊非終端符組成的句子起始，那麼給出的上下文無關文法就表示 語言 (language)，即，將產生式右邊序列的非終結符看成左邊，進行反覆替換的結果就成爲可能的終結符序列集合（可能無限）。

詞法和正則的文法

第 7 章給出了 ECMAScript 的 詞法文法 (lexical grammar)。做爲此文法的終結符字符（Unicode 代碼單元）符合第 6 章定義的 SourceCharacter 的規則。它定義了一套產生式，從目標符 InputElementDiv 或 InputElementRegExp 起始，描述瞭如何將這樣的字符序列翻譯成一個輸入元素序列。

空白和註釋以外的輸入元素構成 ECMAScript 語法文法的終結符，它們被稱爲 ECMAScript 的 tokens。這些 tokens 是，ECMAScript 語言的保留字，標識符，字面量，標點符號。此外，行結束符雖然不被視爲 tokens，但會成爲輸入元素流的一部分，用於引導處理自動插入分號（ 7.9 ）。空白和單行註釋會被簡單的丟棄，不會出如今語法文法的輸入元素的流中。若是一個 多行註釋 (MultiLineComment)（即形式爲「/ ... /」的註釋，無論是否跨越多行）不包含行結束符也會簡單地丟棄，但若是一個 多行註釋 包含一個或多個結束符，那麼，註釋會被替換爲一個行結束符，成爲語法文法輸入元素流的一部分。

15.10 給出了 ECMAScript 的 正則文法 (RegExp grammar)。此文法的終結符字符也由 SourceCharacter 定義。它定義了一套產生式，從目標符 Pattern 起始，描述瞭如何將這樣的字符序列翻譯成一個正則表達式模式。

兩個冒號「::」做爲分隔符分割詞法和正則的文法產生式。詞法和正則的文法共享某些產生式。

數字字符串文法

用於轉換字符串爲數字值的一種文法。此文法與詞法文法的一部分（與數字字面量有關的）相似，而且有終結符 SourceCharacter。此文法出如今 9.3.1 。

三個冒號「:::」做爲分隔符分割數字字符串文法的產生式。

語法文法

第 11，12，13，14 章給出了 ECMAScript 的 語法文法 。詞法文法定義的 ECMAScript tokens 是此文法的終結符（ 5.1.2 ）。它定義了一組起始於 Program 目標符的產生式，描述了語法正確的 ECMAScript 程序應該怎樣排列 tokens。

當一個字符流被解析爲 ECMAScript 程序，它首先經過詞法文法應用程序反覆轉換爲一個輸入元素流；而後再用一個語法文法應用程序解析這個輸入元素流。當輸入元素流沒有更多 tokens 時，若是 tokens 不能解析爲 Program 目標非終結符的單一實例，那麼程序在語法上存在錯誤。

只用一個冒號「:」做爲分隔符分割語法詞法的產生式。

事實上第 11，12，13 和 14 章給出的語法語法，並不能徹底說明一個正確的 ECMAScript 程序能接受的 token 序列。一些額外的 token 序列也被接受，即某些特殊位置（如行結束符前）加入分號能夠被文法接受。此外，文法描述的某些 token 序列不被文法接受，如一個行結束符出如今「尷尬」的位置。

JSON 文法

JSON 文法用於將描述 ECMAScript 對象的字符串轉換爲實際的對象。15.12.1 給出了 JSON 文法 。

JSON 文法由 JSON 詞法文法和 JSON 語法文法組成。JSON 詞法文法用於將字符序列轉換爲 tokens，相似 ECMAScript 詞法文法。JSON 語法文法說明 JSON 詞法文法給出怎樣的 tokens 序列才能轉換爲語法上是正確的 JSON 對象。

兩個冒號「::」做爲分隔符分割 JSON 詞法文法的產生式。JSON 詞法文法使用某些 ECMAScript 詞法文法的產生式。JSON 語法文法與 ECMAScript 語法文法相似。JSON 語法文法產生式被一個冒號「:」做爲分隔符分割。

文法標記法

詞法文法和字符串文法的終結符，以及一些語法文法的終結符，不管是在文法的產生式仍是貫穿本規範的全部文本直接給出的終結符，都用 等寬 (fixed width) 字體顯示。他們表示程序書寫正確。全部以這種方式指定的終結符字符，能夠理解爲 Unicode 字符的完整的 ASCII 範圍，不是任何其餘相似的 Unicode 範圍字符。

非終結符以 斜體 (italic) 顯示。一個非終結符的定義由非終結符名稱和其後定義的一個或多個冒號給出。（冒號的數量表示產生式所屬的文法。）非終結符的右側有一個或多個替代子緊跟在下一行。 例如，語法定義：

WhileStatement

while ( Expression ) Statement

表示這個非終結符 WhileStatement 表明 while token，其後跟左括號 token，其後跟 Expression，其後跟右括號 token，其後跟 Statement。這裏出現的 Expression 和 Statement 自己是非終結符。另外一個例子，語法定義：

ArgumentList : AssignmentExpression ArgumentList , AssignmentExpression

表示這個 ArgumentList 能夠表明一個 AssignmentExpression，或 ArgumentList，其後跟一個逗號，其後跟一個 AssignmentExpression。這個 ArgumentList 的定義是遞歸的，也就是說，它定義它自身。其結果是，一個 ArgumentList 可能包含用逗號隔開的任意正數個參數，每一個參數表達式是一個 AssignmentExpression。這樣，非終結符共用了遞歸的定義。

終結符或非終結符可能會出現後綴下標「 _opt 」，表示它是可選符號。實際上包含可選符號的替代子包含兩個右邊，一個是省略可選元素的，另外一個是包含可選元素的。這意味着：

VariableDeclaration : Identifier Initialiseropt

是如下的一種縮寫：

VariableDeclaration : Identifier Identifier Initialiser

而且：

IterationStatement : for ( ExpressionNoInopt ; Expressionopt ; Expressionopt ) Statement

是如下的一種縮寫：

IterationStatement : for ( ; Expressionopt ; Expressionopt ) Statement for ( ExpressionNoIn ; Expressionopt ; Expressionopt ) Statement

是如下的一種縮寫 :

IterationStatement : for ( ; ; Expressionopt ) Statement for ( ; Expression ; Expressionopt) Statement for ( ExpressionNoIn ; ; Expressionopt) Statement for ( ExpressionNoIn ; Expression ; Expressionopt) Statement

是如下的一種縮寫：

IterationStatement : for ( ; ; ) Statement for ( ; ; Expression ) Statement for ( ; Expression ; ) Statement for ( ; Expression ; Expression ) Statement for ( ExpressionNoIn ; ; ) Statement for ( ExpressionNoIn ; ; Expression ) Statement for ( ExpressionNoIn ; Expression ; ) Statement for ( ExpressionNoIn ; Expression ; Expression ) Statement

所以，非終結 IterationStatement 實際上有 8 個右側變體。

若是文法定義的冒號後面出現文字「one of」，那麼其後一行或多行出現的每一個終結符都是一個選擇定義。例如，ECMAScript 包含的詞法文法生產器：

NonZeroDigit :: one of 1 2 3 4 5 6 7 8 9

這僅僅下面寫法的一種縮寫：

NonZeroDigit :: 1 2 3 4 5 6 7 8 9

若是產生式的右側是出現「[empty]」，它代表，產生式的右側不包含終結符或非終結符。

若是產生式的右側出現「[lookahead ∉ set]」，它代表，給定 set 的成員不得成爲產生式緊隨其後的 token。這個 set 能夠寫成一個大括號括起來的終結符列表。爲方便起見，set 也能夠寫成一個非終結符，在這種狀況下，它表明了這個非終結符 set 可擴展全部終結符。例如，給出定義

DecimalDigit :: one of 0 1 2 3 4 5 6 7 8 9DecimalDigits :: DecimalDigit DecimalDigits DecimalDigit

在定義

LookaheadExample :: n [lookahead ∉ {1 , 3 , 5 , 7 , 9}]DecimalDigits DecimalDigit [lookahead ∉ DecimalDigit ]

能匹配字母 n 後跟隨由偶數起始的一個或多個十進制數字，或一個十進制數字後面跟隨一個非十進制數字。

若是產生式的右側出現「[no LineTerminator here]」，那麼它表示此產生式是個受限的產生式：若是 LineTerminator 在輸入流的指定位置出現，那麼此產生式將不會被適用。例如，產生式：

ThrowStatement : throw [no LineTerminator here] Expression ;

表示若是程序中 return token 和 Expression 之間的出現 LineTerminator，那麼不得使用此產生式。

LineTerminator 除了禁止出如今受限的產生式，能夠在輸入元素流的任何兩個 tokens 之間出現任意次數，而不會影響程序的語法驗證。

當一個詞法文法產生式或數字字符串文法中出現多字符 token，它表示此字符序列將註冊一個 token。

使用詞組「but not「能夠指定某些不容許在產生式右側的擴展，它說明排除這個擴展。例如，產生式：

Identifier :: IdentifierName but not ReservedWord

此非終結符 Identifier 能夠由可替換成 IdentifierName 的字符序列替換，相同的字符序列不能替換 ReservedWord。

最後，對於實際上不可能列出所有可變元的少許非終結符，咱們用普通字體寫出描述性的短語來描述它們：

SourceCharacter :: any Unicode code unit

算法約定

此規範一般使用帶編號的列表來指定算法的步驟。這些算法是用來精確地指定 ECMAScript 語言結構所需的語義。該算法無心暗示任何具體實現使用的技術。在實踐中，也許可用更有效的算法實現一個給定功能。

爲了方便其使用本規範的多個部分，叫作 抽象操做 (abstract operations) 的一些算法編寫成帶名稱的可傳參函數化形式，因此在其餘算法裏能夠經過名稱引用它們。

當一個算法產生返回值 ，「return x」 指令說明該算法的返回值是 x，而且算法應該終止。「第 n 步的結果」的簡寫是 Result(n) 。

爲了表達清晰，算法的步驟可細分爲有序的子步驟。子步驟被縮進，能夠將自身進一步劃分爲縮進子步驟。大綱編號約定用於識別分步驟，第一層次的子步驟適用小寫字母標記，第二層次的子步驟使用小寫羅馬數字標記。若是須要超過三個層次，則重複這些規則，第四層次使用數字標記。例如 :

1. Top-level step
   1. Substep.
   2. Substep
      1. Subsubstep.
      2. Subsubstep.
         1. Subsubsubstep
            1. Subsubsubsubstep

步驟或子步驟可寫「if」謂詞做爲它的子步驟的條件。在這種狀況下，當謂詞爲真時子步驟才適用。若是一個步驟或子步驟由單詞「else」開始，那麼它是一個謂詞，否認前面的同一層級的「if」謂詞。

步驟能夠表示其子步驟的迭代應用可能指定其子步的迭代應用程序。

步驟可能斷言其算法中的某一不變條件。這樣的斷言可讓算法中隱含的不變條件變成顯式的。這種斷言不會添加額外的語義要求，實現沒有必定去檢查的必要性。它們只是用來讓算法更清晰。

數學運算，如加法，減法，取反，乘法，除法，還有稍後在本節中定義的數學函數應該老是被理解爲對數學實數計算精確的數學結果，其中不包括無窮大，不包括負零區別於正零。本標準中的浮點運算算法模型，包括明確的步驟，在必要狀況下處理無窮大和有符號零和執行四捨五入。若是一個數學運算或函數應用一個浮點數，它應該被應用爲表明此浮點數的確切的數學值，一個浮點數必須是有限的 ，若是是 +0 或 -0 ，則相應的數學值就是 0。

數學函數 abs(x) 產生 x 的絕對值，若是 x 是負數（小於零），它是這是 - x，不然是 X 自己。

若是 x 是正數，數學函數 sign (x) 產生 1，若是 x 是負數產生 - 1。此標準中 x 爲零的狀況下不使用 sign 函數。

符號 「x modulo y」 (y 必須有限且非零 ) 計算一個知足如下條件的 k 值 ，與 y 同號 ( 或是零 ) ，abs(k) < abs(y) ，對一些整數 q 知足 x−k = q × y。

數學函數 floor(x) 產生不大於 x 的最大整數（最大可爲正無窮）。

floor(x) = x−(x modulo 1).

若是算法定義「拋出一個異常」，算法的執行將被終止，且沒有返回結果。已調用的算法也被終止，直到算法步驟使用術語「若是一個異常被拋出 ...」明確指出異常處理。一旦遇到這種算法步驟，異常將再也不被視已發生過。

源代碼文本

用 3.0 或更高版本 Unicode 字符編碼的一個字符序列來表示 ECMAScript 源文本。該文本預期已經正常化爲 Unicode Technical Report #15 中描述的 Unicode 正常化形式 C（canonical composition）。符合 ECMAScript 的實現不要求對文本執行正常化，也不要求將其表現爲像執行了正常化同樣。爲了目的，此規範 ECMAScript 的源文本被假定爲一個 16 位代碼單元，本規範的目的序列。這樣的包含 16 位代碼單元序列的源文本可能不是有效的的 UTF-16 字符編碼。若是實際的源文本沒有用 16 位代碼單元形式編碼，那麼必須把它看做已經轉換爲 UTF-16 同樣處理。

語法

SourceCharacter :: any Unicode code unit

貫穿本文檔，短語「代碼單元 (code unit)」和單詞「字符 (character)」特指表示文本的單個 16 位單元的 16 位無符號值。短語「Unicode 字符 (Unicode character)」特指單個 Unicode 標量值（這可能大於 16 位，所以它可能表明多個代碼單位）表示的語言或排版上的抽象單位。短語「代碼點 (code point)」是指這樣一個 Unicode 標量值。「Unicode 字符」僅指由單一的 Unicode 標量值表示的實體：組合字符序列的每一個組成部分都是單個「Unicode 字符」，儘管用戶可能會認爲整個序列是單個字符。

在字符串字面量，正則表達式字面量，標識符中的任意字符（代碼單元），能夠是由六個字符組成的 Unicode 轉義序列，即 \u 加上四個 16 進制數字。在註釋中，這樣的轉義序列被看成註釋的一部分忽略掉。在字符串字面量或正則表達式字面量中，Unicode 轉義序列會給字面量值貢獻一個字符。在標識符中，轉義序列給標識符貢獻一個字符。

雖然本文檔有時會提到「字符串 (string)」裏的「字符 (character)」和表明字符代碼單元的 16 位無符號整數間的「變換 (transformation)」。事實上並無變換，由於實際上就是用 16 位無符號值表明「字符串」裏的「字符」。

ECMAScript 與 Java 編程語言對 Unicode 轉義序列有不一樣的解釋。在 Java 程序中，若是 Unicode 轉義序列 \u000A 出如今單行註釋中，它會被解釋成行終結符（Unicode 字符000A 是換行），所以接下來的一個字符不是註釋的一部分。與此相似，若是 Java 程序中的字符串字面量裏出現 Unicode 轉義序列 \u000A，它一樣會被解釋成行終結符，字符串字面量裏不容許出現行終結符，不得不將做爲字符串字面量字符值的換行符的 \u000A 替換成 \n。在 ECMAScript 程序中，始終不會解釋註釋裏出現的 Unicode 轉義序列，所以沒法給註釋貢獻終止符。與此相似，若是 ECMAScript 程序中的字符串字面量裏出現 Unicode 轉義序列，它始終會貢獻一個字符給字面量值，而且始終不會解釋成有可能終止字符串字面量的行終結符或引號標記。

詞法

ECMAScript 程序的源文本首先轉換成一個輸入元素序列；tokens，行終結符，註釋，空白構成輸入元素序列。從左到右掃描源文本，反覆獲取做爲下一個輸入元素的儘量長的字符序列。

詞法文法有兩個目標符。InputElementDiv 目標符用在容許除法 (/) 或除賦值 (/=) 運算符開始的語法文法上下文中。InputElementRegExp 目標符用在其餘語法文法上下文。

沒有容許除法或除賦值運算符開頭，同時又容許 RegularExpressionLiteral 開頭的語法文法上下文。這不會被分號插入（見 7.9）影響；以下面的例子：

a = b /hi/g.exec(c).map(d);

其中 LineTerminator 後的第一個非空白，非註釋字符是斜線（/），而且這個語法上下文容許除法或除賦值運算符，因此不會在這個 LineTerminator 位置插入分號。也就是說，上面的例子解釋爲：

a = b / hi / g.exec(c).map(d);

語法：

InputElementDiv :: WhiteSpace LineTerminator Comment Token DivPunctuatorInputElementRegExp :: WhiteSpace LineTerminator Comment Token RegularExpressionLiteral

Unicode 格式控制字符

Unicode 格式控制字符（即，Unicode 字符數據庫中「Cf」分類裏的字符，如「左至右符號 (left-to-right mark)」或「右至左符號 (left-to-right mark)」）是用來控制被更高層級協議（如標記語言）忽略的文本範圍的格式的控制代碼。

容許在源文本中出現控制字符是有用的，以方便編輯和顯示。全部格式控制字符可寫入到註釋，字符串字面量，正則表達式字面量中。

在某些語言中和控制字符用於建立必要的的分隔符分割詞或短語。在 ECMAScript 源文本里，和還能夠用在一個標識符後的第一個字符。

控制字符主要出現的文本的開頭，標記它是 Unicode，並容許檢測文本的編碼和字節順序。用於這一目的字符，有時也可能出如今文本開始的後面，例如，一個合併的文件。字符被視爲空白字符（見 [7.2]）。

表 1 總結了一些在註釋，字符串字面量，正則表達式字面量以外被特殊對待的格式控制字符。

控制字符的使用

字符編碼值	名稱	正式名稱	用途
\u200C	零寬非鏈接符	<ZWNJ>	IdentifierPart
\u200D	零寬鏈接符	<ZWJ>	IdentifierPart
\uFEFF	位序掩碼	<BOM>	Whitespace

空白字符

空白字符用來改善源文本的可讀性和分割 tokens（不可分割的詞法單位），此外就可有可無。空白字符能夠出現的兩個 token 之間還能夠出如今輸入的開始或結束位置。空白字符，還能夠出如今字符串 字面量 (StringLiteral) 或正則 表達式字面量 (RegularExpressionLiteral)( 在這裏它表示組成字面量的字符 ) 或 註釋 (Comment) 中，可是不能出現的其餘任何 token 內。

表 2 中列出了 ECMAScript 空白字符。

空白字符

字符編碼值	名稱	正式名稱
\u0009	製表符	<TAB>
\u000B	縱向製表符	<VT>
\u000C	進紙符	<FF>
\u0020	空格	<SP>
\u00A0	非斷空格	<NBSP>
\uFEFF	位序掩碼	<BOM>
其它分類「Zs」	其它任何Unicode"空白分隔符"	<USP>

ECMAScript 實現必須承認 Unicode 3.0 中定義的全部空白字符。後續版本的 Unicode 標準可能定義其餘空白字符。ECMAScript 實現能夠承認更高版本 Unicode 標準裏的空白字符。

語法：

WhiteSpace :: <tab> <vt> <ff> <sp> <nbsp> <bom> <usp>

行終結符

像空白字符同樣，行終止字符用於改善源文本的可讀性和分割 tokens（不可分割的詞法單位）。然而，不像空白字符，行終結符對語法文法的行爲有必定的影響。通常狀況下，行終結符能夠出如今任何兩個 token 之間，但也有少數地方，語法文法禁止這樣作。行終結符也影響自動插入分號過程（7.9）。行終結符不能出如今 StringLiteral 以外的任何 token 內。行終結符只能出如今做爲 LineContinuation 一部分的 StringLiteral token 裏。

行終結符能夠出如今 MultiLineComment（7.4）內，但不能出如今 SingleLineComment 內。

正則表達式的 \s 類匹配的空白字符集中包含行終結符。

表 3 列出了 ECMAScript 的行終止字符。

行終止字符

字符編碼值	名稱	正式名稱
\u000A	進行符	<LF>
\u000D	回車符	<CR>
\u2028	行分隔符	<LS>
\u2029	段分隔符	<PS>

只有表 3 中的字符才被視爲行終結符。其餘新行或折行字符被視爲空白，但不做爲行終結符。字符序列 做一個行終結符。計算行數時它應該被視爲一個字符。

語法：

LineTerminator ::LineTerminatorSequence :: [lookahead ∉ ]

註釋

註釋能夠是單行或多行。多行註釋不能嵌套。

由於單行註釋能夠包含除了 LineTerminator 字符以外的任何字符，又由於有通常規則：一個 token 老是儘量匹配更長，因此一個單行註釋老是包含從 // 到行終結符之間的全部字符。然而，在該行末尾的 LineTerminator 不被當作是單行註釋的一部分，它被詞法文法識別成語法文法輸入元素流的一部分。這一點很是重要，由於這意味着是否存在單行註釋都不影響自動分號插入進程（見 7.9）。

像空白同樣，註釋會被語法文法簡單丟棄，除了 MultiLineComment 包含行終結符字符的狀況，這種狀況下整個註釋會看成一個 LineTerminator 提供給語法文法解析。

語法：

Comment :: MultiLineComment SingleLineCommentMultiLineComment :: /* MultiLineCommentCharsopt*/MultiLineCommentChars :: MultiLineNotAsteriskChar MultiLineCommentCharsopt * PostAsteriskCommentCharsoptPostAsteriskCommentChars :: MultiLineNotForwardSlashOrAsteriskChar MultiLineCommentCharsopt * PostAsteriskCommentCharsoptMultiLineNotAsteriskChar :: SourceCharacter but not asterisk *MultiLineNotForwardSlashOrAsteriskChar :: SourceCharacter but not forward-slash / or asterisk *SingleLineComment :: // SingleLineCommentCharsoptSingleLineCommentChars :: SingleLineCommentChar SingleLineCommentCharsoptSingleLineCommentChar :: SourceCharacter but not LineTerminator

Tokens

語法：

Token :: IdentifierName Punctuator NumericLiteral StringLiteral

DivPunctuator 和 RegularExpressionLiteral 產生式定義 tokens ，但 Token 的產生式不包含它們。

標識符名和標識符

標識符名是 tokens，Unicode 標準第 5 章的「標識符」節給出的文法加入了一些小的修改來解釋它。Identifier 是一個 IdentifierName 但不是一個 ReservedWord( 見 7.6.1)。Unicode 標識符文法基於 Unicode 標準指出的 normative 和 informative 字符分類。全部符合 ECMAScript 的實現必須可以正確處理 Unicode 標準 3.0 版本中指定的分類裏的字符的分類。

本標準增長了個別字符：在 IdentifierName 的任何位置容許出現美圓符（$）和下劃線（_）。

IdentifierName 還容許出現 Unicode 轉義序列，它們被 UnicodeEscapeSequence 的 CV 計算成單個字符貢獻給 IdentifierName（見 7.8.4）。UnicodeEscapeSequence 前面的 \ 不給IdentifierName 貢獻字符。UnicodeEscapeSequence 不能提供單個字符給將要成爲非法字符的 IdentifierName。換句話說，若是一個 \ UnicodeEscapeSequence 序列被UnicodeEscapeSequence 的 CV 替換，結果必須還是有效的包含與原 IdentifierName 精確相同字符序列的 IdentifierName。本規範說明的全部標識符是根據它的實際字符，無論轉義序列貢獻特定字符與否。

根據 Unicode 標準兩個規範的 IdentifierName 相等，是說除非他們的代碼單元序列準確相等，不然不一樣（換句話說，符合 ECMAScript 的實現只須要按位比較 IdentifierName 值）。其目的是爲了傳入編譯器以前就把源文本轉換爲正常化形式 C。

ECMAScript 實現能夠識別後續版本 Unicode 標準定義的標識符字符。若是考慮可移植性，程序員應該只採用 Unicode 3.0 中定義的標識符字符。

語法：

Identifier :: IdentifierName but not ReservedWordIdentifierName :: IdentifierStart IdentifierName IdentifierPartIdentifierStart :: UnicodeLetter $ _ \ UnicodeEscapeSequenceIdentifierPart :: IdentifierStart UnicodeCombiningMark UnicodeDigit UnicodeConnectorPunctuation UnicodeLetter any character in the Unicode categories 「Uppercase letter (Lu)」, 「Lowercase letter (Ll)」, 「Titlecase letter (Lt)」, 「Modifier letter (Lm)」, 「Other letter (Lo)」,or 「Letter number (Nl)」. UnicodeCombiningMark any character in the Unicode categories 「Non-spacing mark (Mn)」\\\ or 「Combining spacing mark (Mc)」 UnicodeDigit any character in the Unicode category 「Decimal number (Nd)」 UnicodeConnectorPunctuation any character in the Unicode category 「Connector punctuation (Pc)」 UnicodeEscapeSequence see 7.8.4.

保留字

保留字不能做爲 Identifier 的 IdentifierName。

語法

ReservedWord :: Keyword FutureReservedWord NullLiteral BooleanLiteral

關鍵詞

下列 token 是 ECMAScript 的關鍵詞，不能用做 ECMAScript 程序的 Identifiers。

語法

Keyword :: one of break do instanceof typeof case else new var catch finally return void continue for switch while debugger function this with default if throw delete in try

將來保留字

下列詞被用做建議擴展關鍵字，所以保留，以便將來可能採用這些擴展。

語法

FutureReservedWord :: one of class enum extends super const export import

當下列 tokens 出如今 嚴格模式代碼 (strict mode code )（見 10.1.1）裏，將被當成是 FutureReservedWords。任意這些 tokens 出如今任意上下文中的嚴格模式代碼 (strict mode code) 中，若是 FutureReservedWord 出現的位置會產生錯誤，那麼必須拋出對應的異常：

implements let private public yield interface package protected static

標點符號

語法

Punctuator :: one of { } ( ) [ ] .  ; , < > <= >= ==  != ===  !== + - *  % ++ -- << >> >>> & | ^  ! ~ && ||  ?  : = += -= *=  %= <<= >>= >>>= &= |= ^= DivPunctuator :: one of / /=

字面量

語法

Literal :: NullLiteral BooleanLiteral NumericLiteral StringLiteral RegularExpressionLiteral

空值字面量

語法：

NullLiteral :: null

語義：

空值字面量的值 null，是 Null 類型的惟一值。

布爾值字面量

語法：

BooleanLiteral :: true false

語義：

布爾值字面量的值 true 是個布爾類型值 ，即 true。

布爾值字面量的值 false 是個布爾類型值 ，即 false。

數值字面量

語法：

NumericLiteral :: DecimalLiteral HexIntegerLiteralDecimalLiteral :: DecimalIntegerLiteral . DecimalDigitsopt ExponentPartopt . DecimalDigits ExponentPartopt DecimalIntegerLiteral ExponentPartoptDecimalIntegerLiteral :: 0 NonZeroDigit DecimalDigitsoptDecimalDigits :: DecimalDigit DecimalDigits DecimalDigit DecimalDigit :: one of 0 1 2 3 4 5 6 7 8 9 NonZeroDigit :: one of 1 2 3 4 5 6 7 8 9ExponentPart :: ExponentIndicator SignedInteger ExponentIndicator :: one of e ESignedInteger :: DecimalDigits + DecimalDigits - DecimalDigitsHexIntegerLiteral :: 0x HexDigit 0X HexDigit HexIntegerLiteral HexDigit HexDigit :: one of 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F

源字符中的 NumericLiteral 後面不容許緊跟着 IdentifierStart 或 DecimalDigit。

例如：

3in

是錯誤的，不存在兩個輸入元素 3 和 in。

語義：

一個數值字面量表明一個 Number 類型的值。此值取決於兩個步驟：第一，由字面量得出的數學值 (mathematical value)（MV）；第二，這個數學值按照後面描述的規則舍入。

• NumericLiteral::DecimalLiteral 的 MV 是 DecimalLiteral 的 MV。
• NumericLiteral :: HexIntegerLiteral 的 MV 是 HexIntegerLiteral 的 MV。
• DecimalLiteral :: DecimalIntegerLiteral . 的 MV 是 DecimalIntegerLiteral 的 MV 是。
• DecimalLiteral :: DecimalIntegerLiteral . DecimalDigits 的 MV 是 DecimalIntegerLiteral 的 MV 加上 (DecimalDigits 的 MV 乘 10-n), 這裏的 n 是 DecimalDigits 的字符個數。
• DecimalLiteral :: DecimalIntegerLiteral . ExponentPart 的 MV 是 DecimalIntegerLiteral 的 MV 乘 10e, 這裏的 e 是 ExponentPart 的 MV。
• DecimalLiteral :: DecimalIntegerLiteral . DecimalDigits ExponentPart 的 MV 是 (DecimalIntegerLiteral 的 MV 加 (DecimalDigits 的 MV 乘 10-n)) 乘 10e, 這裏的 n 是 DecimalDigits 的字符個數，e 是 ExponentPart 的 MV。
• DecimalLiteral ::. DecimalDigits 的 MV 是 DecimalDigits 的 MV 乘 10-n, 這裏的 n 是 DecimalDigits 的字符個數。
• DecimalLiteral ::. DecimalDigits ExponentPart 的 MV 是 DecimalDigits 的 MV 乘 10e-n, 這裏的 n 是 DecimalDigits 的字符個數，e 是 ExponentPart 的 MV。
• DecimalLiteral :: DecimalIntegerLiteral 的 MV 是 DecimalIntegerLiteral 的 MV。
• DecimalLiteral :: DecimalIntegerLiteral ExponentPart 的 MV 是 DecimalIntegerLiteral 的 MV 乘 10e, 這裏的 e 是 ExponentPart 的 MV。
• DecimalIntegerLiteral :: 0 的 MV 是 0。
• DecimalIntegerLiteral :: NonZeroDigit DecimalDigits 的 MV 是 (NonZeroDigit 的 MV 乘 10n) 加 DecimalDigits 的 MV, 這裏的 n 是 DecimalDigits 的字符個數。
• DecimalDigits :: DecimalDigit 的 MV 是 DecimalDigit 的 MV。
• DecimalDigits :: DecimalDigits DecimalDigit 的 MV 是 (DecimalDigits 的 MV 乘 10) 加 DecimalDigit 的 MV。
• ExponentPart :: ExponentIndicator SignedInteger 的 MV 是 SignedInteger 的 MV。
• SignedInteger :: DecimalDigits 的 MV 是 DecimalDigits 的 MV。
• SignedInteger :: + DecimalDigits 的 MV 是 DecimalDigits 的 MV。
• SignedInteger :: - DecimalDigits 的 MV 是 DecimalDigits 的 MV 取負。
• DecimalDigit :: 0 或 HexDigit :: 0 的 MV 是 0。
• DecimalDigit :: 1 或 NonZeroDigit :: 1 或 HexDigit :: 1 的 MV 是 1。
• DecimalDigit :: 2 或 NonZeroDigit :: 2 或 HexDigit :: 2 的 MV 是 2。
• DecimalDigit :: 3 或 NonZeroDigit :: 3 或 HexDigit :: 3 的 MV 是 3。
• DecimalDigit :: 4 或 NonZeroDigit :: 4 或 HexDigit :: 4 的 MV 是 4。
• DecimalDigit :: 5 或 NonZeroDigit :: 5 或 HexDigit :: 5 的 MV 是 5。
• DecimalDigit :: 6 或 NonZeroDigit :: 6 或 HexDigit :: 6 的 MV 是 6。
• DecimalDigit :: 7 或 NonZeroDigit :: 7 或 HexDigit :: 7 的 MV 是 7。
• DecimalDigit :: 8 或 NonZeroDigit :: 8 或 HexDigit :: 8 的 MV 是 8。
• DecimalDigit :: 9 或 NonZeroDigit :: 9 或 HexDigit :: 9 的 MV 是 9。
• HexDigit :: a 或 HexDigit :: A 的 MV 是 10。
• HexDigit :: b 或 HexDigit :: B 的 MV 是 11。
• HexDigit :: c 或 HexDigit :: C 的 MV 是 12。
• HexDigit :: d 或 HexDigit :: D 的 MV 是 13。
• HexDigit :: e 或 HexDigit :: E 的 MV 是 14。
• HexDigit :: f 或 HexDigit :: F 的 MV 是 15。
• HexIntegerLiteral :: 0x HexDigit 的 MV 是 HexDigit 的 MV。
• HexIntegerLiteral :: 0X HexDigit 的 MV 是 HexDigit 的 MV。
• HexIntegerLiteral :: HexIntegerLiteral HexDigit 的 MV 是 (HexIntegerLiteral 的 MV 乘 16) 加 HexDigit 的 MV。

數值字面量的確切 MV 值一旦被肯定，它就會舍入成 Number 類型的值。若是 MV 是 0，那麼舍入值是 +0；不然，舍入值必須是 MV 對應的準確數字值（8.5 中定義），除非此字面量是有效數字超過 20 位的 DecimalLiteral，這種狀況下，數字值能夠用下面兩種方式產生的 MV 值肯定：一，將 20 位後的每一個有效數字用 0 替換後產生的 MV，二，將 20 位後的每一個有效數字用 0 替換，而且遞增第 20 位有效數字位置的字面量值，產生的 MV。若是一個數字是 ExponentPart 的一部分，而且：

• 它不是 0；或
• 它的左側是非零數字，它的右側是不在 ExponentPart 的非零數字。

符合標準的實現，在處理嚴格模式代碼（見 10.1.1）時，按照 B.1.1 的描述，不得擴展 NumericLiteral 包含 OctalIntegerLiteral 的語法。

字符串字面量

一個字符串字面量是關閉的單引號或雙引號裏的零個或多個字符。每一個字符均可以用一個轉義序列表明。除了閉合銀行字符，反斜槓，回車，行分隔符，段落分隔符，換行符以外的全部字符均可以直接出現的字符串字面量裏。任何字符均可以經過轉移序列的形式出現。

語法

StringLiteral :: " DoubleStringCharactersopt " ' SingleStringCharactersopt 'DoubleStringCharacters :: DoubleStringCharacter DoubleStringCharactersoptSingleStringCharacters :: SingleStringCharacter SingleStringCharactersoptDoubleStringCharacter :: SourceCharacter but not double-quote " or backslash \ or LineTerminator \ EscapeSequence LineContinuationSingleStringCharacter :: SourceCharacter but not single-quote ' or backslash \ or LineTerminator \ EscapeSequence LineContinuationLineContinuation :: \ LineTerminatorSequenceEscapeSequence :: CharacterEscapeSequence 0 [lookahead ∉ DecimalDigit] HexEscapeSequence UnicodeEscapeSequenceCharacterEscapeSequence :: SingleEscapeCharacter NonEscapeCharacter SingleEscapeCharacter :: one of ' " \ b f n r t vNonEscapeCharacter :: SourceCharacter but not EscapeCharacter or LineTerminatorEscapeCharacter :: SingleEscapeCharacter DecimalDigit x uHexEscapeSequence :: x HexDigit HexDigitUnicodeEscapeSequence :: u HexDigit HexDigit HexDigit HexDigit

7.6 給出了 HexDigit 非終結符的定義。 第 6 章 定義了 SourceCharacter。

語義

一個字符串字面量表明一個 String 類型的值。字面量的字符串值 (SV) 由字符串字面量各部分貢獻的字符值 (CV) 描述。做爲這一過程的一部分，字符字面量裏的某些字符字符會被解釋成包含數學值 (MV)，如 7.8.3 和下面描述的。

• StringLiteral :: "" 的 SV 是空字符序列。
• StringLiteral :: 的 SV 是空字符序列。
• StringLiteral :: " DoubleStringCharacters " 的 SV 是 DoubleStringCharacters 的 SV。
• StringLiteral :: ' SingleStringCharacters ' 的 SV 是 SingleStringCharacters 的 SV。
• DoubleStringCharacters :: DoubleStringCharacter 的 SV 是包含一個字符的序列，此字符的 CV 是 DoubleStringCharacter 的 CV。
• DoubleStringCharacters :: DoubleStringCharacter DoubleStringCharacters 的 SV 是 （DoubleStringCharacter 的 CV 後面跟着 DoubleStringCharacters 的 SV 裏全部字符的）序列。
• SingleStringCharacters :: SingleStringCharacter 的 SV 是包含一個字符的序列，此字符的 CV 是 SingleStringCharacter 的 CV。
• SingleStringCharacters :: SingleStringCharacter SingleStringCharacters 的 SV 是（SingleStringCharacter 的 CV 後面跟着 SingleStringCharacters 的 SV 裏全部字符的）序列。
• LineContinuation :: \ LineTerminatorSequence 的 SV 是空字符序列。
• DoubleStringCharacter :: SourceCharacter but not double-quote " or backslash \ or LineTerminator 的 CV 是 SourceCharacter 字符自身。
• DoubleStringCharacter :: \ EscapeSequence 的 CV 是 EscapeSequence 的 CV。
• DoubleStringCharacter :: LineContinuation 的 CV 是空字符序列。
• SingleStringCharacter :: SourceCharacter but not single-quote ' or backslash \ or LineTerminator 的 CV 是 SourceCharacter 字符自身。
• SingleStringCharacter :: \ EscapeSequence 的 CV 是 EscapeSequence 的 CV。
• SingleStringCharacter :: LineContinuation 的 CV 是空字符序列。
• EscapeSequence :: CharacterEscapeSequence 的 CV 是 CharacterEscapeSequence 的 CV。
• EscapeSequence :: 0 [lookahead ∉ DecimalDigit] 的 CV 是 字符（Unicode 值 0000）。
• EscapeSequence :: HexEscapeSequence 的 CV 是 HexEscapeSequence 的 CV。
• EscapeSequence :: UnicodeEscapeSequence 的 CV 是 UnicodeEscapeSequence 的 CV。
• CharacterEscapeSequence ::SingleEscapeCharacter 的 CV 是表格 4 裏的 SingleEscapeCharacter 肯定的代碼單元值字符：字符串單字符轉義序列

  轉義序列	字符編碼值	名稱	符號
  \b	\u0008	回格	<BS>
  \t	\u0009	水平製表符	<HT>
  \n	\u000A	進行（新行）	<LF>
  \v	\u000B	豎直製表符	<VT>
  \f	\u000C	進紙	<FF>
  \r	\u000D	回車	<CR>
  \"	\u0022	雙引號	"
  \'	\u0027	單引號	'
  \\	\u005C	反斜槓	\

• CharacterEscapeSequence :: NonEscapeCharacter 的 CV 是 NonEscapeCharacter 的 CV.
• NonEscapeCharacter :: SourceCharacter but not EscapeCharacter or LineTerminator 的 CV 是 SourceCharacter 字符自身 .
• HexEscapeSequence :: x HexDigit HexDigit 的 CV 是 ((16 乘第一個 HexDigit 的 MV) 加第二個 HexDigit 的 MV) 代碼單元肯定的字符。
• UnicodeEscapeSequence :: u HexDigit HexDigit HexDigit HexDigit 的 CV 是 (4096 乘第一個 HexDigit 的 MV) 加 (256 乘第二個 HexDigit 的 MV) 加 (16 乘第三個 HexDigit 的 MV) 加 ( 第四個 HexDigit 的 MV) 代碼單元肯定的字符。

符合標準的實現，在處理嚴格模式代碼（見 10.1.1）時，按照 B.1.2 的描述，不得擴展 EscapeSequence 包含 OctalEscapeSequence 的語法。

行終結符不能出如今字符串字面量裏，除非它成爲 LineContinuation 的一部分產生空字符序列。讓字符串字面量的字符串值包含行終結符的正確方法是使用轉義序列，如 \n或 \u000A。

正則表達式字面量

正則表達式字面量是輸入元素，每當字面量被評估時會轉換爲 RegExp 對象（見 15.10）。當一個程序中有兩個正則表達式字面量評估成正則表達式對象，不能用 === 比較他們是否相等，即便兩個字面量包含相同內容。RegExp 對象也能夠在運行時使用 new RegExp（見 15.10.4）或以函數方式調用 RegExp 構造器來建立（見 15.10.3）。

下面的產生式描述了正則表達式字面量的語法，輸入元素掃描器還用它搜索正則表達式字面量的結束位置。RegularExpressionBody 和 RegularExpressionFlags 包含的字符組成的字符串會直接傳遞給正則表達式構造器，在那裏用更嚴格文法進行解析。一個實現能夠擴展正則表達式構造器的文法。但它不能擴展 RegularExpressionBody 和 RegularExpressionFlags 產生式或使用這些產生式的產生式。

語法

RegularExpressionLiteral :: / RegularExpressionBody / RegularExpressionFlagsRegularExpressionBody :: RegularExpressionFirstChar RegularExpressionCharsRegularExpressionChars :: [empty] RegularExpressionChars RegularExpressionCharRegularExpressionFirstChar :: RegularExpressionNonTerminator but not *or \or / or [ RegularExpressionBackslashSequence RegularExpressionClassRegularExpressionChar :: RegularExpressionNonTerminator but not \or / or [ RegularExpressionBackslashSequence RegularExpressionClassRegularExpressionBackslashSequence :: \ RegularExpressionNonTerminatorRegularExpressionNonTerminator :: SourceCharacter but not LineTerminatorRegularExpressionClass :: [ RegularExpressionClassChars ]RegularExpressionClassChars :: [empty] RegularExpressionClassChars RegularExpressionClassChar RegularExpressionClassChar :: RegularExpressionNonTerminator but not ]or \ RegularExpressionBackslashSequenceRegularExpressionFlags :: [empty] RegularExpressionFlags IdentifierPart

正則表達式字面量不能爲空；並非說正則表達式字面量不能表明空，字符 // 會啓動一個單行註釋。要指定一個空正則，使用：/(?:)/。

語義

正則表達式字面量會評估爲一個 Object 類型值，它是標準內置構造器 RegExp 的一個實例。此值取決於兩個步驟：首先，展開組成正則表達式產生式 RegularExpressionBody 和RegularExpressionFlags 的字符，將其以未解析形式分別存成兩個字符串 Pattern 和 Flags。而後，在每次評估字面量時建立新對象，彷彿使用 new RegExp(Pattern, Flags) 同樣，這裏的 RegExp 是標準內置構造器名。新構造的對象將成爲 RegularExpressionLiteral 的值。若是調用 new RegExp 會產生 15.10.4.1 指定的錯誤，那麼必須把錯誤看成是早期錯誤 ( 見 第 16 章 )。

自動分號插入

必須用分號終止某些 ECMAScript 語句 ( 空語句 , 變量聲明語句 , 表達式語句 , do-while 語句 , continue 語句 , break 語句 , return 語句 ,throw 語句 )。這些分號老是明確的顯示在源文本里。然而，爲了方便起見，某些狀況下這些分號能夠在源文本里省略。描述這種狀況會說：這種狀況下給源代碼的 token 流自動插入分號。

自動分號插入規則

分號插入有三個基本規則：

1. 左到右解析程序，當遇到一個不符合任何文法產生式的 token（叫作 違規 token(offending token)），那麼只要知足下面條件之一就在違規 token 前面自動插入分號。
   • 至少一個 LineTerminator 分割了違規 token 和前一個 token。
   • 違規 token 是 }。
2. 左到右解析程序，tokens 輸入流已經結束，當解析器沒法將輸入 token 流解析成單個完整 ECMAScript 程序 ，那麼就在輸入流的結束位置自動插入分號。
3. 左到右解析程序，遇到一個某些文法產生式容許的 token，可是此產生式是受限產生式，受限產生式的裏緊跟在 no LineTerminator here 後的第一個終結符或非終結符的 token 叫作受限的 token，當至少一個 LineTerminator 分割了受限的 token 和前一個 token，那麼就在受限 token 前面自動插入分號。

然而，上述規則有一個附加的優先條件：若是插入分號後解析結果是空語句，或若是插入分號後它成爲 for 語句頭部的兩個分號之一（見 12.6.3），那麼不會自動插入分號。

文法裏的受限產生式只限如下：

PostfixExpression : LeftHandSideExpression [no LineTerminator here] ++ LeftHandSideExpression [no LineTerminator here] -- ContinueStatement : continue [no LineTerminator here] Identifier; BreakStatement : break [no LineTerminator here] Identifier; ReturnStatement : return [no LineTerminator here] Expression; ThrowStatement : throw [no LineTerminator here] Expression;

這些受限產生式的實際效果以下：

當遇到的 ++ 或 --token 將要被解析器看成一個後綴運算符，而且至少有一個 LineTerminator 出現 ++ 或 --token 和它以前的 token 之間，那麼在 ++ 或 --token 前面自動插入一個分號。

當遇到 continue, break, return, throw token，而且在下一個 token 前面遇到 LineTerminator，那麼在 continue, break, return, throw token 後面自動插入一個分號。

這對 ECMAScript 程序員的實際影響是：

後綴運算符 ++ 或 -- 和它的操做數應該出如今同一行。

return 或 throw 語句的表達式開始位置應該和 return 或 throw token 同一行。

break 或 continue 語句的標示符應該和 break 或 continue token 同一行。

自動分號插入的例子

源代碼：

{ 1 2 } 3

即便在自動分號插入規則下，它也不符合 ECMAScript 文法。作爲對比，源代碼：

{ 1 2 } 3

它仍是不符合 ECMAScript 文法，可是它會被自動分號插入成爲一下形式：

{ 1  ;2 ;} 3;

這符合 ECMAScript 文法。

源代碼：

for (a; b )

不符合 ECMAScript 文法，而且不會被自動分號插入所更改，由於 for 語句頭部須要分號。自動分號插入歷來不會插入成 for 語句頭部的兩個分號之一。

源代碼：

return a + b

會被自動分號插入轉換成如下形式：

return; a + b;

表達式 a + b 不會被當作是 return 語句要返回的值，由於有一個 LineTerminator 分割了它和 return token。

源代碼：

a = b ++c

會被自動分號插入轉換成如下形式：

a = b; ++c;

++token 不會被當作應用於變量 b 的後綴運算符，由於 b 和 ++ 之間出現了一個 LineTerminator。

源代碼：

if (a > b) else c = d

它不符合 ECMAScript 文法 ，else token 前面不會被自動分號插入改變，即便沒有文法產生式適用這一位置，由於自動插入分號後會解析成空語句。

源代碼：

a = b + c (d + e).print()

它不會被自動分號插入改變，由於第二行開始位置的括號表達式能夠解釋成函數調用的參數列表：

a = b + c(d + e).print()

在賦值語句必須用左括號開頭的狀況下，程序員在前面語句的結束位置明確的提供一個分號是個好主意，而不是依賴於自動分號插入。

類型

本規範的算法操做各個有類型的值，可處理的類型在算法相關敘述中定義。類型又再分爲 ECMAScript 語言類型 與 規範類型 。

ECMAScript 語言類型 是 ECMAScript 程序員使用 ECMAScript 語言直接操做的值對應的類型。ECMAScript 語言類型包括 未定義 （Undefined）、 空值 （Null）、 布爾值（Boolean）、 字符串 （String）、 數值 （Number）、 對象 （Object）。

規範類型 是描述 ECMAScript 語言構造與 ECMAScript 語言類型語意的算法所用的元值對應的類型。規範類型包括 引用 、 列表 、 完結 、 屬性描述式 、 屬性標示 、 詞法環境（Lexical Environment）、 環境紀錄（Environment Record）。規範類型的值是不必定對應 ECMAScript 實現裏任何實體的虛擬對象。規範類型可用來描述 ECMAScript 表式運算的中途結果，可是這些值不能存成對象的變量或是 ECMAScript 語言變量的值。

在本規範中，咱們將「x 的類型」簡寫爲 Type(x) ，而類型指的就是上述的 ECMAScript 語言類型 與 規範類型 。

Undefined 類型

Undefined 類型有且只有一個值，稱爲 undefined 。任何沒有被賦值的變量都有 undefined 值。

Null 類型

Null 類型有且只有一個值，稱爲 null 。

Boolean 類型

Boolean 類型表示邏輯實體，有兩個值，稱爲 true 和 false。

String 類型

字符串類型是全部有限的零個或多個 16 位無符號整數值（「元素」）的有序序列。在運行的 ECMAScript 程序中，字符串類型常被用於表示文本數據，此時字符串中的每一個元素都被視爲一個代碼點（參看 章節 6）。 每一個元素都被認爲佔有此序列中的一個位置。用非負數值索引這些位置。任什麼時候候，第一個元素（若存在）在位置 0，下一個元素（若存在）在位置 1，依此類推。字符串的長度即其中元素的個數（好比，16 位值）。空字符串長度爲零，於是不包含任何元素。

若一個字符串包含實際的文本數據，每一個元素都被認爲是一個單獨的 UTF-16 單元。不管這是否是 String 實際的存儲格式，String 中的字符都被看成表示爲 UTF-16 來計數。除非特別聲明，做用在字符串上的全部操做都視它們爲無差異的 16 位無符號整數；這些操做不保證結果字符串仍爲常規化的形式，也不保證語言敏感結果。

這些決議背後的原理是儘量地保持字符串的實現簡單而高效。這意味着，在運行中的程序讀到從外部進入執行環境的文本數據（即，用戶輸入，從文件讀取文本 ，或從網絡上接收文本，等等）以前，它們已被轉爲 Unicode 常規化形式 C。一般狀況下，這個轉化在進入的文本被從其原始字符編碼轉爲 Unicode 的同時進行（且強制去除頭部附加信息）。所以，建議 ECMAScript 程序源代碼爲常規化形式 C，（若是保證源代碼文本是常規化的）保證字符串常量是常規化的，即使它們不包含任何 Unicode 轉義序列。

Number 類型

精確地，數值類型擁有 18437736874454810627（即，2⁶⁴-2⁵³ +3）個值，表示爲 IEEE-754 格式 64 位雙精度數值（IEEE 二進制浮點數算術中描述了它），除了 IEEE 標準中的 9007199254740990（即，2⁵³-2）個明顯的「非數字 」值；在 ECMAScript 中，它們被表示爲一個單獨的特殊值：NaN。（請注意，NaN 值由程序表達式 NaN 產生，並假設執行程序不能調整定義的全局變量 NaN。） 在某些實現中，外部代碼也許有能力探測出衆多非數字值之間的不一樣，但此類行爲依賴於具體實現；對於 ECMAScript 代碼而言，NaN 值相互之間沒法區別。

還有另外兩個特殊值，稱爲正無窮和負無窮。爲簡潔起見，在說明目的時，用符號 +∞ 和 -∞ 分別表明它們。（請注意，兩個無限數值由程序表達式 +Infinity（簡做Infinity） 和 -Infinity 產生，並假設執行程序不能調整定義的全局變量 Infinity。）

另外 18437736874454810624（即，2⁶⁴-2⁵³） 個值被稱爲有限數值。其中的一半是正數，另外一半是負數，對於每一個正數而言，都有一個與之對應的、相同規模的負數。

請注意，還有一個 正零 和一個 負零 。爲簡潔起見，相似地，在說明目的時，分別用用符號 +0 和 -0 表明這些值。（請注意，這兩個數字零由程序表達式 +0（簡做 0） 和-0 產生。）

這 18437736874454810622（即，2⁶⁴-2⁵³-2） 個有限非零值分爲兩種：

其中 18428729675200069632（即，2⁶⁴-2⁵⁴） 個是常規值，形如

s * m * 2e

這裏的 s 是 +1 或 -1，m 是一個小於 2⁵³ 但不小於 2⁵² 的正整數，e 是一個閉區間 -1074 到 971 中的整數。

剩下的 9007199254740990（即，2⁵³-2）個值是很是規的，形如

s * m * 2e

這裏的 s 是 +1 或 -1，m 是一個小於 2⁵² 的 正整數，e 爲 -1074

請注意，全部規模不超過 2⁵³ 的正整數和負整數均可被數值類型表示（不過，整數 0 有兩個呈現形式，+0 和 0）。

若是一個有限的數值非零且用來表達它（上文兩種形式之一）的整數 m 是奇數，則該數值有 奇數標記 (odd significand)。不然，它有 偶數標記 (even significand)。

在本規範中，當 x 表示一個精確的非零實數數學量（甚至能夠是無理數，好比 π）時，短語 "the number value for x" 意爲，如下面的方式選擇一個數字 值。考慮數值類型的全部有限值的集合（不包括 -0 和兩個被加入在數值類型中但不可呈現的值，即 21024（即 +1 * 2⁵³ * 2⁹⁷¹）和 -2¹⁰²⁴ （那是 -1 * 2⁵³ * 2⁹⁷¹）。選擇此集合 中值最接近 x 的一員，若集合中的兩值近似相等，那麼選擇有偶數標記的那個；爲此，2¹⁰²⁴ 和 -2¹⁰²⁴ 這兩個超額值被認爲有偶數標記。最終，若選擇 2¹⁰²⁴ ，用 +∞替換它；若選擇 -2¹⁰²⁴ ，用 -∞替換它；若選擇 +0，有且只有 x 小於零時，用 -0 替換它；其它任何被選取的值都不用改變。結果就是 x 的數字值。（此過程正是 IEEE-754"round to nearest" 模式對應的行爲。）

某些 ECMAScript 運算符僅涉及閉區間 -2³¹ 到 2³¹-1 的整數，或閉區間 0 到 2³²-1。這些運算符接受任何數值類型的值，不過，數值首先被轉換爲 2³² 個整數值中的一個。參見ToInt32 和 ToUint32 的 描述，分別在 章節 9.5 和 9.6 中。

Object 類型

Object 是一個屬性的集合。每一個屬性既能夠是一個命名的數據屬性，也能夠是一個命名的訪問器屬性，或是一個內部屬性：

• 命名的數據屬性（named data property）由一個名字與一個 ECMAScript 語言值和一個 Boolean 屬性集合組成
• 命名的訪問器屬性（named accessor property）由一個名字與一個或兩個訪問器函數，和一個 Boolean 屬性集合組成。訪問器函數用於存取一個與該屬性相關聯的 ECMAScript 語言值
• 內部屬性（internal property）沒有名字，且不能直接經過 ECMAScript 語言操做。內部屬性的存在純粹爲了規範的目的。

有兩種帶名字的訪問器屬性（非內部屬性）：get 和 put，分別對應取值和賦值。

Property 特性

本規範中的特性（Attributes）用於定義和解釋命名屬性（properties）的狀態。命名的數據屬性由一個名字關聯到一個下表中列出的特性 (attributes)

命名的數據屬性的特性

特性名稱	取值範圍	描述
[[Value]]	任何 ECMAScript 語言類型	經過讀 property 來取到該值
[[Writable]]	Boolean	若是爲 false，試圖經過 ECMAScript 代碼 [[Put]] 去改變該屬性的 [[Value]]，將會失敗
[[Enumerable]]	Boolean	若是爲 true，則該屬性可被 for-in 枚舉出來（參見 12.6.4），不然，該屬性不可枚舉。
[[Configurable]]	Boolean	若是爲 false，試圖刪除該屬性，改變該屬性爲訪問器屬性，或改變它的 attributes（和 [[Value]] 不一樣），都會失敗。

命名的訪問器屬性由一個名字關聯到一個下表中列出的特性 (attributes)

命名的訪問器屬性的特性

特性名稱	取值範圍	描述
[[Get]]	Object 或 Undefined	若是該值爲一個 Object 對象，那麼它必須是一個函數對象。每次有對該屬性進行 get 訪問時，該函數的內部方法 [[Call]]（8.6.2）會被一個空參數列表調用，以返回該屬性值
[[Set]]	Object 或 Undefined	若是該值爲一個 Object 對象，那麼它必須是一個函數對象。每次有對該屬性進行 set 訪問時，該函數的內部方法 [[Call]]（8.6.2）會被一個參數列表調用，這個參數列表包含分配的值做爲惟一的參數。property 的內部方法 [[Set]] 產生的影響可能會，但不是必須的，對隨後的 property 內部方法 [[Get]] 的調用返回結果產生影響。
[[Enumerable]]	/>Boolean	若是爲 true，則該屬性可被 for-in 枚舉出來（參見 12.6.4），不然，該屬性不可枚舉。
[[Configurable]]	/>Boolean	若是爲 false，試圖刪除該屬性，改變該屬性爲訪問器屬性，或改變它的 attributes（和 [[Value]] 不一樣），都會失敗。

若是某個命名屬性的特性值沒有在此規範中明確給出，那麼它的默認值將使用下表的定義。

默認特性值

特性名稱	默認值
[[Value]]	undefined
[[Get]]	undefined
[[Set]]	undefined
[[Writable]]	false
[[Enumerable]]	false
[[Configurable]]	false

Object 內部屬性及方法

本規範使用各類內部屬性來定義對象值的語義。這些內部屬性不是 ECMAScript 語言的一部分。本規範中純粹是以說明爲目的定義它們。ECMAScript 實現必須表現爲彷彿它被這裏描述的內部屬性產生和操做。內部屬性的名字用閉合雙方括號 括起來。若是一個算法使用一個對象的一個內部屬性，而且此對象沒有實現須要的內部屬性，那麼拋出TypeError 異常。

表 8 總結了本規範中適用於全部 ECMAScript 對象的內部屬性。表 9 總結了本規範中適用於某些 ECMAScript 對象的內部屬性。這些表中的描述若是沒有特別指出是特定的原生 ECMAScript 對象，那麼就說明了其在原生 ECMAScript 對象中的行爲。宿主對象的內部屬性能夠支持任何依賴於實現的行爲，只要其與本文檔說的宿主對象的個別限制一直。

下面表的「值的類域」一列定義了內部屬性關聯值的類型。類型名稱參考第 8 章定義的類型，做爲加強添加了一下名稱：「any」指值能夠是任何 ECMAScript 語言類型；「primitive」指 Undefined, Null, Boolean, String, , Number；「SpecOp」指內部屬性是一個內部方法，一個抽象操做規範定義一個實現提供它的步驟。「SpecOp」後面跟着描述性參數名的列表。若是參數名和類型名一致那麼這個名字用於描述參數的類型。若是「SpecOp」有返回值，那麼這個參數列表後跟着「→」符號和返回值的類型。

全部對象共有的內部屬性

內部屬性	取值範圍	說明
[[Prototype]]	Object 或 Null	此對象的原型
[[Class]]	String	說明規範定義的對象分類的一個字符串值
[[Extensible]]	Boolean	若是是 true，能夠向對象添加自身屬性。
[[Get]]	SpecOp(propertyName) → any	返回命名屬性的值
[[GetOwnProperty]]	SpecOp (propertyName) → Undefined 或 Property Descriptor	返回此對象的自身命名屬性的屬性描述，若是不存在返回 undefined
[[GetProperty]]	SpecOp (propertyName) → Undefined 或 Property Descriptor	返回此對象的徹底填入的自身命名屬性的屬性描述，若是不存在返回 undefined
[[Put]]	SpecOp (propertyName, any, Boolean)	將指定命名屬性設爲第二個參數的值。flog 控制失敗處理。
[[CanPut]]	SpecOp (propertyName) → Boolean	返回一個 Boolean 值，說明是否能夠在 PropertyName 上執行 [[Put]] 操做。
[[HasProperty]]	SpecOp (propertyName) → Boolean	返回一個 Boolean 值，說明對象是否含有給定名稱的屬性。
[[Delete]]	SpecOp (propertyName, Boolean) → Boolean	從對象上刪除指定的自身命名屬性。flog 控制失敗處理。
[[DefaultValue]]	SpecOp (Hint) → primitive	Hint 是一個字符串。返回對象的默認值
[[DefineOwnProperty]]	SpecOp (propertyName, PropertyDescriptor, Boolean) → Boolean	建立或修改自身命名屬性爲擁有屬性描述裏描述的狀態。flog 控制失敗處理。

全部對象（包括宿主對象）必須實現表 8 中列出的全部內部屬性。然而，對某些對象的 [[DefaultValue]] 內部方法，能夠簡單的拋出 TypeError 異常。

全部對象都有一個叫作 [[Prototype]] 的內部屬性。此對象的值是 null 或一個對象，而且它用於實現繼承。一個原生屬性是否能夠把宿主對象做爲它的 [[Prototype]] 取決於實現。全部 [[Prototype]] 鏈必須是有限長度（即，從任何對象開始，遞歸訪問 [[Prototype]] 內部屬性必須最終到頭，而且值是 null）。從 [[Prototype]] 對象繼承來的命名數據屬性（做爲子對象的屬性可見）是爲了 get 請求，但沒法用於 put 請求。命名訪問器屬性會把 get 和 put 請求都繼承。

全部 ECMASCript 對象都有一個 Boolean 值的 [[Extensible]] 內部屬性，它控制是否能夠給對象添加命名屬性。若是 [[Extensible]] 內部屬性的值是 false 那麼不得給對象添加命名屬性。此外，若是 [[Extensible]] 是 false 那麼不得更改對象的 [[Class]] 和 [[Prototype]] 內部屬性的值。一旦 [[Extensible]] 內部屬性的值設爲 false 以後沒法再更改成 true。

本規範的定義中沒有 ECMAScript 語言運算符或內置函數容許一個程序更改對象的 [[Class]] 或 [[Prototype]] 內部屬性或把 [[Extensible]] 的值從 false 更改爲 true。實現中修改 [[Class]], [[Prototype]], [[Extensible]] 的個別擴展必須不違反前一段定義的不變量。

本規範的每種內置對象都定義了 [[Class]] 內部屬性的值。宿主對象的 [[Class]] 內部屬性的值能夠是除了 "Arguments", "Array", "Boolean", "Date", "Error", "Function", "JSON", "Math", "Number", "Object", "RegExp", "String" 的任何字符串。[[Class]] 內部屬性的值用於內部區分對象的種類。注，本規範中除了經過 Object.prototype.toString ( 見 15.2.4.2) 沒有提供任何手段使程序訪問此值。

除非特別指出，原生 ECMAScrpit 對象的公共內部方法的行爲描述在 8.12。Array 對象的 [[DefineOwnProperty]] 內部方法有稍不一樣的實現（見 15.4.5.1），又有 String 對象的 [[GetOwnProperty]] 內部方法有稍不一樣的實現（見 15.5.5.2）。Arguments 對象（10.6）的 [[Get]]，[[GetOwnProperty]]，[[DefineOwnProperty]]，[[Delete]] 有不一樣的實現。Function 對象（15.3）的 [[Get]] 的有不一樣的實現。

除非特別指出，宿主對象能夠以任何方式實現這些內部方法，一種多是一個特別的宿主對象的 [[Get]] 和 [[Put]] 確實能夠存取屬性值，但 [[HasProperty]] 老是產生 false。然而，若是任何對宿主對象內部屬性的操做不被實現支持，那麼當試圖操做時必須拋出 TypeError 異常。

宿主對象的 [[GetOwnProperty]] 內部方法必須符合宿主對象每一個屬性的如下不變量 ：

• 若是屬性是描述過的數據屬性，並隨着時間的推移，它可能返回不一樣的值，那麼即便沒有暴露提供更改值機制的其餘內部方法，[[Writable]] 和 [[Configurable]] 之一或所有必須是 true。
• 若是屬性是描述過的數據屬性，而且其 [[Writable]] 和 [[Configurable]] 都是 false。那麼全部對 [[GetOwnProperty]] 的呼出，必須返回做爲屬性 [[Value]] 特性的SameValue(9.12)。
• 若是 [[Writable]] 特性能夠從 false 更改成 true，那麼 [[Configurable]] 特性必須是 true。
• 當 ECMAScript 代碼監測到宿主對象的 [[Extensible]] 內部屬性值是 false。那麼若是調用 [[GetOwnProperty]] 描述一個屬性是不存在，那麼接下來全部調用這個屬性必須也描述爲不存在。

若是 ECMAScript 代碼監測到宿主對象的 [[Extensible]] 內部屬性是 false，那麼這個宿主對象的 [[DefineOwnProperty]] 內部方法不容許向宿主對象添加新屬性。

若是 ECMAScript 代碼監測到宿主對象的 [[Extensible]] 內部屬性是 false，那麼它之後必須不能再改成 true。

只在某些對象中定義的內部屬性 Object

內部屬性	取值範圍	說明
[[PrimitiveValue]]	primitive	與此對象的內部狀態信息關聯。對於標準內置對象只能用 Boolean, Date, Number, String 對象實現 [[PrimitiveValue]]。
[[Construct]]	SpecOp(a List of any) → Object	經過 new 運算符調，建立對象。SpecOp 的參數是經過 new 運算符傳的參數。實現了這個內部方法的對象叫作 構造器 。
[[Call]]	SpecOp(any, a List of any) → any or Reference	運行與此對象關聯的代碼。經過函數調用表達式調用。SpecOp 的參數是一個 this 對象和函數調用表達式傳來的參數組成的列表。實現了這個內部方法的對象是 可調用 的。只有做爲宿主對象的可調用對象纔可能返回 引用 值。
[[HasInstance]]	SpecOp(any) → Boolean	返回一個表示參數對象是否多是由本對象構建的布爾值。在標準內置 ECMAScript 對象中只有 Function 對象實現 [[HasInstance]]。
[[Scope]]	Lexical Environment	一個定義了函數對象執行的環境的詞法環境。在標準內置 ECMAScript 對象中只有 Function 對象實現 [[Scope]]。
[[FormalParameters]]	List of Strings	一個包含 Function 的 FormalParameterList 的標識符字符串的多是空的列表。在標準內置 ECMAScript 對象中只有 Function 對象實現 [[FormalParameterList]]。
[[Code]]	ECMAScript code	函數的 ECMAScript 代碼。在標準內置 ECMAScript 對象中只有 Function 對象實現 [[Code]]。
[[TargetFunction]]	Object	使用標準內置的 Function.prototype.bind 方法建立的函數對象的目標函數。只有使用 Function.prototype.bind 建立的 ECMAScript 對象纔有 [[TargetFunction]] 內部屬性。
[[BoundThis]]	any	使用標準內置的 Function.prototype.bind 方法建立的函數對象的預綁定的 this 值。只有使用 Function.prototype.bind 建立的 ECMAScript 對象纔有 [[BoundThis]] 內部屬性。
[[BoundArguments]]	List of any	使用標準內置的 Function.prototype.bind 方法建立的函數對象的預綁定的參數值。只有使用 Function.prototype.bind 建立的 ECMAScript 對象纔有 [[BoundArguments]] 內部屬性。
[[Match]]	SpecOp(String, index) → MatchResult	測試正則匹配並返回一個 MatchResult 值（見 15.10.2.1）。在標準內置 ECMAScript 對象中只有 RegExp 對象實現 [[Match]]。
[[ParameterMap]]		提供參數對象的屬性和函數關聯的形式參數之間的映射。只有參數對象纔有 [[ParameterMap]] 內部屬性。

引用規範類型

引用類型用來講明 delete，typeof，賦值運算符這些運算符的行爲。例如，在賦值運算中左邊的操做數指望產生一個引用。經過賦值運算符左側運算子的語法案例分析能夠但不能徹底解釋賦值行爲，還有個難點：函數調用容許返回引用。認可這種可能性純粹是爲了宿主對象。本規範沒有定義返回引用的內置 ECMAScript 函數，而且也不提供返回引用的用戶定義函數。（另外一個不使用語法案列分析的緣由是，那樣將會影響規範的不少地方，冗長而且彆扭。）

一個 引用 (Reference) 是個已解決的命名綁定。一個引用由三部分組成， 基 (base) 值， 引用名稱（referenced name） 和布爾值 嚴格引用 (strict reference) 標誌。基值是 undefined, 一個 Object, 一個 Boolean, 一個 String, 一個 Number, 一個 environment record 中的任意一個。基值是 undefined 表示此引用能夠不解決一個綁定。引用名稱是一個字符串。

本規範中使用如下抽象操做接近引用的組件：

• GetBase(V)。 返回引用值 V 的基值組件。
• GetReferencedName(V)。 返回引用值 V 的引用名稱組件。
• IsStrictReference(V)。 返回引用值 V 的嚴格引用組件。
• HasPrimitiveBase(V)。 若是基值是 Boolean, String, Number，那麼返回 true。
• IsPropertyReference(V)。 若是基值是個對象或 HasPrimitiveBase(V) 是 true，那麼返回 true；不然返回 false。
• IsUnresolvableReference(V)。 若是基值是 undefined 那麼返回 true，不然返回 false。

本規範使用如下抽象操做來操做引用：

GetValue(v)

1. 若是 Type(V) 不是引用 , 返回 V。
2. 令 base 爲調用 GetBase(V) 的返回值。
3. 若是 IsUnresolvableReference(V), 拋出一個 ReferenceError 異常。
4. 若是 IsPropertyReference(V), 那麼
   1. 若是 HasPrimitiveBase(V) 是 false, 那麼令 get 爲 base 的 [[Get]] 內部方法 , 不然令 get 爲下面定義的特殊的 [[Get]] 內部方法。
   2. 將 base 做爲 this 值，傳遞 GetReferencedName(V) 爲參數，調用 get 內部方法，返回結果。
5. 不然 , base 必須是一個 environment record。
6. 傳遞 GetReferencedName(V) 和 IsStrictReference(V) 爲參數調用 base 的 GetBindingValue( 見 10.2.1) 具體方法，返回結果。

GetValue 中的 V 是原始基值的 屬性引用 時使用下面的 [[Get]] 內部方法。它用 base 做爲他的 this 值，其中屬性 P 是它的參數。採用如下步驟：

1. 令 O 爲 ToObject(base)。
2. 令 desc 爲用屬性名 P 調用 O 的 [[GetProperty]] 內部方法的返回值。
3. 若是 desc 是 undefined，返回 undefined。
4. 若是 IsDataDescriptor(desc) 是 true，返回 desc.[[Value]]。
5. 不然 IsAccessorDescriptor(desc) 必須是 true，令 getter 爲 desc.[[Get]]。
6. 若是 getter 是 undefined，返回 undefined。
7. 提供 base 做爲 this 值，無參數形式調用 getter 的 [[Call]] 內部方法，返回結果。

上述方法以外沒法訪問在第一步建立的對象。實現能夠選擇不真的建立這個對象。使用這個內部方法給實際屬性訪問產生可見影響的狀況只有在調用訪問器函數時。

PutValue(v,w)

1. 若是 Type(V) 不是引用，拋出一個 ReferenceError 異常。
2. 令 base 爲調用 GetBase(V) 的結果。
3. 若是 IsUnresolvableReference(V)，那麼
   1. 若是 IsStrictReference(V) 是 true，那麼
      1. 拋出 ReferenceError 異常。
   2. 用 GetReferencedName(V)，W，false 做爲參數調用全局對象的 [[Put]] 內部方法。
4. 不然若是 IsPropertyReference(V)，那麼
   1. 若是 HasPrimitiveBase(V) 是 false，那麼令 put 爲 base 的 [[Put]] 內部方法，不然令 put 爲下面定義的特殊的 [[Put]] 內部方法。
   2. 用 base 做爲 this 值，用 GetReferencedName(V)，W，IsStrictReference(V) 做爲參數調用 put 內部方法。
5. 不然 base 一定是 environment record 做爲 base 的引用。因此，
   1. 用 GetReferencedName(V), W, IsStrictReference(V) 做爲參數調用 base 的 SetMutableBinding (10.2.1) 具體方法。
6. 返回。

PutValue 中的 V 是原始基值的屬性引用時使用下面的 [[Put]] 內部方法。用 base 做爲 this 值，用屬性 P，值 W，布爾標誌 Throw 做爲參數調用它。採用如下步驟：

1. 令 O 爲 ToObject(base)。
2. 若是用 P 做爲參數調用 O 的 [[CanPut]] 內部方法的結果是 false，那麼
   1. 若是 Throw 是 true，那麼拋出一個 TypeError 異常。
   2. 不然返回。
3. 令 ownDesc 爲用 P 做爲參數調用 O 的 [[GetOwnProperty]] 內部方法的結果。
4. 若是 IsDataDescriptor(ownDesc) 是 true，那麼
   1. 若是 Throw 是 true，那麼拋出一個 TypeError 異常。
   2. 不然返回。
5. 令 desc 爲用 P 做爲參數調用 O 的 [[GetProperty]] 內部方法的結果。這多是一個自身或繼承的訪問器屬性描述或是一個繼承的數據屬性描述。
6. 若是 IsAccessorDescriptor(desc) 是 true，那麼
   1. 令 setter 爲 desc.Set，他不能是 undefined。
   2. 用 base 做爲 this 值，用只由 W 組成的列表做爲參數調用 setter 的 [[Call]] 內部方法。
7. 不然，這是要在臨時對象 O 上建立自身屬性的請求。
   1. 若是 Throw 是 true，拋出一個 TypeErroe 異常。
8. 返回。

上述方法以外沒法訪問在第一步建立的對象。實現能夠選擇不真的建立這個臨時對象。使用這個內部方法給實際屬性訪問產生可見影響的狀況只有在調用訪問器函數時，或 Throw 未經過提早錯誤檢查。當 Throw 是 true，試圖在這個臨時對象上建立新屬性的任何屬性分配操做會拋出一個錯誤。

列表規範類型

列表類型用於說明 new 表達式，函數調用，其餘須要值的簡單列表的算法 -- 裏的參數列表的計算。列表類型的值是簡單排序的一些值的序列。此序列能夠是任意長度。

完結規範類型

完結類型用於說明執行將控制轉移到外部的聲明 (break, continue, return, throw) 的行爲。完結類型的值是由三部分組成，形如（type，value，target），其中 type 是 normal, break, continue, return, throw 之一，value 是任何 ECMASCript 語言值或 empty，target 是任何 ECMAScript 標識符或 empty。

術語「忽然完結（abrupt completion）」是指任何非正常完成的完成類型。

屬性描述符及屬性標識符規範類型

屬性描述符類型是用來解釋命名屬性的具體的操做的特性集。屬性描述符類型的值是記錄項，由命名字段組成，每一個字段的名稱是一個特性名而且它的值是一個相應的特性值，這些特性指定在 8.6.1。此外，任何字段均可能存在或不存在。

根據是否存在或使用了某些字段，屬性描述符的值可進一步劃分爲數據屬性描述符和訪問器屬性描述符。一個數據屬性描述符 裏包括叫作 [[Value]] 或 [[Writable]] 的字段。一個訪問器屬性描述符裏包括叫作 [[Get]] 或 [[Set]] 的字段。任何屬性描述均可能有名爲 [[Enumerable]] 和 [[Configurable]] 的字段。一個屬性描述符不能同時是數據屬性描述符和訪問器屬性描述符；可是，它可能兩者都不是。一個通用屬性描述符是，既不是數據屬性描述符也不是訪問器屬性描述符的屬性描述符值。一個徹底填充屬性描述符是訪問器屬性描述符或數據屬性描述符，而且擁有 8.6.1 Table 5 或 Table 6 裏定義的全部屬性特性對應的字段。

本規範中爲了便於標記，使用一種相似對象字面量的語法來定義屬性描述符。例如，屬性描述符 {[[Value]]: 42, [[Writable]]: false, [[Configurable]]: true}，就定義了一個數據屬性描述符。字段名稱的順序並不重要。任何沒有明確列出的字段被認爲是不存在的。

在規範中的文本和算法裏，可用點符號來指明一個屬性描述符的特定字段。例如，若是 D 是一個屬性描述符，那麼 D.[[Value]] 是「D 的 [[Value]] 字段」的簡寫。

屬性標識符類型用於關聯屬性名稱與屬性描述符。屬性標識符類型的值是 (name, descriptor) 形式的一對值，其中 name 是一個字符串和 descriptor 是一個屬性描述符值。

在本規範中使用如下的抽象操做來操做屬性描述符值：

IsAccessorDescriptor (Desc)

當用屬性描述 Desc 調用抽象操做 IsAccessorDescriptor，採用如下步驟：

1. 若是 Desc 是 undefined，那麼返回 false。
2. 若是 Desc.[[Get]] 和 Desc.[[Set]] 都不存在，則返回 false。
3. 返回 true。

IsDataDescriptor (Desc)

當用屬性描述 Desc 調用抽象操做 IsDataDescriptor，採用如下步驟：

1. 若是 Desc 是 undefined，那麼返回 false。
2. 若是 Desc.[[Value]] 和 Desc.[[Writable]] 都不存在，則返回 false。
3. 返回 true。

IsGenericDescriptor (Desc)

當用屬性描述 Desc 調用抽象操做 IsDataDescriptor，採用如下步驟：

1. 若是 Desc 是 undefined，那麼返回 false。
2. 若是 IsAccessorDescriptor(Desc) 和 IsDataDescriptor(Desc) 都是 false, 則返回 true。
3. 返回 false。

FromPropertyDescriptor (Desc)

當用屬性描述 Desc 調用抽象操做 FromPropertyDescriptor，採用如下步驟：

假定如下算法的 Desc 是 [[GetOwnProperty]]( 見 8.12.1) 返回的徹底填充的 屬性描述。

1. 若是 Desc 是 undefined，那麼返回 false。
2. 令 obj 爲彷彿使用 new Object() 表達式建立的新對象，這裏的 Object 是標準內置構造器名。
3. 若是 IsDataDescriptor(Desc) 是 true，則
   1. 用參數 "value", 屬性描述符 {[[Value]]: Desc.[[Value]], [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, false 調用 obj 的 [[DefineOwnProperty]] 內部方法。
   2. 用參數 "writable", 屬性描述符 {[[Value]]: Desc.[[Writable]], [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, false 調用 obj 的 [[DefineOwnProperty]] 內部方法。
4. 不然，IsAccessorDescriptor(Desc) 一定是 true，因此
   1. 用參數 "get", 屬性描述符 {[[Value]]: Desc.[[Get]], [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, false 調用 obj 的 [[DefineOwnProperty]] 內部方法。
   2. 用參數 "set", 屬性描述符 {[[Value]]: Desc.[[Set]], [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, false 調用 obj 的 [[DefineOwnProperty]] 內部方法。
5. 用參數 "enumerable", 屬性描述符 {[[Value]]: Desc.[[Enumerable]], [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, false 調用 obj 的 [[DefineOwnProperty]] 內部方法。
6. 用參數 "configurable", 屬性描述符 {[[Value]]: Desc.[[Configurable]], [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, false 調用 obj 的 [[DefineOwnProperty]] 內部方法。
7. 返回 obj。

ToPropertyDescriptor (Obj)

當用對象 Desc 調用抽象操做 FromPropertyDescriptor，採用如下步驟：

1. 若是 Type(Obj) 不是 Object，拋出一個 TypeError 異常。
2. 令 desc 爲建立初始不包含字段的新屬性描述的結果。
3. 若是用參數 "enumerable" 調用 Obj 的 [[HasProperty]] 內部方法的結果是 true，則
   1. 令 enum 爲用參數 "enumerable" 調用 Obj 的 [[Get]] 內部方法的結果。
   2. 設定 desc 的 [[Enumerable]] 字段爲 ToBoolean(enum)。
4. 若是參數 "configurable" 調用 Obj 的 [[HasProperty]] 內部方法的結果是 true，則
   1. 令 conf 爲用參數 "enumerable" 調用 Obj 的 [[Get]] 內部方法的結果。
   2. 設定 desc 的 [[Configurable]] 字段爲 ToBoolean(conf)。
5. 若是參數 "value" 調用 Obj 的 [[HasProperty]] 內部方法的結果是 true，則
   1. 令 value 爲用參數 "value" 調用 Obj 的 [[Get]] 內部方法的結果。
   2. 設定 desc 的 [[Value]] 字段爲 value。
6. 若是參數 "writable" 調用 Obj 的 [[HasProperty]] 內部方法的結果是 true，則
   1. 令 writable 爲用參數 "writable" 調用 Obj 的 [[Get]] 內部方法的結果。
   2. 設定 desc 的 [[Writable]] 字段爲 ToBoolean(writable)。
7. 若是參數 "get" 調用 Obj 的 [[HasProperty]] 內部方法的結果是 true，則
   1. 令 getter 爲用參數 "get" 調用 Obj 的 [[Get]] 內部方法的結果。
   2. 若是 IsCallable(getter) 是 false 而且 getter 不是 undefined，則拋出一個 TypeError 異常。
   3. 設定 desc 的 [[Get]] 字段爲 getter。
8. 若是參數 "set" 調用 Obj 的 [[HasProperty]] 內部方法的結果是 true，則
   1. 令 setter 爲用參數 "set" 調用 Obj 的 [[Get]] 內部方法的結果。
   2. 若是 IsCallable(setter) 是 false 而且 setter 不是 undefined，則拋出一個 TypeError 異常。
   3. 設定 desc 的 [[Set]] 字段爲 Setter。
9. 若是存在 desc.[[Get]] 或 desc.[[Set]]，則
   1. 若是存在 desc.[[Value]] 或 desc.[[Writable]]，則拋出一個 TypeError 異常。
10. 返回 desc

詞法環境和環境記錄項規範類型

詞法環境和環境記錄項類型用於說明在嵌套的函數或塊中的名稱解析行爲。這些類型和他們的操做定義在第 10 章。

對象內部方法的算法

在如下算法說明中假定 O 是一個原生 ECMAScript 對象，P 是一個字符串，Desc 是一個屬性說明記錄，Throw 是一個布爾標誌。

[[GetOwnProperty]](P)

當用屬性名 P 調用 O 的 [[GetOwnProperty]] 內部方法，採用如下步驟：

1. 若是 O 不包含名爲 P 的自身屬性，返回 undefined。
2. 令 D 爲無字段的新建屬性描述。
3. 令 X 爲 O 的名爲 P 的自身屬性。
4. 若是 X 是數據屬性，則
   1. 設定 D.[[Value]] 爲 X 的 [[Value]] 特性值。
   2. 設定 D.[[Writable]] 爲 X 的 [[Writable]] 特性值。
5. 不然 X 是訪問器屬性，因此
   1. 設定 D.[[Get]] 爲 X 的 [[Get]] 特性值。
   2. 設定 D.[[Set]] 爲 X 的 [[Set]] 特性值。
6. 設定 D.[[Enumerable]] 爲 X 的 [[Enumerable]] 特性值。
7. 設定 D.[[Configurable]] 爲 X 的 [[Configurable]] 特性值。
8. 返回 D。

然而，若是 O 是一個字符串對象，關於其 [[GetOwnProperty]] 的更多闡述定義在 15.5.5.2。

[[GetProperty]] (P)

當用屬性名 P 調用 O 的 [[GetProperty]] 內部方法，採用如下步驟：

1. 令 prop 爲用屬性名 P 調用 O 的 [[GetOwnProperty]] 內部方法的結果。
2. 若是 prop 不是 undefined，返回 prop。
3. 令 proto 爲 O 的 [[Prototype]] 內部屬性值。
4. 若是 proto 是 null，返回 undefined。
5. 用參數 P 調用 proto 的 [[GetProperty]] 內部方法，返回結果。

[[Get]] (P)

當用屬性名 P 調用 O 的 [[Get]] 內部方法，採用如下步驟：

1. 令 desc 爲用屬性名 P 調用 O 的 [[GetProperty]] 內部方法的結果。
2. 若是 desc 是 undefined，返回 undefined。
3. 若是 IsDataDescriptor(desc) 是 true，返回 desc.[[Value]]。
4. 不然，IsAccessorDescriptor(desc) 一定是真，因此，令 getter 爲 desc.[[Get]]。
5. 若是 getter 是 undefined，返回 undefined。
6. 用 O 做爲 this，無參數調用 getter 的 [[Call]] 內部方法，返回結果。

[[CanPut]] (P)

當用屬性名 P 調用 O 的 [[CanPut]] 內部方法，採用如下步驟：

1. 令 desc 爲用參數 P 調用 O 的 [[GetOwnProperty]] 內部方法的結果。
2. 若是 desc 不是 undefined，則
   1. 若是 IsAccessorDescriptor(desc) 是 true，則
      1. 若是 desc.[[Set]] 是 undefined，則返回 false。
      2. 不然返回 true。
   2. 不然，desc 一定是 DataDescriptor，因此返回 desc.[[Writable]] 的值。
3. 令 proto 爲 O 的 [[Prototype]] 內部屬性。
4. 若是 proto 是 null，則返回 O 的 [[Extensible]] 內部屬性的值。
5. 令 inherited 爲用屬性名 P 調用 proto 的 [[GetProperty]] 內部方法的結果。
6. 若是 inherited 是 undefined，返回 O 的 [[Extensible]] 內部屬性的值。
7. 若是 IsAccessorDescriptor(inherited) 是 true，則
   1. 若是 inherited.[[Set]] 是 undefined，則返回 false。
   2. 不然返回 true。
8. 不然，inherited 一定是 DataDescriptor
   1. 若是 O 的 [[Extensible]] 內部屬性是 false，返回 false。
   2. 不然返回 inherited.[[Writable]] 的值。

宿主對象能夠定義受額外約束的 [[Put]] 操做。若是可能，宿主對象不該該在 [[CanPut]] 返回 false 的狀況下容許 [[Put]] 操做。

[[Put]] (P, V, Throw)

當用屬性名 P，值 V，布爾值 Throw 調用 O 的 [[Put]] 內部方法，採用如下步驟：

1. 若是用參數 P 調用 O 的 [[CanPut]] 內部方法的結果是 false，則
   1. 若是 Throw 是 true，則拋出一個 TypeError 異常。
   2. 不然返回。
2. 令 ownDesc 爲用參數 P 調用 O 的 [[GetOwnProperty]] 內部方法的結果。
3. 若是 IsDataDescriptor(ownDesc) 是 true，則
   1. 令 valueDesc 爲屬性描述 {[[Value]]: V}。
   2. 用參數 P，valueDesc，Throw 調用 O 的 [[DefineOwnProperty]] 內部方法。
   3. 返回。
4. 令 desc 爲用參數 P 調用 O 的 [[GetProperty]] 內部方法的結果。這多是自身或繼承的訪問器屬性描述或者是繼承的數據屬性描述。
5. 若是 IsAccessorDescriptor(desc) 是 true，則
   1. 令 setter 爲不是 undefined 的 desc.[[Set]]。
   2. 用 O 做爲 this，V 做爲惟一參數調用 setter 的 [[Call]] 內部方法。
6. 不然，按照如下步驟在對象 O 上建立名爲 P 的命名數據屬性。
   1. 令 newDesc 爲屬性描述 {[[Value]]: V, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}。
   2. 用參數 P, newDesc, Throw 調用 O 的 [[DefineOwnProperty]] 內部方法。
7. 返回。

[[HasProperty]] (P)

當用屬性名 P 調用 O 的 [[HasProperty]] 內部方法，採用如下步驟：

1. 令 desc 爲用屬性名 P 調用 O 的 [[GetProperty]] 內部方法的結果。
2. 若是 desc 是 undefined，則返回 false。
3. 不然返回 true。

[[Delete]] (P, Throw)

當用屬性名 P 和布爾值 Throw 調用 O 的 [[Delete]] 內部方法，採用如下步驟：

1. 令 desc 爲用屬性名 P 調用 O 的 [[GetOwnProperty]] 內部方法的結果。
2. 若是 desc 是 undefined，則返回 true。
3. 若是 desc.[[Configurable]] 是 true，則
   1. 在 O 上刪除名爲 P 的自身屬性。
   2. 返回 true。
4. 不然若是 Throw，則拋出一個 TypeError 異常。
5. 返回 false。

[[DefaultValue]] (hint)

當用字符串 hint 調用 O 的 [[DefaultValue]] 內部方法，採用如下步驟：

1. 令 toString 爲用參數 "toString" 調用對象 O 的 [[Get]] 內部方法的結果。
2. 若是 IsCallable(toString) 是 true，則
   1. 令 str 爲用 O 做爲 this 值，空參數列表調用 toString 的 [[Call]] 內部方法的結果。
   2. 若是 str 是原始值，返回 str。
3. 令 valueOf 爲用參數 "valueOf" 調用對象 O 的 [[Get]] 內部方法的結果。
4. 若是 IsCallable(valueOf) 是 true，則
   1. 令 val 爲用 O 做爲 this 值，空參數列表調用 valueOf 的 [[Call]] 內部方法的結果。
   2. 若是 val 是原始值，返回 val。
5. 拋出一個 TypeError 異常。

當用數字 hint 調用 O 的 [[DefaultValue]] 內部方法，採用如下步驟：

1. 令 valueOf 爲用參數 "valueOf" 調用對象 O 的 [[Get]] 內部方法的結果。
2. 若是 IsCallable(valueOf) 是 true，則
   1. 令 val 爲用 O 做爲 this 值，空參數列表調用 valueOf 的 [[Call]] 內部方法的結果。
   2. 若是 val 是原始值，返回 val。
3. 令 toString 爲用參數 "toString" 調用對象 O 的 [[Get]] 內部方法的結果。
4. 若是 IsCallable(toString) 是 true，則
   1. 令 str 爲用 O 做爲 this 值，空參數列表調用 toString 的 [[Call]] 內部方法的結果。
   2. 若是 str 是原始值，返回 str。
5. 拋出一個 TypeError 異常。

當不用 hint 調用 O 的 [[DefaultValue]] 內部方法，O 是 Date 對象的狀況下彷彿 hint 是字符串同樣解釋它的行爲，除此以外彷彿 hint 是數字同樣解釋它的行爲。

上面說明的 [[DefaultValue]] 在原生對象中只能返回原始值。若是一個宿主對象實現了它自身的 [[DefaultValue]] 內部方法，那麼必須確保其 [[DefaultValue]] 內部方法只能返回原始值。

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

在如下算法中，術語「拒絕」指代「若是 Throw 是 true，則拋出 TypeError 異常，不然返回 false。算法包含測試具體值的屬性描述 Desc 的各類字段的步驟。這種方式測試的字段事實上不須要真的在 Desc 裏。若是一個字段不存在則將其值看做是 false。

當用屬性名 P，屬性描述 Desc，布爾值 Throw 調用 O 的 [[DefineOwnProperty]] 內部方法，採用如下步驟：

1. 令 current 爲用屬性名 P 調用 O 的 [[GetOwnProperty]] 內部屬性的結果。
2. 令 extensible 爲 O 的 [[Extensible]] 內部屬性值。
3. 若是 current 是 undefined 而且 extensible 是 false，則拒絕。
4. 若是 current 是 undefined 而且 extensible 是 true，則
   1. 若是 IsGenericDescriptor(Desc) 或 IsDataDescriptor(Desc) 是 true，則
      1. 在 O 上建立名爲 P 的自身數據屬性，Desc 描述了它的 [[Value]], [[Writable]], [[Enumerable]]，[[Configurable]] 特性值。若是 Desc 的某特性字段值不存在，那麼設定新建屬性的此特性爲默認值。
   2. 不然，Desc 一定是訪問器屬性描述，因此
      1. 在 O 上建立名爲 P 的自身訪問器屬性，Desc 描述了它的 [[Get]], [[Set]], [[Enumerable]], [[Configurable]] 特性值。若是 Desc 的某特性字段值不存在，那麼設定新建屬性的此特性爲默認值。
5. 若是 Desc 不存在任何字段，返回 true。
6. 若是 Desc 的任何字段都出如今 current 中，而且用 SameValue 算法比較 Desc 中每一個字段值和 current 裏對應字段值，結果相同，則返回 true。
7. 若是 current 的 [[Configurable]] 字段是 false，則
   1. 若是 Desc 的 [[Configurable]] 字段是 true，則拒絕。
   2. 若是 Desc 有 [[Enumerable]] 字段，而且 current 和 Desc 的 [[Enumerable]] 字段相互布爾否認，則拒絕。
8. IsGenericDescriptor(Desc) 是 true，則不須要進一步驗證。
9. 不然，若是 IsDataDescriptor(current) 和 IsDataDescriptor(Desc) 的結果不一樣，則
   1. 若是 current 的 [[Configurable]] 字段是 false，則拒絕。
   2. 若是 IsDataDescriptor(current) 是 true，則
      1. 將對象 O 的名爲 P 的數據屬性轉換爲訪問器屬性。保留轉換屬性的 [[Configurable]] 和 [[Enumerable]] 特性的現有值，而且設定屬性的其他特性爲其默認值。
   3. 不然
      1. 將對象 O 的名爲 P 的訪問器屬性轉換爲數據屬性。保留轉換屬性的 [[Configurable]] 和 [[Enumerable]] 特性的現有值，而且設定屬性的其他特性爲其默認值。
10. 不然，若是 IsDataDescriptor(current) 和 IsDataDescriptor(Desc) 都是 true，則
    1. 若是 current 的 [[Configurable]] 字段是 false，則
       1. 若是 current 的 [[Writable]] 字段是 false 而且 Desc 的 [[Writable]] 字段是 true，則拒絕。
       2. 若是 current 的 [[Writable]] 字段是 false，則
          1. 若是 Desc 有 [[Value]] 字段，而且 SameValue(Desc.[[Value]], current.[[Value]]) 是 false，則拒絕。
    2. 不然，current 的 [[Configurable]] 字段是 true，因此可接受任何更改。
11. 不然 IsAccessorDescriptor(current) 和 IsAccessorDescriptor(Desc) 都是 true，因此
    1. 若是 current 的 [[Configurable]] 字段是 false，則
       1. 若是 Desc 有 [[Set]] 字段，而且 SameValue(Desc.[[Set]], current.[[Set]]) 是 false，則拒絕。
       2. 若是 Desc 有 [[Get]] 字段，而且 SameValue(Desc.[[Set]], current.[[Get]]) 是 false，則拒絕。
12. Desc 擁有全部特性字段，設定對象 O 的名爲 P 的屬性的對性特性爲這些字段值。
13. 返回 true。

然而，若是 O 是一個 Array 對象，其 [[DefineOwnProperty]] 內部方法的更多闡述定義在 15.4.5.1

若是 current 的 [[Configurable]] 字段是 true，那麼步驟 10.b 容許 Desc 的任何字段與 current 對應的字段不一樣。這甚至能夠改變 [[Writable]] 特性爲 false 的屬性的 [[Value]]。容許這種狀況是由於值是 true 的 [[Configurable]] 特性會容許按照：首先設定 [[Writable]] 爲 true，而後設定新 [[Value]]，[[Writable]] 設爲 false 的順序調用。

類型轉換與測試

ECMAScript 運行時系統會在須要時從事自動類型轉換。爲了闡明某些結構的語義，定義一集轉換運算符是頗有用的。這些運算符不是語言的一部分；在這裏定義它們是爲了協助語言語義的規範。轉換運算符是多態的 — 它們能夠接受任何 ECMAScript 語言類型 的值，可是不接受 規範類型 。

ToPrimitive

ToPrimitive 運算符接受一個值，和一個可選的 指望類型 做參數。ToPrimitive 運算符把其值參數轉換爲非對象類型。若是對象有能力被轉換爲不止一種原語類型，能夠使用可選的 指望類型 來暗示那個類型。根據下表完成轉換：

ToPrimitive轉換

輸入類型	結果
Undefined	結果等於輸入的參數（不轉換）。
Null	結果等於輸入的參數（不轉換）。
Boolean	結果等於輸入的參數（不轉換）。
Number	結果等於輸入的參數（不轉換）。
String	結果等於輸入的參數（不轉換）。
Object	返回該對象的默認值。（調用該對象的內部方法[[DefaultValue]]一樣）。

ToBoolean

ToBoolean 運算符根據下表將其參數轉換爲布爾值類型的值：

ToBoolean轉換

輸入類型	結果
Undefined	false
Null	false
Boolean	結果等於輸入的參數（不轉換）。
Number	若是參數是 +0, -0, 或 NaN，結果爲 false ；不然結果爲 true。
String	若是參數參數是空字符串（其長度爲零），結果爲 false，不然結果爲 true。
Object	true

ToNumber

ToNumber 運算符根據下表將其參數轉換爲數值類型的值：

ToNumber轉換

輸入類型	結果
Undefined	NaN
Null	+0
Boolean	若是參數是 true，結果爲 1。若是參數是 false，此結果爲 +0。
Number	結果等於輸入的參數（不轉換）。
String	參見下文的文法和註釋。
Object	應用下列步驟： 設 原始值 為 ToPrimitive( 輸入參數 , 暗示 數值類型)。 返回 ToNumber( 原始值 )。

對字符串類型應用 ToNumber

對字符串應用 ToNumber 時，對輸入字符串應用以下文法。若是此文法沒法將字符串解釋爲「字符串數值常量」的擴展，那麼 ToNumber 的結果爲 NaN。

語法

StringNumericLiteral ::: StrWhiteSpaceopt StrWhiteSpaceoptStrNumericLiteral StrWhiteSpaceoptStrWhiteSpace ::: StrWhiteSpaceChar StrWhiteSpaceoptStrWhiteSpaceChar ::: WhiteSpace LineTerminatorStrNumericLiteral ::: StrDecimalLiteral HexIntegerLiteralStrDecimalLiteral ::: StrUnsignedDecimalLiteral + StrUnsignedDecimalLiteral - StrUnsignedDecimalLiteralStrUnsignedDecimalLiteral ::: Infinity DecimalDigits . DecimalDigitsopt ExponentPartopt . DecimalDigits ExponentPartopt DecimalDigits ExponentPartoptDecimalDigits ::: DecimalDigit DecimalDigits DecimalDigit DecimalDigit ::: 如下之一 0 1 2 3 4 5 6 7 8 9ExponentPart ::: ExponentIndicator SignedInteger ExponentIndicator ::: 如下之一 e ESignedInteger ::: DecimalDigits + DecimalDigits - DecimalDigitsHexIntegerLiteral ::: 0x HexDigit 0X HexDigit HexIntegerLiteral HexDigit HexDigit ::: 如下之一 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F

須要注意到「字符串數值常量」和 「數值常量」 語法上的不一樣：

• 「字符串數值常量」以前和、或以後能夠有空白和／或行結束符。
• 十進制的「字符串數值常量」可有任意位數的 0 在前頭。
• 十進制的「字符串數值常量」可有指示其符號的 + 或 - 前綴。
• 空的，或只包含空白的「字符串值常量」會被轉換爲 +0。

字符串到數字值的轉換，大致上相似於斷定 數值常量 的數字值，不過有些細節上的不一樣，因此，這裏給出了把字符串數值常量轉換爲數值類型的值的所有過程。這個值分兩步來斷定：首先，從字符串數值常量中導出數學值；第二步，如下面所描述的方式對該數學值進行舍入。

• 「字符串整數常量 ::: [empty]」的數學值是 0。
• 「字符串整數常量 ::: 串空白」的數學值是 0。
• 無論有沒有空白「字符串整數常量 ::: 串空白 _opt 串數值常量 串空白 _opt」的數學值是「串數值常量」的數學值
• 「串數值常量 ::: 串十進制常量」的數學值是「串十進制常量」的數學值
• 「串數值常量 ::: 十六進制整數常量」的數學值是「十六進制整數常量」的數學值
• 「串十進制常量 ::: 串無符號整數常量」的數學值是「串無符號整數常量」的數學值
• 「串十進制常量 ::: + 串無符號整數常量」的數學值是「串無符號整數常量」的數學值。
• 「串十進制常量 ::: - 串無符號整數常量」的數學值是「串無符號整數常量」的數學值的負數。 （須要注意的是，若是「串無符號整數常量」的數學值是 0, 其負數也是 0。下面中描述的舍入規則會合適地處理小於數學零到浮點數 +0 或 -0 的變換。）
• 「串無符號整數常量 ::: Infinity」的數學值是 10¹⁰⁰⁰⁰（一個大到會舍入爲 +∞ 的值過大的值會返回爲 ）。
• 「串無符號整數常量 ::: 十進制數 .」的數學值是「十進制數」的數學值。
• 「串無符號整數常量 ::: 十進制數 . 十進制數」的數學值是第一個「十進制數」的數學值加（第二個「十進制數」的數學值乘以 10^-n），這裏的 n 是 the number of characters in the 第二個「十進制數」字符數。
• 「串無符號整數常量 ::: 十進制數 . 指數部分」的數學值是「十進制數」的數學值乘以 10^e, 這裏的 e 是「指數部分」的數學值
• 「串無符號整數常量 ::: 十進制數 . 十進制數 指數部分」的數學值是（第一個「十進制數」的數學值加（第二個「十進制數」的數學值乘以 10^-n））乘以 10^e，這裏的 n 是 第二個「十進制數」中的字符個數，e 是「指數部分」的數學值。
• 「串無符號整數常量 ::: . 十進制數」的數學值是「十進制數」的數學值乘以 10^-n，這裏的 n 是「十進制數」中的字符個數。
• 「串無符號整數常量 ::: . 十進制數 指數部分」的數學值是「十進制數」的數學值乘以 10^e-n，這裏的 n 是「十進制數」中的字符個數，e 是「指數部分」的數學值
• 「串無符號整數常量 ::: 十進制數」的數學值是「十進制數」的數學值
• 「串無符號整數常量 ::: 十進制數 指數部分」的數學值是「十進制數」的數學值乘以 10^e，這裏的 e 是「指數部分」的數學值
• 「十進制數 ::: 十進制數字」是「十進制數字」的數學值
• 「十進制數 ::: 十進制數 十進制數字」的數學值是（「十進制數」的數學值乘以 10）加「十進制數字」的數學值
• 「指數部分 ::: 冪指示符 有符號整數」的數學值是「有符號整數」的數學值
• 「有符號整數 ::: 十進制數」的數學值是「十進制數」的數學值
• 「有符號整數 ::: + 十進制數」的數學值是「十進制數」的數學值
• 「有符號整數 ::: - 十進制數」是「十進制數」的數學值的負數。
• 「十進制數字 ::: 0」或「十六進制數字 ::: 0」的數學值是 0。
• 「十進制數字 ::: 1」或「十六進制數字 ::: 1」的數學值是 1。
• 「十進制數字 ::: 2」或「十六進制數字 ::: 2」的數學值是 2。
• 「十進制數字 ::: 3」或「十六進制數字 ::: 3」的數學值是 3。
• 「十進制數字 ::: 4」或「十六進制數字 ::: 4」的數學值是 4。
• 「十進制數字 ::: 5」或「十六進制數字 ::: 5」的數學值是 5。
• 「十進制數字 ::: 6」或「十六進制數字 ::: 6」的數學值是 6。
• 「十進制數字 ::: 7」或「十六進制數字 ::: 7」的數學值是 7。
• 「十進制數字 ::: 8」或「十六進制數字 ::: 8」的數學值是 8。
• 「十進制數字 ::: 9」或「十六進制數字 ::: 9」的數學值是 9。
• 「十六進制數字 ::: a」或「十六進制數字 ::: A」的數學值是 10。
• 「十六進制數字 ::: b」或「十六進制數字 ::: B」的數學值是 11。
• 「十六進制數字 ::: c」或「十六進制數字 ::: C」的數學值是 12。
• 「十六進制數字 ::: d」或「十六進制數字 ::: D」的數學值是 13。
• 「十六進制數字 ::: e」或「十六進制數字 ::: E」的數學值是 14。
• 「十六進制數字 ::: f」或「十六進制數字 ::: F」的數學值是 15。
• 「十六進制整數常量 ::: 0x 十六進制數字」的數學值是「十六進制數字」的數學值。
• 「十六進制整數常量 ::: 0X 十六進制數字」的數學值是「十六進制數字」的數學值。
• 「十六進制整數常量 ::: 十六進制整數常量 十六進制數字」的數學值是（「十六進制整數常量」的數學值乘以 16）加「十六進制數字」的數學值。

一旦字符串數值常量的數學值被精確地肯定，接下來就會被舍入爲數值類型的一個值。若是數學值是 0，那麼舍入值爲 +0，除非字符串數值常量中第一個非空白字符是 ‘-’ — 在這種狀況下，舍入值爲 -0。不然，舍入值必須是數學值的 數字值 ，除非該常量包括一個「串無符號十進制常量」，且此常量多於 20 位 重要數字 — 在這種狀況下，此數字的值是下面兩種之一：一是將其 20 位以後的每一個重要數字用 0 替換，產生此字符串解析出的數學值的數字值；二是將其 20 位以後的每一個有效數字用 0 替換，並在第 20 位重要數字加一，產生此字符串解析出的數學值的數字值 。判斷一個數字是否爲 重要數字 ，首先它不能是「指數部分」的一部分，且

• 它不是 0；或
• 它的左邊是一個非零值，右邊是一個不在「指數部分」中的非零值。

ToInteger

ToInteger 運算符將其參數轉換爲整數值。此運算符功能以下所示：

1. 對輸入參數調用 ToNumber。
2. 若是 Result(1) 是 NaN，返回 +0。
3. 若是 Result(1) 是 +0 ，-0，+∞，或 -∞，返回 Result(1)。
4. 計算 sign(Result(1)) * floor(abs(Result(1)))。
5. 返回 Result(4)。

ToInt32：（32 位有符號整數）

ToInt32 運算符將其在 -2³¹ 到 2³¹-1 閉區間內的參數轉換爲 2³² 個整數值之一。此運算符功能以下所示：

1. 對輸入參數調用 ToNumber。
2. 若是 Result(1) 是 +0 ，-0，+∞，或 -∞，返回 +0。
3. 計算 sign(Result(1)) * floor(abs(Result(1)))。
4. 計算 Result(3) modulo 2³² ；也就是說，數值類型的有限整數值 k 爲正，且小於 2³² ，規模相對於 Result(3) 的數學值差別 ，2³² 是 k 的整數倍。
5. 若是 Result(4) 是大於等於 2³¹ 的整數，返回 Result(4) - 2³² ，不然返回 Result(4)。

按照ToInt32以上的定義：ToInt32抽象操做是冪等的：若是做用於它產生的結果，第二次程序將會保持值不變，對任何值x，ToInt32(ToUint32(x))都與ToInt32(x)相等。（將+∞和−∞映射到+0就是爲了保持這一特性。） ToInt32將-0映射爲+0。

ToUint32：（32 位無符號整數）

ToUint32 運算符將其在 0 到 2³²-1 閉區間內的參數轉換爲 2³² 個整數值之一。此運算符功能以下所示：

1. 對輸入參數調用 ToNumber。
2. 若是 Result(1) 是 +0 ，-0，+∞，或 -∞，返回 +0。
3. 計算 sign(Result(1)) * floor(abs(Result(1)))。
4. 計算 Result(3) modulo 2³² ；也就是說，數值類型的有限整數值 k 爲正，且小於 2³² ，規模相對於 Result(3) 的數學值差別 ，2³² 是 k 的整數倍。
5. 返回 Result(4)。

上面給出的 ToUint32 的定義中：

• ToUint32 和 ToInt32 惟一的不一樣在於第 5 步。
• ToUint32 的操做具備鑑一性：若是應用於一個已經產生的結果，第二次應用保持值不變。
• 對於 x 的全部值，ToUint32(ToInt32(x)) 與 ToUint32 相等。（這是爲了保證後來的屬性 +∞ 和 -∞ 被映射爲 +0。）
• ToUint32 把 -0 映射爲 +0。

ToUint16：（16 位無符號整數）

ToUint32 運算符將其在 0 到 2¹⁶-1 閉區間內的參數轉換爲 2¹⁶ 個整數值之一。此運算符功能以下所示：

1. 對輸入參數調用 ToNumber。
2. 若是 Result(1) 是 +0 ，-0，+∞，或 -∞，返回 +0。
3. 計算 sign(Result(1)) * floor(abs(Result(1)))。
4. 計算 Result(3) modulo 2¹⁶ ；也就是說，數值類型的有限整數值 k 爲正，且小於 2¹⁶ ，規模相對於 Result(3) 的數學值差別 ，2¹⁶ 是 k 的整數倍。
5. 返回 Result(4)。

上面給出的 ToUint16 的定義中：

• ToUint32 和 ToUint16 之間惟一的不一樣是第 4 步中，2¹⁶ 代替了 2³²。
• ToUint32 把 -0 映射爲 +0。

ToString

ToString 運算符根據下表將其參數轉換爲字符串類型的值：

ToString轉換

輸入類型	結果
Undefined	"undefined"
Null	"null"
Boolean	若是參數是 true，那麼結果爲 "true"。 若是參數是 false，那麼結果爲 "false"。
Number	結果等於輸入的參數（不轉換）。
String	參見下文的文法和註釋。
Object	應用下列步驟： 調用 ToPrimitive( 輸入參數 , 暗示 字符串類型)。 調用 ToString(Result(1))。 返回 Result(2)。

對數值類型應用 ToString

ToString 運算符將數字 m 轉換爲字符串格式的給出以下所示：

1. 若是 m 是 NaN，返回字符串 "NaN"。
2. 若是 m 是 +0 或 -0，返回字符串 "0"。
3. 若是 m 小於零，返回鏈接 "-" 和 ToString(-m) 的字符串。
4. 若是 m 無限大，返回字符串 "Infinity"。
5. 不然，令 n, k, 和 s 是整數，使得 k ≥ 1, 10^k-1 ≤ s < 10^k，s × 10^n-k 的數字值是 m，且 k 足夠小。要注意的是，k 是 s 在十進制表示中的數字的個數。s 不被 10 整除，且s 的至少要求的有效數字位數不必定要被這些標準惟一肯定。
6. 若是 k ≤ n ≤ 21，返回由 k 個 s 在十進制表示中的數字組成的字符串（有序的，開頭沒有零），後面跟隨字符 '0' 的 n-k 次出現。
7. 若是 0 < n ≤ 21，返回由 s 在十進制表示中的、最多 n 個有效數字組成的字符串，後面跟隨一個小數點 '. '，再後面是餘下的 k-n 個 s 在十進制表示中的數字。
8. 若是 -6 < n ≤ 0，返回由字符 '0' 組成的字符串，後面跟隨一個小數點 '. '，再後面是字符 '0' 的 -n 次出現，再日後是 k 個 s 在十進制表示中的數字。
9. 不然，若是 k = 1，返回由單個數字 s 組成的字符串，後面跟隨小寫字母 'e'，根據 n-1 是正或負，再後面是一個加號 '+' 或減號 '-' ，再日後是整數 abs(n-1) 的十進制表示（沒有前置的零）。
10. 返回由 s 在十進制表示中的、最多的有效數字組成的字符串，後面跟隨一個小數點 '. '，再後面是餘下的是 k-1 個 s 在十進制表示中的數字，再日後是小寫字母 'e'，根據n-1 是正或負，再後面是一個加號 '+ ' 或減號 '-' ，再日後是整數 abs(n-1) 的十進制表示（沒有前置的零）。

下面的評語可能對指導實現有用，但不是本標準的常規要求。

• 若是 x 是除 -0 之外的任一數字值，那麼 ToNumber(ToString(x)) 與 x 是徹底相同的數字值。
• s 至少要求的有效數字位數並不是老是由步驟 5 中所列的要求惟一肯定。

對於那些提供了比上面的規則所要求的更精確的轉換的實現，咱們推薦下面這個步驟 5 的可選版本，做爲指導：

不然，令 n, k, 和 s 是整數，使得 k ≥ 1, 10^k-1 ≤ s < 10^k，s × 10^n-k 的數字值是 m，且 k 足夠小。若是有數倍於 s 的可能性，選擇 s × 10^n-k 最接近於 m 的值做爲 s 的值。若是 s有兩個這樣可能的值，選擇是偶數的那個。要注意的是，k 是 s 在十進制表示中的數字的個數，且 s 不被 10 整除。

ECMAScript 的實現者們可能會發現，David M 所寫的關於浮點數進行二進制到十進制轉換方面的文章和代碼頗有用：

Gay, David M. Correctly Rounded Binary-Decimal and Decimal-Binary Conversions. Numerical Analysis Manuscript 90-10. AT&T Bell Laboratories (Murray Hill, New Jersey). November 30, 1990. 在這裏取得 http://cm.bell-labs.com/cm/cs/doc/90/4-10.ps.gz 。有關的代碼在這裏 http://cm.bell-labs.com/netlib/fp/dtoa.c.gz 還有 http://cm.bell-labs.com/netlib/fp/g_fmt.c.gz 。這些均可在衆多的 netlib 鏡像站點上找到。

ToObject

ToObject 運算符根據下表將其參數轉換爲對象類型的值：

ToObject轉換

輸入類型	結果
Undefined	拋出 TypeError 異常。
Null	>拋出 TypeError 異常。
Boolean	建立一個新的Boolean對象，其 [[PrimitiveValue]]屬性被設爲該布爾值的值。
Number	建立一個新的Number對象，其[[PrimitiveValue]]屬性被設爲該布爾值的值。
String	建立一個新的String對象，其 [[PrimitiveValue]] 屬性被設爲該布爾值的值。
Object	結果是輸入的參數（不轉換）。

CheckObjectCoercible

根據表 15 定義，抽象操做 CheckObjectCoercible 在其參數沒法用 ToObject 轉換成對象的狀況下拋出一個異常：

CheckObjectCoercible結果

輸入類型	結果
Undefined	拋出一個 TypeError 異常
Null	>拋出 TypeError 異常。
Boolean	返回
Number	返回
String	返回
Object	返回

IsCallable

根據表 16，抽象操做 IsCallable 肯定其必須是 ECMAScript 語言值的參數是不是一個可調用對象：

IsCallable結果

輸入類型	結果
Undefined	返回false
Null	>返回false
Boolean	返回false
Number	返回false
String	返回false
Object	若是參數對象包含一個Call內部方法，則返回 true，不然返回 false

SameValue 算法

內部嚴格比較操做 SameValue(x,y)，x 和 y 爲 ECMAScript 語言中的值，須要產出 true 或 false。比較過程以下：

1. 若是 Type(x) 與 Type(y) 的結果不一致，返回 false，不然
2. 若是 Type(x) 結果爲 Undefined，返回 true
3. 若是 Type(x) 結果爲 Null，返回 true
4. 若是 Type(x) 結果爲 Number，則
   1. 若是 x 爲 NaN，且 y 也爲 NaN，返回 true
   2. 若是 x 爲 +0，y 爲 -0，返回 false
   3. 若是 x 爲 -0，y 爲 +0，返回 false
   4. 若是 x 與 y 爲同一個數字，返回 true
   5. 返回 false
5. 若是 Type(x) 結果爲 String，若是 x 與 y 爲徹底相同的字符序列（相同的長度和相同的字符對應相同的位置），返回 true，不然，返回 false
6. 若是 Type(x) 結果爲 Boolean，若是 x 與 y 都爲 true 或 false，則返回 true，不然，返回 false
7. 若是 x 和 y 引用到同一個 Object 對象，返回 true，不然，返回 false

可執行代碼與執行環境

可執行代碼類型

一共有 3 種 ECMA 腳本可執行代碼：

• 全局代碼 是指被做爲 ECMA 腳本 程序 處理的源代碼文本。一個特定 程序 的全局代碼不包括做爲 函數體 被解析的源代碼文本。
• Eval 代碼 是指提供給 eval 內置函數的源代碼文本。更精確地說，若是傳遞給 eval 內置函數的參數爲一個字符串，該字符串將被做爲 ECMA 腳本 程序 進行處理。在特定的一次對 eval 的調用過程當中，eval 代碼做爲該 程序 的 #global-code 部分。
• 函數代碼 是指做爲 函數體 被解析的源代碼文本。一個 函數體 的 函數代碼 不包括做爲其嵌套函數的 函數體 被解析的源代碼文本。 函數代碼 同時還特指 以構造器方式調用 Function 內置對象 時所提供的源代碼文本。更精確地說，調用 Function 構造器時傳遞的最後一個參數將被轉換爲字符串並做爲 函數體 使用。若是調用 Function 構造器時，傳遞了一個以上的參數，除最後一個參數之外的其餘參數都將轉換爲字符串，並以逗號做爲分隔符鏈接在一塊兒成爲一個字符串，該字符串被解析爲 形參列表 供由最後一個參數定義的 函數體 使用。初始化 Function 對象時所提供的函數代碼，並不包括做爲其嵌套函數的 函數體 被解析的源代碼文本。

嚴格模式下的代碼

一個 ECMA 腳本程序的語法單元能夠使用非嚴格或嚴格模式下的語法及語義進行處理。當使用嚴格模式進行處理時，以上三種代碼將被稱爲嚴格全局代碼、嚴格 eval 代碼和嚴格函數代碼。當符合如下條件時，代碼將被解析爲嚴格模式下的代碼：

• 當 全局代碼 以指令序言開始，且該指令序言包含一個使用嚴格模式的指令序言（參考 14.1 章 ）時，即爲嚴格全局代碼。
• 當 全局代碼 以指令序言開始，且該指令序言包含一個使用嚴格模式的指令序言時；或者在 嚴格模式下的代碼 中經過直接調用 eval 函數 （參考 15.1.2.1.1 章 ）時，即爲嚴格 eval 代碼。
• 當一個 函數聲明 、 函數表達式 或 函數賦值 訪問器處在一段 嚴格模式下的代碼 中，或其函數代碼以指令序言開始，且該指令序言包含一個使用嚴格模式的指令序言時，該函數代碼 即爲嚴格函數代碼。
• 當調用內置的 Function 構造器時，若是最後一個參數所表達的字符串在做爲 函數體 處理時以指令序言開始，且該指令序言包含一個使用嚴格模式的指令序言，則該 函數代碼即爲嚴格函數代碼。

詞法環境

詞法環境 是一個用於定義特定變量和函數標識符在 ECMAScript 代碼的詞法嵌套結構上關聯關係的規範類型。一個詞法環境由一個環境記錄項和可能爲空的外部詞法環境引用構成。一般詞法環境會與特定的 ECMAScript 代碼諸如 FunctionDeclaration,WithStatement 或者 TryStatement 的 Catch 塊這樣的語法結構相聯繫，且相似代碼每次執行都會有一個新的語法環境被建立出來。

環境記錄項記錄了在它的關聯詞法環境域內建立的標識符綁定情形。

外部詞法環境引用用於表示詞法環境的邏輯嵌套關係模型。（內部）詞法環境的外部引用是邏輯上包含內部詞法環境的詞法環境。外部詞法環境天然也可能有多個內部詞法環境。例如，若是一個 FunctionDeclaration 包含兩個嵌套的 FunctionDeclaration，那麼每一個內嵌函數的詞法環境都是外部函數本次執行所產生的詞法環境。

詞法環境和環境記錄項是純粹的規範機制，而不須要 ECMAScript 的實現保持一致。ECMAScript 程序不可能直接訪問或者更改這些值。

環境記錄項

在本標準中，共有 2 類環境記錄項： 聲明式環境記錄項 和 對象式環境記錄項 。聲明式環境記錄項用於定義那些將 標識符 與語言值直接綁定的 ECMA 腳本語法元素，例如 函數定義 ， 變量定義 以及 Catch 語句。對象式環境記錄項用於定義那些將 標識符 與具體對象的屬性綁定的 ECMA 腳本元素，例如 程序 以及 With 表達式 。

出於標準規範的目的，能夠將環境記錄項理解爲面向對象中的一個簡單繼承結構，其中環境記錄項是一個抽象類花前月下有 2 個具體實現類，分別爲聲明式環境記錄項和對象式環境記錄項。抽象類包含了表 17 所描述的抽象方法定義，針對每個具體實現類，每一個抽象方法都有不一樣的具體算法。

環境記錄項的抽象方法

方法	做用
HasBinding(N)	判斷環境記錄項是否包含對某個標識符的綁定。若是包含該綁定則返回 true，反之返回 false。其中字符串 N 是標識符文本。
CreateMutableBinding(N, D)	在環境記錄項中建立一個新的可變綁定。其中字符串 N 指定綁定名稱。若是可選參數 D 的值爲true，則該綁定在後續操做中能夠被刪除。
SetMutableBinding(N,V, S)	在環境記錄項中設置一個已經存在的綁定的值。其中字符串 N 指定綁定名稱。V 用於指定綁定的值，能夠是任何 ECMA 腳本語言的類型。S 是一個布爾類型的標記，當 S 爲 true 而且該綁定不容許賦值時，則拋出一個 TypeError 異常。S 用於指定是否爲嚴格模式。
GetBindingValue(N,S)	返回環境記錄項中一個已經存在的綁定的值。其中字符串 N 指定綁定的名稱。S 用於指定是否爲嚴格模式。若是 S 的值爲 true 而且該綁定不存在或未初始化，則拋出一個 ReferenceError 異常。
DeleteBinding(N)	從環境記錄項中刪除一個綁定。其中字符串 N 指定綁定的名稱。若是 N 指定的綁定存在，將其刪除並返回 true。若是綁定存在但沒法刪除則返回false。若是綁定不存在則返回 true。
ImplicitThisValue()	當從該環境記錄項的綁定中獲取一個函數對象而且調用時，該方法返回該函數對象使用的 this 對象的值。

聲明式環境記錄項

每一個聲明式環境記錄項都與一個包含變量和（或）函數聲明的 ECMA 腳本的程序做用域相關聯。聲明式環境記錄項用於綁定做用域內定義的一系列標識符。

除了全部環境記錄項都支持的可變綁定外，聲明式環境記錄項還提供不可變綁定。在不可變綁定中，一個標識符與它的值之間的關聯關係創建以後，就沒法改變。建立和初始化不可變綁定是兩個獨立的過程，所以相似的綁定能夠處在已初始化階段或者未初始化階段。除了環境記錄項定義的抽象方法外，聲明式環境記錄項還支持表 18 中列出的方法：

聲明式環境記錄項的額外方法

方法	做用
CreateImmutableBinding(N)	在環境記錄項中建立一個未初始化的不可變綁定。其中字符串 N 指定綁定名稱。
InitializeImmutableBinding(N,V)	在環境記錄項中設置一個已經建立但未初始化的不可變綁定的值。其中字符串 N 指定綁定名稱。V 用於指定綁定的值，能夠是任何 ECMA 腳本語言的類型。

環境記錄項定義的方法的具體行爲將由如下算法給予描述。

HasBinding (N)

聲明式環境記錄項的 HasBinding 具體方法用於簡單地判斷做爲參數的標識符是不是當前對象綁定的標識符之一：

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 若是 envRec 有一個名稱爲 N 的綁定，返回 true。
3. 若是沒有該綁定，返回 false。

CreateMutableBinding (N, D)

聲明式環境記錄項的 CreateMutableBinding 具體方法會建立一個名稱爲 N 的綁定，並初始化其值爲 undefined。方法調用時，當前環境記錄項中不能存在 N 的綁定。若是調用時提供了布爾類型的參數 D 且其值爲 true，則新建的綁定被標記爲可刪除。

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 執行斷言：envRec 沒有 N 的綁定。
3. 在 envRec 中爲 N 建立一個可變綁定，並將綁定的值設置爲 undefined。若是 D 爲 true 則新建立的綁定可在後續操做中經過調用 DeleteBinding 刪除。

SetMutableBinding (N,V,S)

聲明式環境記錄項的 SetMutableBinding 具體方法嘗試將當前名稱爲參數 N 的綁定的值修改成參數 V 指定的值。方法調用時，必須存在 N 的綁定。若是該綁定爲不可變綁定，而且 S 的值爲 true，則拋出一個 TypeError 異常。

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 執行斷言：envRec 必須有 N 的綁定。
3. 若是 envRec 中 N 的綁定爲可變綁定，則將其值修改成 V。
4. 不然該操做會嘗試修改一個不可變綁定的值，所以若是 S 的值爲 true，則拋出一個 TypeError 異常。

GetBindingValue (N,S)

聲明式環境記錄項的 GetBindingValue 具體方法簡單地返回名稱爲參數 N 的綁定的值。方法調用時，該綁定必須存在。若是 S 的值爲 true 且該綁定是一個未初始化的不可變綁定，則拋出一個 ReferenceError 異常。

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 執行斷言：envRec 必須有 N 的綁定。
3. 若是 envRec 中 N 的綁定是一個未初始化的不可變綁定，則：
   1. 若是 S 爲 false，返回 undefined，不然拋出一個 ReferenceError 異常。
4. 不然返回 envRec 中與 N 綁定的值。

DeleteBinding (N)

聲明式環境記錄項的 DeleteBinding 具體方法只能刪除顯示指定可被刪除的那些綁定。

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 若是 envRec 不包含名稱爲 N 的綁定，返回 true。
3. 若是 envRec 中 N 的綁定不能刪除，返回 false。
4. 移除 envRec 中 N 的綁定。
5. 返回 true。

ImplicitThisValue()

聲明式環境記錄項永遠將 undefined 做爲其 ImplicitThisValue 返回。

1. 返回 undefined。

CreateImmutableBinding (N)

聲明式環境記錄項的 CreateImmutableBinding 具體方法會建立一個不可變綁定，其名稱爲 N 且初始化其值爲 undefined。調用方法時，該環境記錄項中不得存在 N 的綁定。

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 執行斷言：envRec 不存在 N 的綁定。
3. 在 envRec 中爲 N 建立一個不可變綁定，並記錄爲未初始化。

InitializeImmutableBinding (N,V)

聲明式環境記錄項的 InitializeImmutableBinding 具體方法用於將當前名稱爲參數 N 的綁定的值修改成參數 V 指定的值。方法調用時，必須存在 N 對應的未初始化的不可變綁定。

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 執行斷言：envRec 存在一個與 N 對應的未初始化的不可變綁定。
3. 在 envRec 中將 N 的綁定的值設置爲 V。
4. 在 envRec 中將 N 的不可變綁定記錄爲已初始化。

對象式環境記錄項

每個對象式環境記錄項都有一個關聯的對象，這個對象被稱做 綁定對象 。對象式環境記錄項直接將一系列標識符與其綁定對象的屬性名稱創建一一對應關係。不符合IdentifierName 的屬性名不會做爲綁定的標識符使用。不管是對象自身的，仍是繼承的屬性都會做爲綁定，不管該屬性的 [[Enumerable]] 特性的值是什麼。因爲對象的屬性能夠動態的增減，所以對象式環境記錄項所綁定的標識符集合也會隱匿地變化，這是增減綁定對象的屬性而產生的反作用。經過以上描述的反作用而創建的綁定，均被視爲可變綁定，即便該綁定對應的屬性的 Writable 特性的值爲 false。對象式環境記錄項沒有不可變綁定。

對象式環境記錄項能夠經過配置的方式，將其綁定對象合爲函數調用時的隱式 this 對象的值。這一功能用於規範 With 表達式（12.10 章 ）引入的綁定行爲。該行爲經過對象式環境記錄項中布爾類型的 provideThis 值控制，默認狀況下，provideThis 的值爲 false。

環境記錄項定義的方法的具體行爲將由如下算法給予描述。

HasBinding(N)

對象式環境記錄項的 HasBinding 具體方法判斷其關聯的綁定對象是否有名爲 N 的屬性：

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 令 bindings 爲 envRec 的綁定對象。
3. 以 N 爲屬性名，調用 bindings 的 [[HasProperty]] 內部方法，並返回調用的結果。

CreateMutableBinding (N, D)

對象式環境記錄項的 CreateMutableBinding 具體方法會在其關聯的綁定對象上建立一個名稱爲 N 的屬性，並初始化其值爲 undefined。調用方法時，綁定對象不得包含名稱爲 N的屬性。若是調用方法時提供了布爾類型的參數 D 且其值爲 true，則設置新建立的屬性的 [[Configurable]] 特性的值爲 true，不然設置爲 false。

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 令 bindings 爲 envRec 的綁定對象。
3. 執行斷言：以 N 爲屬性名，調用 bindings 的 [[HasProperty]] 內部方法，調用的結果爲 false。
4. 若是 D 的值爲 true，則令 configValue 的值爲 true，不然令 configValue 的值爲 false。
5. 以 N、屬性描述符 {[[Value]]:undefined, [[Writable]]: true, [[Enumerable]]: true , [[Configurable]]: configValue} 和布爾值 true 爲參數，調用 bindings 的 [[DefineOwnProperty]] 內部方法。

SetMutableBinding (N,V,S)

對象式環境記錄項的 SetMutableBinding 具體方法會嘗試設置其關聯的綁定對象中名爲 N 的屬性的值爲 V。方法調用時，綁定對象中應當存在該屬性，若是該屬性不存在或屬性不可寫，則根據 S 參數的值來執行錯誤處理。

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 令 bindings 爲 envRec 的綁定對象
3. 以 N、V 和 S 爲參數，調用 bindings 的 [[Put]] 內部方法。

GetBindingValue(N,S)

對象式環境記錄項的 GetBindingValue 具體方法返回其關聯的綁定對象中名爲 N 的屬性的值。方法調用時，綁定對象中應當存在該屬性，若是該屬性不存在，則方法的返回值由 S參數決定：

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 令 bindings 爲 envRec 的綁定對象
3. 以 N 爲屬性名，調用 bindings 的 [[HasProperty]] 內部方法，並令 value 爲調用的結果。
4. 若是 value 的值爲 false，則：
   1. 若是 S 的值爲 false，則返回 undefined，不然拋出一個 ReferenceError 異常。
5. 以 N 爲參數，調用 bindings 的 [[Get]] 內部方法，並返回調用的結果。

DeleteBinding (N)

對象式環境記錄項的 DeleteBinding 具體方法只能用於刪除其關聯的綁定對象上 [[Configurable]] 特性的值爲 true 的屬性所對應的綁定。

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 令 bindings 爲 envRec 的綁定對象
3. 以 N 和布爾值 false 爲參數，調用 bindings 的 [[Delete]] 內部方法。

ImplicitThisValue()

對象式環境記錄項的 ImplicitThisValue 一般返回 undefined，除非其 provideThis 標識的值爲 true。

1. 令 envRec 爲函數調用時對應的聲明式環境記錄項。
2. 若是 envRec 的 provideThis 標識的值爲 true，返回 envRec 的綁定對象。
3. 不然返回 undefined。

詞法環境的運算

在本標準中，如下抽象運算將被用於操做環境記錄項：

GetIdentifierReference (lex, name, strict)

當調用 GetIdentifierReference 抽象運算時，須要指定一個 詞法環境 lex，一個標識符字符串 name 以及一個布爾型標識 strict。lex 的值能夠爲 null。當調用該運算時，按如下步驟進行：

1. 若是 lex 的值爲 null，則：
   1. 返回一個類型爲 引用 的對象，其基值爲 undefined，引用的名稱爲 name，嚴格模式標識的值爲 strict。
2. 令 envRec 爲 lex 的環境數據。
3. 以 name 爲參數 N，調用 envRec 的 HasBinding(N) 具體方法，並令 exists 爲調用的結果。
4. 若是 exists 爲 true，則：
   1. 返回一個類型爲 引用 的對象，其基值爲 envRec，引用的名稱爲 name，嚴格模式標識的值爲 strict。
5. 不然：
   1. 令 outer 爲 lex 的 外部環境引用 。
   2. 以 outer、name 和 struct 爲參數，調用 GetIdentifierReference，並返回調用的結果。

NewDeclarativeEnvironment (E)

當調用 NewDeclarativeEnvironment 抽象運算時，需指定一個 詞法環境 E，其值能夠爲 null，此時按如下步驟進行：

1. 令 env 爲一個新建的 詞法環境 。
2. 令 envRec 爲一個新建的 聲明式環境數據 ，該環境數據不包含任何綁定。
3. 令 env 的環境數據爲 envRec。
4. 令 env 的外部詞法環境引用至 E。
5. 返回 env。

NewObjectEnvironment (O, E)

當調用 NewObjectEnvironmentis 抽象運算時，需指定一個對象 O 及一個 詞法環境 E（其值能夠爲 null），此時按如下步驟進行：

1. 令 env 爲一個新建的 詞法環境 。
2. 令 envRec 爲一個新建的 對象環境數據 ，該環境數據包含 O 做爲綁定對象。
3. 令 env 的環境數據爲 envRec。
4. 令 env 的外部詞法環境引用至 E。
5. 返回 env。

全局環境

全局環境 是一個惟一的 詞法環境 ，它在任何 ECMA 腳本的代碼執行前建立。全局環境的 環境數據 是一個 #object-environment-record 對象環境數據，該環境數據使用 全局對象（15.1）做爲 綁定對象 。全局環境的 外部環境引用 爲 null。

在 ECMA 腳本的代碼執行過程當中，可能會向 全局對象 添加額外的屬性，也可能修改其初始屬性的值。

執行環境

當控制器轉入 ECMA 腳本的可執行代碼時，控制器會進入一個執行環境。當前活動的多個執行環境在邏輯上造成一個棧結構。該邏輯棧的最頂層的執行環境稱爲當前運行的執行環境。任什麼時候候，當控制器從當前運行的執行環境相關的可執行代碼轉入與該執行環境無關的可執行代碼時，會建立一個新的執行環境。新建的這個執行環境會推入棧中，成爲當前運行的執行環境。

執行環境包含全部用於追蹤與其相關的代碼的執行進度的狀態。精確地說，每一個執行環境包含如表 19 列出的組件。

執行環境的狀態組件

組件	做用目的
詞法環境	指定一個詞法環境對象，用於解析該執行環境內的代碼建立的標識符引用。
變量環境	指定一個詞法環境對象，其環境數據用於保存由該執行環境內的代碼經過 變量表達式 和 函數表達式 建立的綁定。
>This 綁定	指定該執行環境內的 ECMA 腳本代碼中 this 關鍵字所關聯的值。

其中執行環境的詞法環境和變量環境組件始終爲 詞法環境 對象。當建立一個執行環境時，其詞法環境組件和變量環境組件最初是同一個值。在該執行環境相關聯的代碼的執行過程當中，變量環境組件永遠不變，而詞法環境組件有可能改變。

在本標準中，一般狀況下，只有正在運行的執行環境（執行環境棧裏的最頂層對象）會被算法直接修改。所以當遇到「詞法環境」，「變量環境」和「This 綁定」這三個術語時，指的是正在運行的執行環境的對應組件。

執行環境是一個純粹的標準機制，並不表明任何 ECMA 腳本實現的工件。在 ECMA 腳本程序中是不可能訪問到執行環境的。

標識符解析

標識符解析是指使用正在運行的執行環境中的詞法環境，經過一個 標識符 得到其對應的綁定的過程。在 ECMA 腳本代碼執行過程當中，PrimaryExpression : Identifier 這一語法產生式將按如下算法進行解釋執行：

1. 令 env 爲正在運行的執行環境的 詞法環境 。
2. 若是正在解釋執行的語法產生式處在 嚴格模式下的代碼 中，則僅 strict 的值爲 true，不然令 strict 的值爲 false。
3. 以 env，Identifier 和 strict 爲參數，調用 GetIdentifierReference 函數，並返回調用的結果。

解釋執行一個標識符獲得的結果一定是 引用 類型的對象，且其引用名屬性的值與 Identifier 字符串相等。

創建執行環境

解釋執行 全局代碼 或使用 eval 函數（15.1.2.1）輸入的代碼會建立並進入一個新的執行環境。每次調用 ECMA 腳本代碼定義的函數（13.2.1）也會創建並進入一個新的執行環境，即使函數是自身遞歸調用的。每一次 return 都會退出一個執行環境。拋出異常也可退出一個或多個執行環境。

當控制流進入一個執行環境時，會設置該執行環境的 this 綁定，定義變量環境和初始詞法環境，並執行定義綁定初始化過程（10.5）。以上這些步驟的嚴格執行方式由進入的代碼的類型決定。

進入全局代碼

當控制流進入 全局代碼 的執行環境時，執行如下步驟：

1. 按 10.4.1.1 描述的方案，使用 全局代碼 初始化執行環境。
2. 按 10.5 描述的方案，使用 全局代碼 執行定義綁定初始化步驟。

10.4.1.1 初始化全局執行環境

如下步驟描述 ECMA 腳本的全局執行環境 C 的建立過程：

1. 將變量環境設置爲 全局環境 。
2. 將詞法環境設置爲 全局環境 。
3. 將 this 綁定設置爲 全局對象 。

進入 eval 代碼

當控制流進入 eval 代碼 的執行環境時，執行如下步驟：

1. 若是沒有調用環境，或者 eval 代碼 並不是經過直接調用（15.1.2.1.1）eval 函數進行評估的，則
   1. 按（10.4.1.1）描述的初始化全局執行環境的方案，以 eval 代碼 做爲 C 來初始化執行環境。
2. 不然
   1. 將 this 綁定設置爲當前執行環境下的 this 綁定。
   2. 將詞法環境設置爲當前執行環境下的 詞法環境 。
   3. 將變量環境設置爲當前執行環境下的變量環境。
3. 若是 eval 代碼 是 嚴格模式下的代碼 ，則
   1. 令 strictVarEnv 爲以詞法環境爲參數調用 NewDeclarativeEnvironment 獲得的結果。
   2. 設置詞法環境爲 strictVarEnv。
   3. 設置變量環境爲 strictVarEnv。
4. 按 10.5 描述的方案，使用 eval 代碼 執行定義綁定初始化步驟。

嚴格模式下的限制

若是調用環境的代碼或 eval 代碼 是 嚴格模式下的代碼 ，則 eval 代碼不能在調用環境的變量環境中 初始化變量及函數綁定 。與之相對的，變量及函數綁定將在一個新的環境變量中被初始化，該環境變量僅可被 eval 代碼 訪問。

進入函數代碼

當控制流根據一個函數對象 F、調用者提供的 thisArg 以及調用者提供的 argumentList，進入 函數代碼 的執行環境時，執行如下步驟：

1. 若是 函數代碼 是 嚴格模式下的代碼 ，設 this 綁定爲 thisArg。
2. 不然若是 thisArg 是 null 或 undefined，則設 this 綁定爲 全局對象 。
3. 不然若是 Type(thisArg) 的結果不爲 Object，則設 this 綁定爲 ToObject(thisArg)。
4. 不然設 this 綁定爲 thisArg。
5. 以 F 的 [[Scope]] 內部屬性爲參數調用 NewDeclarativeEnvironment，並令 localEnv 爲調用的結果。
6. 設詞法環境爲 localEnv。
7. 設變量環境爲 localEnv。
8. 令 code 爲 F 的 [[Code]] 內部屬性的值。
9. 按 [10.5](#10.5) 描述的方案，使用 函數代碼 code 和 argumentList 執行定義綁定初始化步驟。

定義綁定初始化

每一個執行環境都有一個關聯的變量環境。當在一個執行環境下評估一段 ECMA 腳本時，變量和函數定義會以綁定的形式添加到這個變量環境的 環境記錄 中。對於函數 函數代碼，參數也一樣會以綁定的形式添加到這個變量環境的 環境記錄 中。

選擇使用哪個、哪一類型的 環境記錄 來綁定定義，是由執行環境下執行的 ECMA 腳本的類型決定的，而其它部分的邏輯是相同的。當進入一個執行環境時，會按如下步驟在變量環境上建立綁定，其中使用到調用者提供的代碼設爲 code，若是執行的是 函數代碼 ，則設 參數列表 爲 args：

1. 令 env 爲當前運行的執行環境的環境變量的 環境記錄 。
2. 若是 code 是 eval 代碼 ，則令 configurableBindings 爲 true，不然令 configurableBindings 爲 false。
3. 若是代碼是 嚴格模式下的代碼 ，則令 strict 爲 true，不然令 strict 爲 false。
4. 若是代碼爲 函數代碼 ，則：
   1. 令 func 爲經過 [[Call]] 內部屬性初始化 code 的執行的函數對象。令 names 爲 func 的 [[FormalParameters]] 內部屬性。
   2. 令 argCount 爲 args 中元素的數量。
   3. 令 n 爲數字類型，其值爲 0。
   4. 按列表順序遍歷 names，對於每個字符串 argName：
      1. 令 n 的值爲 n 當前值加 1。
      2. 若是 n 大於 argCount，則令 v 爲 undefined，不然令 v 爲 args 中的第 n 個元素。
      3. 以 argName 爲參數，調用 env 的 HasBinding 具體方法，並令 argAlreadyDeclared 爲調用的結果。
      4. 若是 argAlreadyDeclared 的值爲 false，以 argName 爲參數調用 env 的 CreateMutableBinding 具體方法。
      5. 以 argName、v 和 strict 爲參數，調用 env 的 SetMutableBinding 具體方法。
5. 按源碼順序遍歷 code，對於每個 FunctionDeclaration 表達式 f：
   1. 令 fn 爲 FunctionDeclaration 表達式 f 中的 標識符 。
   2. 按 第 13 章 中所述的步驟初始化 FunctionDeclaration 表達式 ，並令 fo 爲初始化的結果。
   3. 以 fn 爲參數，調用 env 的 HasBinding 具體方法，並令 argAlreadyDeclared 爲調用的結果。
   4. 若是 argAlreadyDeclared 的值爲 false，以 fn 和 configurableBindings 爲參數調用 env 的 CreateMutableBinding 具體方法。
   5. 不然若是 env 是全局環境的 環境記錄 對象，則：
      1. 令 go 爲全局對象。
      2. 以 fn 爲參數，調用 go 和 [[GetProperty]] 內部方法，並令 existingProp 爲調用的結果。
      3. 若是 existingProp.[[Configurable]] 的值爲 true，則：
         1. 以 fn、由 {[[Value]]: undefined, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: configurableBindings } 組成的 屬性描述符 和 true 爲參數，調用go 的 [[DefineOwnProperty]] 內部方法。
      4. 不然若是 IsAccessorDescrptor(existingProp) 的結果爲真，或 existingProp 的特性中沒有 {[[Writable]]: true, [[Enumerable]]: true}，則：
         1. 拋出一個 TypeError 異常。
      5. 以 fn、fo 和 strict 爲參數，調用 env 的 SetMutableBinding 具體方法。
6. 以 arguments 爲參數，調用 env 的 HasBinding 具體方法，並令 argumentsAlreadyDeclared 爲調用的結果。
7. 若是 code 是 函數代碼 ，而且 argumentsAlreadyDeclared 爲 false，則：
   1. 以 fn、names、args、env 和 strict 爲參數，調用 CreateArgumentsObject 抽象運算函數，並令 argsObj 爲調用的結果。
   2. 若是 strict 爲 true，則：
      1. 以字符串 "arguments" 爲參數，調用 env 的 CreateImmutableBinding 具體方法。
      2. 以字符串 "arguments" 和 argsObj 爲參數，調用 env 的 InitializeImmutableBinding 具體函數。
   3. 不然：
      1. 以字符串 "arguments" 爲參數，調用 env 的 CreateMutableBinding 具體方法。
      2. 以字符串 "arguments"、argsObj 和 false 爲參數，調用 env 的 SetMutableBinding 具體函數。
8. 按源碼順序遍歷 code，對於每個 VariableDeclaration 和 VariableDeclarationNoIn 表達式：
   1. 令 dn 爲 d 中的標識符。
   2. 以 dn 爲參數，調用 env 的 HasBinding 具體方法，並令 varAlreadyDeclared 爲調用的結果。
   3. 若是 varAlreadyDeclared 爲 false，則：
      1. 以 dn 和 configurableBindings 爲參數，調用 env 的 CreateMutableBinding 具體方法。
      2. 以 dn、undefined 和 strict 爲參數，調用 env 的 SetMutableBinding 具體方法。

Arguments 對象

當控制器進入到函數代碼的執行環境時，將建立一個 arguments 對象，除非它做爲標識符 "arguments" 出如今該函數的形參列表中，或者是該函數代碼內部的變量聲明標識符或函數聲明標識符。

Arguments 對象經過調用抽象方法 CreateArgumentsObject 建立，調用時將如下參數傳入：func, names, args, env, strict。將要執行的函數對象做爲 func 參數，將該函數的全部形參名加入一個 List 列表，做爲 names 參數，將全部傳給內部方法 [[Call]] 的實際參數，做爲 args 參數，將該函數代碼的環境變量做爲 env 參數，將該函數代碼是否爲嚴格代碼做爲strict 參數。當 CreateArgumentsObject 調用時，按照如下步驟執行：

1. 令 len 爲參數 args 的元素個數
2. 令 obj 爲一個新建的 ECMAScript 對象
3. 按照 8.12 章節中的規範去設定 obj 對象的全部內部方法
4. 將 obj 對象的內部屬性 [[Class]] 設置爲 "Arguments"
5. 令 Object 爲標準的內置對象的構造函數 (15.2.2)
6. 將 obj 對象的內部屬性 [[Prototype]] 設置爲標準的內置對象的原型對象
7. 調用 obj 的內部方法 [[DefineOwnProperty]]，將 "length" 傳遞進去，屬性描述符爲：{[[Value]]: len, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}，參數爲 false
8. 令 map 爲表達式 new Object() 建立的對象，就是名爲 Object 的標準的內置構造函數
9. 令 mappedNames 爲一個空的 List 列表
10. 令 indx = len - 1
11. 當 indx >= 0 的時候，重複此過程：
    1. 令 val 爲 args（維度從 0 開始的 list 列表）的第 indx 維度所在的元素
    2. 調用 obj 的內部方法 [[DefineOwnProperty]]，將 ToString(indx) 傳遞進去，屬性描述符爲：{[[Value]]: val, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}，參數爲 false
    3. 若是 indx 小於 names 的元素個數，則
       1. 令 name 爲 names（維度從 0 開始的 list 列表）的第 indx 維度所在的元素
       2. 若是 strict 值爲 false，且 name 不是一個 mappedNames 元素，則
          1. 將 name 添加到 mappedNames 列表中，做爲它的一個元素
          2. 令 g 爲調用抽象操做 MakeArgGetter 的結果，其參數爲 name 和 env
          3. 令 p 爲調用抽象操做 MakeArgSetter 的結果，其參數爲 name 和 env
          4. 調用 map 對象的內部方法 [[DefineOwnProperty]]，將 ToString(indx) 傳遞進去，屬性描述符爲：{[[Set]]: p, [[Get]]: g, [[Configurable]]: true}，參數爲 false
    4. 令 indx = indx - 1
12. 若是 mappedNames 不爲空，則
    1. 將 obj 對象的內部屬性 [[ParameterMap]] 設置爲 map
    2. 將 obj 對象的內部方法 [[Get]], [[GetOwnProperty]], [[DefineOwnProperty]], [[Delete]] 按下面給出的定義進行設置。
13. 若是 strict 值爲 false，則
    1. 調用 obj 對象的內部方法 [[DefineOwnProperty]]，將 "callee" 傳遞進去，屬性描述符爲；{[[Value]]: func, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}，參數爲 false
14. 不然，strict 值爲 true，那麼
    1. 令 thrower 爲 [[ThrowTypeError]] 函數對象 (13.2.3)
    2. 調用 obj 對象的內部方法 [[DefineOwnProperty]]，將 "caller" 傳遞進去，屬性描述符爲 :{[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}，參數爲 false
    3. 調用 obj 對象的內部方法 [[DefineOwnProperty]]，將 "callee" 傳遞進去，屬性描述符爲 :{[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}，參數爲 false
15. 返回 obj

抽象操做 MakeArgGetter 以字符串 name 和環境記錄 env 做爲參數被調用時，會建立一個函數對象，當執行完後，會返回在 env 中綁定的 name 的值。執行步驟以下：

1. 令 body 爲字符 "return "，name，";" 的鏈接字符串
2. 返回一個按照 13.2 章節中描述的方式建立的函數對象，它不須要形參列表，以 body 做爲它的 FunctionBody，以 env 做爲它的 Scope，而且 Strict 值爲 true

抽象操做 MakeArgSetter 以字符串 name 和環境記錄 env 做爲參數被調用時，會建立一個函數對象，當執行完後，會給在 env 中綁定的 name 設置一個值。執行步驟以下：

1. 令 param 爲 name 和字符串 "_arg" 的鏈接字符串
2. 令 body 爲字符串 "=;"；將 替換爲 name 的值，將 替換爲 param 的值
3. 返回一個按照 13.2 章節中描述的方式建立的函數對象，以一個只包含字符串 param 的 list 列表做爲它的形參，以 body 做爲它的函數體（FunctionBody），以 env 做爲它的Scope，而且 Strict 值爲 true

當 arguments 對象的內部方法 [[Get]] 在一個非嚴格模式下帶有形參的函數中，在一個屬性名爲 P 的條件下被調用時，其執行步驟以下：

1. 令 map 爲 arguments 對象的內部屬性 [[ParameterMap]]
2. 令 isMapped 爲 map 對象的內部方法 [[GetOwnPropery]] 傳入參數 P 的執行結果
3. 若是 isMapped 值爲 undefined，則
   1. 令 v 爲 arguments 對象的內部默認的 [[Get]] 方法（8.12.3），傳入參數 P 的執行結果
   2. 若是 P 爲 "caller"，且 v 爲嚴格模式下的 Function 對象，則拋出一個 TypeError 的異常
   3. 返回 v
4. 不然，map 包含一個 P 的形參映射表
   1. 返回 map 對象的內部方法 [[Get]] 傳入參數 P 的執行結果

當 arguments 對象的內部方法 [[GetOwnProperty]] 在一個非嚴格模式下帶有形參的函數中，在一個屬性名爲 P 的條件下被調用時，其執行步驟以下：

1. 令 desc 爲 arguments 對象的內部方法 [[GetOwnPropery]]（8.12.1）傳入參數 P 的執行結果
2. 若是 desc 爲 undefined，返回 desc
3. 令 map 爲 arguments 對象內部屬性 [[ParameterMap]] 的值
4. 令 isMapped 爲 map 對象的內部方法 [[GetOwnPropery]] 傳入參數 P 的執行結果
5. 若是 isMapped 的值不是 undefined，則
   1. 將 desc 的值設置爲 map 對象的內部方法 [[Get]] 傳入參數 P 的執行結果
6. 返回 desc

當 arguments 對象的內部方法 [[DefineOwnProperty]] 在一個非嚴格模式下帶有形參的函數中，在一個屬性名爲 P，屬性描述符爲 Desc，布爾標誌爲 Throw 的條件下被調用時，其執行步驟以下：

1. 令 map 爲 arguments 對象的內部屬性 [[ParameterMap]] 的值
2. 令 isMapped 爲 map 對象的內部方法 [[GetOwnPropery]] 傳入參數 P 的執行結果
3. 令 allowed 爲 arguments 對象的內部方法 [[DefineOwnPropery]]（8.12.9）傳入參數 P，Desc，false 的執行結果
4. 若是 allowed 爲 false，則
   1. 若是 Throw 爲 true，則拋出一個 TypeError 的異常，不然，返回 false
5. 若是 isMapped 的值不爲 undefined，則
   1. 若是 IsAccessorDescriptor(Desc) 爲 true，則
      1. 調用 map 對象的內部方法 [[Delete]]，傳入 P 和 false 做爲參數
   2. 不然
      1. 若是 Desc.[[Value]] 存在，則
         1. 調用 map 對象的內部方法 [[Put]]，傳入 P，Desc.[[Value]] 和 Throw 做爲參數
      2. 若是 Desc.[[Writable]] 存在，且其值爲 false，則
         1. 調用 map 對象的內部方法 [[Delete]]，傳入 P 和 false 做爲參數
6. 返回 true

當 arguments 對象的內部方法 [[Delete]] 在一個非嚴格模式下帶有形參的函數中，在一個屬性名爲 P，布爾標誌爲 Throw 的條件下被調用時，其執行步驟以下：

1. 令 map 爲 arguments 對象的內部屬性 [[ParameterMap]] 的值
2. 令 isMapped 爲 map 對象的內部方法 [[GetOwnPropery]] 傳入參數 P 的執行結果
3. 令 result 爲 arguments 對象的內部方法 [[Delete]]（8.12.7）傳入參數 P 和 Throw 的執行結果
4. 若是 result 爲 true，且 isMapped 不爲 undefined，則
   1. 調用 map 對象的內部方法 [[Delete]]，傳入 P 和 false 做爲參數
5. 返回 result

非嚴格模式下的函數，arguments 對象以數組索引（參見 15.4 的定義）做爲數據屬性的命名，其數字名字的值少於對應的函數對象初始時的形參數量，它們與綁定在該函數執行環境中對應的參數共享值。這意味着，改變該屬性將改變這些對應的、綁定的參數的值，反之亦然。若是其中一個屬性被刪除而後再對其重定義，或者其中一個屬性在某個訪問器屬性內部被更改，則這種對應關係將被打破。嚴格模式下的函數，arguments 對象的屬性值就是傳入該函數的實際參數的簡單拷貝，它們與形參之間的值不存在動態的聯動關係。

ParameterMap 對象和它的屬性值被做爲說明 arguments 對象對應綁定參數的裝置。ParameterMap 對象和它的屬性值對象不能直接被 ECMAScript 代碼訪問。做爲 ECMAScript 的實現，不須要實際建立或使用這些對象去實現指定的語義。

嚴格模式下函數的 Arguments 對象定義的非可配置的訪問器屬性，"caller" 和 "callee"，在它們被訪問時，將拋出一個 TypeError 的異常。在非嚴格模式下，"callee" 屬性具備很是明確的意義，"caller" 屬性有一個歷史問題，它是否被提供，視爲一個由實做環境決定的，在具體的 ECMAScript 實做進行擴展。在嚴格模式下對這些屬性的定義的出現是爲了確保它們倆誰也不能在規範的 ECMAScript 實做中以任何方式被定義。

表達式

主值表達式

語法：

PrimaryExpression : this Identifier Literal ArrayLiteral ObjectLiteral ( Expression )

this 關鍵字

this 關鍵字執行爲當前執行環境的 ThisBinding。

標識符引用

Identifier 的執行遵循 10.3.1 所規定的標識符查找。標識符執行的結果老是一個 Reference 類型的值。

字面量引用

Literal 按照 7.8 所描述的方式執行。

數組初始化

數組初始化是一個以字面量的形式書寫的描述數組對象的初始化的表達式。它是一個零個或者多個表達式的序列，其中每個表示一個數組元素，而且用方括號括起來。元素並不必定要是字面量，每次數組初始化執行時它們都會被執行一次。

數組元素可能在元素列表的開始、結束，或者中間位置被省略。當元素列表中的一個逗號沒有被 AssignmentExpression 優先處理（如，一個逗號在另外一個逗號以前。）的狀況下，缺失的數組元素仍然會對數組長度有貢獻，而且增長後續元素的索引值。省略數組元素是沒有定義的。假如元素在數組末尾被省略，那麼元素不會貢獻數組長度。

語法：

ArrayLiteral : [ Elisionopt ] [ ElementList ] [ ElementList , Elisionopt ]ElementList : ElisionoptAssignmentExpression ElementList , ElisionoptAssignmentExpressionElision : , Elision ,

語義：

產生式 ArrayLiteral : [ Elision_opt ] 按照下面的過程執行 :

1. 令 array 爲以表達式 new Array() 徹底一致的方式建立一個新對象的結果，其中 Array 是一個標準的內置構造器
2. 令 pad 爲解釋執行 Elision 的結果 ; 若是不存在的話，使用數值 0.
3. 以參數 "length", pad, 和 false 調用 array 的 [[Put]] 內置方法
4. 返回 array.

產生式 ArrayLiteral : [ ElementList ] 按照下面的過程執行 :

1. 返回解釋執行 ElementList 的結果 .

產生式 ArrayLiteral : '[ ElementList , 'Elision_opt ] 按照下面的過程執行 :

1. 令 array 爲解釋執行 ElementList 的結果 .
2. 令 pad 爲解釋執行 Elision 的結果 ; 若是不存在的話，使用數值 0.
3. 令 len 爲以參數 "length". 調用 array 的 [[Get]] 內置方法的結果
4. 以參數 "length", ToUint32(pad+len), 和 false 調用 array 的 [[Put]] 內置方法
5. 返回 array.

產生式 ElementList : Elision_opt AssignmentExpression 按照下面的過程執行 :

1. 令 array 爲以表達式 new Array() 徹底一致的方式建立一個新對象的結果，其中 Array 是一個標準的內置構造器
2. 令 firstIndex 爲解釋執行 Elision 的結果 ; 若是不存在的話，使用數值 0.
3. 令 initResult 爲解釋執行 AssignmentExpression 的結果 .
4. 令 initValue 爲 GetValue(initResult).
5. 以參數 ToString(firstIndex), 屬性描述對象 { [[Value]]: initValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 調用 array 的 [[DefineOwnProperty]] 內置方法
6. 返回 array.

產生式 ElementList : ElementList , Elision_opt AssignmentExpression 按照下面的過程執行 :

1. 令 array 爲解釋執行 ElementList 的結果 .
2. 令 pad 爲解釋執行 Elision 的結果 ; 若是不存在的話，使用數值 0.
3. 令 initResult 爲解釋執行 AssignmentExpression 的結果 .
4. 令 initValue 爲 GetValue(initResult).
5. 令 len 爲以參數 "length". 調用 array 的 [[Get]] 內置方法的結果
6. 以參數 ToString(ToUint32((pad+len)) 和 屬性描述對象 { [[Value]]: initValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 調用 array 的 [[DefineOwnProperty]] 內置方法
7. 返回 array.

產生式 Elision : , 按照下面的過程執行 :

1. 返回數值 1.

產生式 Elision : Elision , 按照下面的過程執行 :

1. 令 preceding 爲解釋執行 Elision 的結果 .
2. 返回 preceding+1.

[[DefineOwnProperty]] 用於確保即便默認的數組原型對象被更改的狀況下自身屬性也會被定義，能夠杜絕用 [[put]] 建立一個新的自身屬性。

對象初始化

對象初始化是一個以直接量的方式描述對象的初始化過程的表達式。它是用花括號括起來的由零或者多對屬性名 / 關聯值組成的列表，值不須要是直接量，每次對象初始化被執行到時他們會執行一次。

語法：

ObjectLiteral : { } { PropertyNameAndValueList } { PropertyNameAndValueList , }PropertyNameAndValueList : PropertyAssignment PropertyNameAndValueList , PropertyAssignmentPropertyAssignment : PropertyName : AssignmentExpression get PropertyName() { FunctionBody } set PropertyName( PropertySetParameterList ) { FunctionBody }PropertyName : IdentifierName StringLiteral NumericLiteralPropertySetParameterList : Identifier

語義：

產生式 ObjectLiteral : { } 按照下面的過程執行 :

1. 返回 a new object created as if by the expression new Object() where Object is the st 和 ard built-in constructor with that name.

產生式 s ObjectLiteral : { PropertyNameAndValueList } 以及 ObjectLiteral : { PropertyNameAndValueList ,} 按照下面的過程執行 :

1. 返回解釋執行 PropertyNameAndValueList 的結果 .

產生式 PropertyNameAndValueList : PropertyAssignment 按照下面的過程執行 :

1. 令 obj 爲以表達式 new Object() 徹底一致的方式建立一個新對象的結果，其中 Object 是一個標準的內置構造器
2. 令 propId 爲解釋執行 PropertyAssignment 的結果 .
3. 以參數 propId.name, propId.descriptor, 和 false 調用 obj 的 [[DefineOwnProperty]] 內置方法
4. 返回 obj.

產生式 PropertyNameAndValueList : PropertyNameAndValueList , PropertyAssignment 按照下面的過程執行 :

1. 令 obj 爲解釋執行 PropertyNameAndValueList 的結果 .
2. 令 propId 爲解釋執行 PropertyAssignment 的結果 .
3. 令 previous 爲以參數 propId.name. 調用 obj 的 [[GetOwnProperty]] 內置方法的結果
4. 若是 previous 不是 undefined，且當如下任意一個條件爲 true 時，則拋出一個 SyntaxError 異常：
   • 產生式包含在嚴格模式下而且 IsDataDescriptor(previous) 爲 true 而且 IsDataDescriptor(propId.descriptor) 爲 true
   • IsDataDescriptor(previous) 爲 true 而且 IsAccessorDescriptor(propId.descriptor) 爲 true.
   • IsAccessorDescriptor(previous) 爲 true 而且 IsDataDescriptor(propId.descriptor) 爲 true.
   • IsAccessorDescriptor(previous) 爲 true 而且 IsAccessorDescriptor(propId.descriptor) 爲 true 而且 previous 和 propId.descriptor 都有 [[Get]] 字段 或者 previous 和 propId.descriptor 都有 [[Set]] 字段。

若是以上步驟拋出一個語法錯誤，那麼實現應該把這個錯誤視爲早期語法錯誤。

產生式 PropertyAssignment : PropertyName : AssignmentExpression 按照下面的過程執行 :

1. 令 propName 爲解釋執行 PropertyName 的結果 .
2. 令 exprValue 爲解釋執行 AssignmentExpression 的結果 .
3. 令 propValue 爲 GetValue(exprValue).
4. 令 desc 爲屬性描述對象 {[[Value]]: propValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}
5. 返回 Property Identifier (propName, desc).

產生式 PropertyAssignment : get PropertyName ( ) { FunctionBody } 按照下面的過程執行 :

1. 令 propName 爲解釋執行 PropertyName 的結果 .
2. 令 closure 爲按照 13.2 規定，以空的參數列表和 body 表明的 FunctionBody 建立的一個新的函數對象 . 傳入當前執行中的執行環境的 LexicalEnvironment 做爲 Scope. 假如 PropertyAssignment 包含在嚴格模式代碼中或者 FunctionBody 是嚴格模式代碼，傳入 true 爲嚴格模式標誌。
3. 令 desc 爲屬性描述對象 {[[Get]]: closure, [[Enumerable]]: true, [[Configurable]]: true}
4. 返回 Property Identifier (propName, desc).

產生式 PropertyAssignment : set PropertyName ( PropertySetParameterList ) { FunctionBody } is evaluated as follows:

1. 令 propName 爲解釋執行 PropertyName 的結果 .
2. 令 closure 爲按照 13.2 規定，以 PropertySetParameterList 做爲參數列表和 body 表明的 FunctionBody 建立的一個新的函數對象 . 傳入當前執行中的執行環境的 LexicalEnvironment 做爲 Scope. 假如 PropertyAssignment 包含在嚴格模式代碼中或者 FunctionBody 是嚴格模式代碼，傳入 true 爲嚴格模式標誌。
3. 令 desc 爲屬性描述對象 {[[Set]]: closure, [[Enumerable]]: true, [[Configurable]]: true}
4. 返回屬性標識符 (propName, desc).

假如 FunctionBody 是嚴格模式或者被包含在嚴格模式代碼內，PropertyAssignment 中的 PropertySetParameterList，"eval" 或者 "arguments" 做爲標識符將會是一個語法錯誤。

產生式 PropertyName : IdentifierName 按照下面的過程執行 :

1. 返回一個包含跟 IdentifierName. 徹底相同的字符序列的字符串值

產生式 PropertyName : StringLiteral 按照下面的過程執行 :

1. 返回 the SV of the StringLiteral.

產生式 PropertyName : NumericLiteral 按照下面的過程執行 :

1. 令 nbr 爲求 NumericLiteral 值的結果
2. 返回 ToString(nbr).

分組表達式

產生式 PrimaryExpression : ( Expression ) 按照下面的過程執行 :

1. 返回執行Expression的結果，它多是Reference類型。

這一算法並不會做用GetValue於執行Expression的結果。這樣作的原則是確保delete和typeof這樣的運算符能夠做用於括號括起來的表達式。

左值表達式

語法：

MemberExpression : PrimaryExpression FunctionExpression MemberExpression [ Expression ] MemberExpression . IdentifierName new MemberExpression ArgumentsNewExpression : MemberExpression new NewExpressionCallExpression : MemberExpression Arguments CallExpression Arguments CallExpression [ Expression ] CallExpression . IdentifierNameArguments : ( ) ( ArgumentList )ArgumentList : AssignmentExpression ArgumentList , AssignmentExpressionLeftHandSideExpression : NewExpression CallExpression

屬性訪問

屬性是經過 name 來訪問的，能夠使用點表示法訪問

MemberExpression . IdentifierName CallExpression . IdentifierName

或者括號表示法訪問

MemberExpression [ Expression ] CallExpression [ Expression ]

點表示法是根據如下的語法轉換解釋

MemberExpression . IdentifierName

這會等同於下面這個行爲

MemberExpression [ <identifier-name-string> ]

相似地，

CallExpression . IdentifierName

是等同於下面的行爲

CallExpression [ <identifier-name-string> ]

是一個字符串字面量，它與 Unicode 編碼後的 IdentifierName 包含相同的字符序列。

產生式 MemberExpression : MemberExpression [ Expression ] is evaluated as follows:

1. 令 baseReference 爲解釋執行 MemberExpression 的結果 .
2. 令 baseValue 爲 GetValue(baseReference).
3. 令 propertyNameReference 爲解釋執行 Expression 的結果 .
4. 令 propertyNameValue 爲 GetValue(propertyNameReference).
5. 調用 CheckObjectCoercible(baseValue).
6. 令 propertyNameString 爲 ToString(propertyNameValue).
7. 若是正在執行中的語法產生式包含在嚴格模式代碼當中，令 strict 爲 true, 不然令 strict 爲 false.
8. 返回一個值類型的引用，其基值爲 baseValue 且其引用名爲 propertyNameString, 嚴格模式標記爲 strict.

產生式CallExpression : CallExpression [ Expression ] 以徹底相同的方式執行，除了第1步執行的是其中的CallExpression。

new 運算符

產生式 NewExpression : new NewExpression 按照下面的過程執行 :

1. 令 ref 爲解釋執行 NewExpression 的結果 .
2. 令 constructor 爲 GetValue(ref).
3. 若是 Type(constructor) is not Object ，拋出一個 TypeError 異常 .
4. 若是 constructor 沒有實現 [[Construct]] 內置方法 ，拋出一個 TypeError 異常 .
5. 返回調用 constructor 的 [[Construct]] 內置方法的結果 , 傳入按無參數傳入參數列表 ( 就是一個空的參數列表 ).

產生式 MemberExpression : new MemberExpression Arguments 按照下面的過程執行 :

1. 令 ref 爲解釋執行 MemberExpression 的結果 .
2. 令 constructor 爲 GetValue(ref).
3. 令 argList 爲解釋執行 Arguments 的結果 , 產生一個由參數值構成的內部列表類型 (11.2.4).
4. 若是 Type(constructor) is not Object ，拋出一個 TypeError 異常 .
5. 若是 constructor 沒有實現 [[Construct]] 內置方法，拋出一個 TypeError 異常 .
6. 返回以 argList 爲參數調用 constructor 的 [[Construct]] 內置方法的結果。

函數調用

產生式 CallExpression : MemberExpression Arguments 按照下面的過程執行 :

1. 令 ref 爲解釋執行 MemberExpression 的結果 .
2. 令 func 爲 GetValue(ref).
3. 令 argList 爲解釋執行 Arguments 的結果 , 產生參數值們的內部列表 (see 11.2.4).
4. 若是 Type(func) is not Object ，拋出一個 TypeError 異常 .
5. 若是 IsCallable(func) is false ，拋出一個 TypeError 異常 .
6. 若是 Type(ref) 爲 Reference，那麼 若是 IsPropertyReference(ref) 爲 true，那麼 令 thisValue 爲 GetBase(ref). 不然 , ref 的基值是一個環境記錄項 令 thisValue 爲調用 GetBase(ref) 的 ImplicitThisValue 具體方法的結果
7. 不然 , 假如 Type(ref) 不是 Reference. 令 thisValue 爲 undefined.
8. 返回調用 func 的 [[Call]] 內置方法的結果 , 傳入 thisValue 做爲 this 值和列表 argList 做爲參數列表

產生式 CallExpression : CallExpression Arguments以徹底相同的方式執行，除了第1步執行的是其中的CallExpression。

假如func是一個原生的ECMAScript對象，返回的結果永遠不會是Reference類型，調用一個宿主對象是否返回一個Reference類型的值由實現決定。 若一Reference值返回，則它必須是一個非嚴格的屬性引用。

參數列表

The evaluation of an argument list produces a List of values (see 8.8).

產生式 Arguments : ( ) 按照下面的過程執行 :

1. 返回一個空列表 .

產生式 Arguments : ( ArgumentList ) 按照下面的過程執行 :

1. 返回解釋執行 ArgumentList 的結果 .

產生式 ArgumentList ':' AssignmentExpression 按照下面的過程執行 :

1. 令 ref 爲解釋執行 AssignmentExpression 的結果 .
2. 令 arg 爲 GetValue(ref).
3. 返回 a List whose sole item is arg.

產生式 ArgumentList :'''' ArgumentList , AssignmentExpression 按照下面的過程執行 :

1. 令 precedingArgs 爲解釋執行 ArgumentList 的結果 .
2. 令 ref 爲解釋執行 AssignmentExpression 的結果 .
3. 令 arg 爲 GetValue(ref).
4. 返回一個列表，長度比 precedingArgs 大 1 且 它的 items 爲 precedingArgs 的 items, 按順序在後面跟 arg，arg 是這個新的列表的最後一個 item.

函數表達式

產生式 MemberExpression : FunctionExpression 按照下面的過程執行 :

1. 返回解釋執行 FunctionExpression 的結果 .

後綴表達式

語法：

PostfixExpression : LeftHandSideExpression LeftHandSideExpression [ 此處無換行 LineTerminator] ++ LeftHandSideExpression [ 此處無換行 LineTerminator] --

後綴自增運算符

產生式 PostfixExpression : LeftHandSideExpression [ 此處無換行 LineTerminator] ++ 按照下面的過程執行 :

1. 令 lhs 爲解釋執行 LeftH 和 SideExpression 的結果 .
2. 假如如下全部條件都爲 true，拋出一個 SyntaxError 異常 :
   • Type(lhs) 爲 Reference
   • IsStrictReference(lhs) 爲 true
   • Type(GetBase(lhs)) 爲環境記錄項
   • GetReferencedName(lhs) 爲 "eval" 或 "arguments"

後綴自減運算符

產生式 PostfixExpression : LeftHandSideExpression [ 此處無換行 LineTerminator] -- 按照下面的過程執行 :

1. 令 lhs 爲解釋執行 LeftH 和 SideExpression 的結果 .
2. 假如如下全部條件都爲 true，拋出一個 SyntaxError 異常 :
   • Type(lhs) 爲 Reference
   • IsStrictReference(lhs) 爲 true
   • Type(GetBase(lhs)) 爲環境記錄項
   • GetReferencedName(lhs) 爲 "eval" 或 "arguments"

一元運算符

語法：

UnaryExpression : PostfixExpression delete UnaryExpression void UnaryExpression typeof UnaryExpression ++ UnaryExpression -- UnaryExpression + UnaryExpression - UnaryExpression ~ UnaryExpression  ! UnaryExpression

delete 運算符

產生式 UnaryExpression : delete UnaryExpression 按照下面的過程執行 :

1. 令 ref 爲解釋執行 UnaryExpression 的結果。
2. 若是 Type(ref) 不是 Reference，返回 true。
3. 若 IsUnresolvableReference(ref) 則 , 若是 IsStrictReference(ref) 爲 true ，拋出一個 SyntaxError 異常。 不然，返回 true。
4. 若是 IsPropertyReference(ref) 爲 true 則： 返回以 GetReferencedName(ref) 和 IsStrictReference(ref) 作爲參數調用 ToObject(GetBase(ref)) 的 [[Delete]] 內置方法的結果。
5. 不然 , ref 是到環境記錄項綁定的 Reference，因此： 若是 IsStrictReference(ref) 爲 true ，拋出一個 SyntaxError 異常 . 令 bindings 爲 GetBase(ref). 返回以 GetReferencedName(ref) 爲參數調用綁定的 DeleteBinding 具體方法的結果。

當delete運算符出如今strict模式代碼中的時候，若UnaryExpression是到變量，函數形參或者函數名的直接引用則拋出一個SyntaxError異常。此外若delete運算符出如今嚴格模式代碼中且要刪除的屬性具備特性{ [[Configurable]]: false }，拋出一個TypeError異常。

void 運算符

產生式 UnaryExpression : void UnaryExpression 按照下面的過程執行 :

1. 令 expr 爲解釋執行 UnaryExpression 的結果 .
2. 調用 GetValue(expr).
3. 返回 undefined.

GetValue必定要調用，即便它的值無用，可是可能會有可見的附加效果。

typeof 運算符

產生式 UnaryExpression : typeof UnaryExpression 按照下面的過程執行 :

1. 令 val 爲解釋執行 UnaryExpression 的結果 .
2. 若是 Type(val) 爲 Reference，則： 若是 IsUnresolvableReference(val) 爲 true，返回 "undefined"。 令 val 爲 GetValue(val).
3. 返回根據表 20 由 Type(val) 決定的字符串。

typeof 運算符結果

val類型	結果
Undefined	"undefined"
Null	"null"
Boolean	"boolean"
Number	"number"
String	"string"
Object（原生，且沒有實現 [[call]]）	"object"
Object（原生或者宿主且實現了 [[call]]）	"function"
Object（宿主且沒實現 [[call]]）	由實現定義，但不能是 "undefined", "boolean", "number", or "string"

前自增運算符

產生式 UnaryExpression : ++ UnaryExpression 按照下面的過程執行 :

1. 令 expr 爲解釋執行 UnaryExpression 的結果 .
2. 拋出一個 SyntaxError 異常當如下條件所有爲真 :
   • Type(expr) 爲 Reference
   • IsStrictReference(expr) 爲 true
   • Type(GetBase(expr)) 爲環境記錄項
   • GetReferencedName(expr) 是 "eval" 或 "arguments"

前自減運算符

產生式 UnaryExpression : -- UnaryExpression 按照下面的過程執行 :

1. 令 expr 爲解釋執行 UnaryExpression 的結果 .
2. 拋出一個 SyntaxError 異常，當如下條件所有爲真 :
   • Type(expr) 爲 Reference
   • IsStrictReference(expr) 爲 true
   • Type(GetBase(expr)) 爲環境記錄項
   • GetReferencedName(expr) 是 "eval" 或 "arguments"

一元 + 運算符

一元+運算符將其操做數轉換爲Number類型。

產生式 UnaryExpression : + UnaryExpression 按照下面的過程執行 :

1. 令 expr 爲解釋執行 UnaryExpression 的結果 .
2. 返回 ToNumber(GetValue(expr)).

一元 - 運算符

一元+運算符將其操做數轉換爲Number類型並反轉其正負。注意負的+0產生-0，負的-0產生+0。

產生式 UnaryExpression : - UnaryExpression 按照下面的過程執行 :

1. 令 expr 爲解釋執行 UnaryExpression 的結果 .
2. 令 oldValue 爲 ToNumber(GetValue(expr)).
3. 若是 oldValue is NaN ，return NaN.
4. 返回 oldValue 取負（即，算出一個數字相同可是符號相反的值）的結果。

按位非運算符

產生式 UnaryExpression : ~ UnaryExpression 按照下面的過程執行 :

1. 令 expr 爲解釋執行 UnaryExpression 的結果 .
2. 令 oldValue 爲 ToInt32(GetValue(expr)).
3. 返回 oldValue 按位取反的結果。結果爲 32 位有符號整數。

邏輯非運算符

產生式 UnaryExpression : ! UnaryExpression 按照下面的過程執行 :

1. 令 expr 爲解釋執行 UnaryExpression 的結果 .
2. 令 oldValue 爲 ToBoolean(GetValue(expr)).
3. 若是 oldValue 爲 true ，返回 false.
4. 返回 true.

乘法運算符

語法：

MultiplicativeExpression : UnaryExpression MultiplicativeExpression * UnaryExpression MultiplicativeExpression / UnaryExpression MultiplicativeExpression % UnaryExpression

語義：

產生式 MultiplicativeExpression : 'MultiplicativeExpression'@ 'UnaryExpression, 其中 @ 表示上面定義中的運算符之一，按照下面的過程執行 :

1. 令 left 爲解釋執行 MultiplicativeExpression 的結果 .
2. 令 leftValue 爲 GetValue(left).
3. 令 right 爲解釋執行 UnaryExpression 的結果 .
4. 令 rightValue 爲 GetValue(right).
5. 令 leftNum 爲 ToNumber(leftValue).
6. 令 rightNum 爲 ToNumber(rightValue).
7. 返回將特定運算符 (*, /, or %) 做用於 leftNum 和 rightNum 的結果。參見 11.5.1, 11.5.2, 11.5.3 後的註解。

使用 * 運算符

*運算符表示乘法，產生操做數的乘積。乘法運算知足交換律。由於精度問題，乘法不老是知足結合律。

浮點數的乘法遵循IEEE 754二進制雙精度幅度浮點算法規則：

• 若兩個操做數之一爲NaN，結果爲NaN。
• 假如兩個操做數的正負號相同，結果就是正的，若是不一樣就是負的。
• 無窮大被零乘結果是NaN。
• 無窮大被無窮大乘結果就是無窮大。符號按照前面說過的規則決定。
• 無窮大被有窮的非零值乘結果是帶正負號的無窮大。符號仍然按照前面說過的規則決定。
• 其它狀況下，既沒有無窮大也沒有NaN參與運算，結果計算出來後會按照IEEE 754 round-to-nearest模式取到最接近的能表示的數。若是值過大不能表示，則結果爲相應的正負無窮大。若是值太小不能表示，則結果爲相應的正負零。ECMAScript要求支持IEEE 754規定的漸進下溢。

使用 / 運算符

/運算符表示除法，產生操做數的商。左操做數是被除數，右操做數是除數。ECMAScript不支持整數除法。全部除法運算的操做數和結果都是雙精度浮點數。浮點數的除法遵循IEEE 754二進制雙精度幅度浮點算法規則：

• 若兩個操做數之一爲NaN，結果爲NaN。
• 假如兩個操做數的正負號相同，結果就是正的，若是不一樣就是負的。
• 無窮大被零乘結果是NaN。
• 無窮大被無窮大除結果是NaN。
• 無窮大被零除結果是無窮大。符號按照前面說過的規則決定。
• 無窮大被非零有窮的值除結果是有正負號的無窮大。符號按照前面說過的規則決定。
• 有窮的非零值被無窮大除結果是零。符號按照前面說過的規則決定。
• 零被零除結果是NaN；零被其它有窮數除結果是零，符號按照前面說過的規則決定。
• 有窮的非零值被零除結果是有正負號的無窮大。符號按照前面說過的規則決定。
• 其它狀況下，既沒有無窮大也沒有NaN參與運算，結果計算出來後會按照IEEE 754 round-to-nearest模式取到最接近的能表示的數。若是值過大不能表示，則結果爲相應的正負無窮大。若是值太小不能表示，則結果爲相應的正負零。ECMAScript要求支持IEEE 754規定的漸進下溢。

使用 % 運算符

%運算符產生其運算符在除法中的餘數。左操做數是被除數，右操做數是除數。

在C和C++中，餘數運算符只接受整數爲操做數；在ECMAScript，它還接受浮點操做數。

浮點數使用%運算符的餘數運算與IEEE 754所定義的"remainder"運算不徹底相同。IEEE 754 「remainder」運算作鄰近取整除法的餘數計算，而不是舍尾除法，這樣它的行爲跟一般意義上的整數餘數運算符行爲不一致。而ECMAScript語言定義浮點操做%爲與Java取餘運算符一致；能夠參照C庫中的函數fmod。

ECMAScript浮點數的取餘法遵循IEEE 754二進制雙精度幅度浮點算法規則：

• 若兩個操做數之一爲NaN，結果爲NaN。
• 結果的符號等於被除數。
• 若被除數是無窮大或者除數是零，或者二者皆是，結果就是NaN。
• 若被除數有窮而除數爲無窮大，結果爲被除數。
• 若被除數爲零且除數非零且有窮，結果與被除數相同。
• 其它狀況下，既沒有0，無窮大也沒有NaN參與運算，從被除數n和除數d獲得浮點數餘數r以數學關係式 r = n − (d × q) 定義，其中q是個整數，在n/d爲負時爲負，在n/d爲正時爲正，它應該在不超過n和d的商的前提下儘量大。結果計算出來後會按照IEEE 754 round-to-nearest模式取到最接近的能表示的數。

加法運算符

語法：

AdditiveExpression : MultiplicativeExpression AdditiveExpression + MultiplicativeExpression AdditiveExpression - MultiplicativeExpression

加號運算符 ( + )

The addition operator either performs string concatenation or numeric addition.

產生式 AdditiveExpression : AdditiveExpression + MultiplicativeExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 AdditiveExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 MultiplicativeExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 lprim 爲 ToPrimitive(lval).
6. 令 rprim 爲 ToPrimitive(rval).
7. 若是 Type(lprim) 爲 String 或者 Type(rprim) 爲 String，則： 返回由 ToString(lprim) 和 ToString(rprim) 鏈接而成的字符串
8. 返回將加法運算做用於 ToNumber(lprim) 和 ToNumber(rprim) 的結果。參見 11.6.3 後的註解。

在步驟5和6中的ToPrimitive調用沒有提供hint，除了Date對象以外全部ECMAScript對象將缺乏hint的狀況當作Number處理；Date對象將缺乏hint的狀況當作hint爲字符串。宿主對象可能將缺乏hint的狀況當作別的處理。

步驟7與關係運算符比較算法中的步驟3不一樣，它使用邏輯或運算符而不是邏輯與運算符

減號運算符 ( - )

產生式 AdditiveExpression : AdditiveExpression - MultiplicativeExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 AdditiveExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 MultiplicativeExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 lnum 爲 ToNumber(lval).
6. 令 rnum 爲 ToNumber(rval).
7. 返回返回將減法運算做用於 ToNumber(lprim) 和 ToNumber(rprim) 的結果。參見 11.6.3 後的註解。

加法做用於數字

+運算符做用於兩個數字類型的操做數時表示加法，產生兩個操做數之和。-運算符表示劍法，產生兩個數字之差。

加法是知足交換律的運算，可是不總知足結合律。

加法遵循IEEE 754二進制雙精度幅度浮點算法規則：

• 兩個正負號相反的無窮之和爲NaN。
• 兩個正負號相同的無窮大之和是具備相同正負的無窮大。
• 無窮大和有窮值之和等於操做數中的無窮大。
• 兩個負零之和爲-0。
• 兩個正零，或者兩個正負號相反的零之和爲+0。
• 零與非零有窮值之和等於非零的那個操做數。
• 兩個大小相等，符號相反的非零有窮值之和爲+0。
• 其它狀況下，既沒有無窮大也沒有NaN或者零參與運算，而且操做數要麼大小不等，要麼符號相同，結果計算出來後會按照IEEE 754 round-to-nearest模式取到最接近的能表示的數。若是值過大不能表示，則結果爲相應的正負無窮大。若是值太小不能表示，則結果爲相應的正負零。ECMAScript要求支持IEEE 754規定的漸進下溢。

-運算符做用於兩個數字類型時表示減法，產生兩個操做數之差。左邊操做數是被減數右邊是減數。給定操做數a和b，老是有a–b產生與a + ( -b )產生相同結果。

位運算移位運算符

語法：

ShiftExpression : AdditiveExpression ShiftExpression << AdditiveExpression ShiftExpression >> AdditiveExpression ShiftExpression >>> AdditiveExpression

左移運算符

表示對左操做數作右操做數指定次數的按位左移操做。

產生式 ShiftExpression : ShiftExpression << AdditiveExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 ShiftExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 AdditiveExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 lnum 爲 ToInt32(lval).
6. 令 rnum 爲 ToUint32(rval).
7. 令 shiftCount 爲用掩碼算出 rnum 的最後五個比特位 , 即計算 rnum & 0x1F 的結果。
8. 返回 lnum 左移 shiftCount 比特位的結果。結果是一個有符號 32 位整數。

帶符號右移運算符

filling bitwise right shift operation on the left operand by the amount specified by the right operand.

產生式 ShiftExpression : ShiftExpression >> AdditiveExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 ShiftExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 AdditiveExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 lnum 爲 ToInt32(lval).
6. 令 rnum 爲 ToUint32(rval).
7. 令 shiftCount 爲用掩碼算出 rnum 的最後五個比特位 , 即計算 rnum & 0x1F 的結果。
8. 返回 lnum 帶符號擴展的右 移 shiftCount 比特位的結果 . The most significant bit is propagated. 結果是一個有符號 32 位整數。

無符號右移運算符

Performs a zero-filling bitwise right shift operation on the left operand by the amount specified by the right operand.

產生式 ShiftExpression : ShiftExpression >>> AdditiveExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 ShiftExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 AdditiveExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 lnum 爲 ToUint32(lval).
6. 令 rnum 爲 ToUint32(rval).
7. 令 shiftCount 爲用掩碼算出 rnum 的最後五個比特位 , 即計算 rnum & 0x1F 的結果。
8. 返回 lnum 作 0 填充右移 shiftCount 比特位的結果 . 缺乏的比特位填 0。 結果是一個無符號 32 位整數 .

比較運算符

語法：

RelationalExpression : ShiftExpression RelationalExpression < ShiftExpression RelationalExpression > ShiftExpression RelationalExpression <= ShiftExpression RelationalExpression >= ShiftExpression RelationalExpression instanceof ShiftExpression RelationalExpression in ShiftExpressionRelationalExpressionNoIn : ShiftExpression RelationalExpressionNoIn < ShiftExpression RelationalExpressionNoIn > ShiftExpression RelationalExpressionNoIn <= ShiftExpression RelationalExpressionNoIn >= ShiftExpression RelationalExpressionNoIn instanceof ShiftExpression

「NoIn」變體用以免混淆關係表達式中的in運算符和for語句中的in運算符。

語義：

執行關係比較運算符的結果老是Boolean類型。表示是否由運算符指定的關係對兩操做數成立。

RelationalExpressionNoIn跟RelationalExpression徹底按相同的方式執行，出了RelationalExpressionNoIn要代替RelationalExpression被執行。

The Less-than Operator ( < )

產生式 RelationalExpression : RelationalExpression < ShiftExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 RelationalExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 ShiftExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 r 爲抽象關係比較算法 lval < rval( 參見 11.8.5) 的結果
6. 若是 r 爲 undefined，返回 false. 不然 , 返回 r.

The Greater-than Operator ( > )

產生式 RelationalExpression : RelationalExpression > ShiftExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 RelationalExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 ShiftExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 r 爲爲抽象關係比較算法 lval < rval( 參見 11.8.5) 的結果，參數 LeftFirst 設爲 false
6. 若是 r 爲 undefined，返回 false. 不然 , 返回 r.

The Less-than-or-equal Operator ( <= )

產生式 RelationalExpression : RelationalExpression <= ShiftExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 RelationalExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 ShiftExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 r 爲爲抽象關係比較算法 rval < lval( 參見 11.8.5) 的結果，參數 LeftFirst 設爲 false
6. 若是 r 爲 true 或者 undefined ，返回 false. 不然 , 返回 true.

The Greater-than-or-equal Operator ( >= )

產生式 RelationalExpression : RelationalExpression >= ShiftExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 RelationalExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 ShiftExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 r 爲抽象關係比較算法 lval < rval( 參見 11.8.5) 的結果
6. 若是 r 爲 true 或者 undefined ，返回 false. 不然 , 返回 true.

抽象關係比較算法

以 x 和 y 爲值進行小於比較（x<y 的比較），會產生的結果可爲="" true，false或 undefined（這說明 x、y 中最少有一個操做數是 NaN）。除了 x 和 y，這個算法另外須要一個名爲 LeftFirst 的布爾值標記做爲參數。這個標記用於解析順序的控制，由於操做數 x 和 y 在執行的時候會有潛在可見的反作用。LeftFirst 標誌是必須的，由於 ECMAScript 規定了表達式是從左到右順序執行的。LeftFirst 的默認值是 true，這代表在相關的表達式中，參數 x 出如今參數 y 以前。若是 LeftFirst 值是 false，狀況會相反，操做數的執行必須是先 y 後 x。這樣的一個小於比較的執行步驟以下：

1. 若是 LeftFirst 標誌是 true，那麼
   1. 讓 px 爲調用 ToPrimitive(x, hint Number) 的結果。
   2. 讓 py 爲調用 ToPrimitive(y, hint Number) 的結果。
2. 不然解釋執行的順序須要反轉，從而保證從左到右的執行順序
   1. 讓 py 爲調用 ToPrimitive(y, hint Number) 的結果。
   2. 讓 px 爲調用 ToPrimitive(x, hint Number) 的結果。
3. 若是 Type(px) 和 Type(py) 獲得的結果不都是 String 類型，那麼
   1. 讓 nx 爲調用 ToNumber(px) 的結果。由於 px 和 py 都已是基本數據類型（primitive values 也做原始值），其執行順序並不重要。
   2. 讓 ny 爲調用 ToNumber(py) 的結果。
   3. 若是 nx 是 NaN，返回 undefined
   4. 若是 ny 是 NaN，返回 undefined
   5. 若是 nx 和 ny 的數字值相同，返回 false
   6. 若是 nx 是 +0 且 ny 是 -0，返回 flase
   7. 若是 nx 是 -0 且 ny 是 +0，返回 false
   8. 若是 nx 是 +∞，返回 fasle
   9. 若是 ny 是 +∞，返回 true
   10. 若是 ny 是 -∞，返回 flase
   11. 若是 nx 是 -∞，返回 true
   12. 若是 nx 數學上的值小於 ny 數學上的值（注意這些數學值都不能是無限的且不能都爲 0），返回 ture。不然返回 false。
4. 不然，px 和 py 都是 Strings 類型
   1. 若是 py 是 px 的一個前綴，返回 false。（當字符串 q 的值能夠是字符串 p 和一個其餘的字符串 r 拼接而成時，字符串 p 就是 q 的前綴。注意：任何字符串都是本身的前綴，由於 r 多是空字符串。）
   2. 若是 px 是 py 的前綴，返回 true。
   3. 讓 k 成爲最小的非負整數，能使得在 px 字符串中位置 k 的字符與字符串 py 字符串中位置 k 的字符不相同。（這裏必須有一個 k，使得互相都不是對方的前綴）
   4. 讓 m 成爲字符串 px 中位置 k 的字符的編碼單元值。
   5. 讓 n 成爲字符串 py 中位置 k 的字符的編碼單元值。
   6. 若是 n<m，返回 true。不然，返回 false。

使用或代替的時候要注意，這裏的步驟 3 和加號操做符 + 算法 (11.6.1) 的步驟 7 的區別。

String 類型的比較使用了其編碼單元值的做爲一個簡單的詞法表序列去比較。這裏不打算使用更復雜的、語義化的字符或字符串序列，和 Unicode 規範的整理序列進行比較。所以，字符串的值和其對應的 Unicode 標準的值是不相同的。實際上，這個算法假定了全部字符串已是正常化的格式。同時要注意，對於字符串拼接追加的字符的時候，UTF-16 編碼單元值的詞法表序列是不一樣於代碼點值的序列的。

The instanceof operator

產生式 RelationalExpression: RelationalExpression instanceof ShiftExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 RelationalExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 ShiftExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 若是 Type(rval) 不是 Object，拋出一個 TypeError 異常 .
6. 若是 rval 沒有 [[HasInstance]] 內置方法，拋出一個 TypeError 異常 .
7. 返回以參數 lval. 調用 rval 的 [[HasInstance]] 內置方法的結果

The in operator

產生式 RelationalExpression : RelationalExpression in ShiftExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 RelationalExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 ShiftExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 若是 Type(rval) 不是 Object ，拋出一個 TypeError 異常 .
6. 返回以參數 ToString(lval). 調用 rval 的 [[HasProperty]] 內置方法的結果

等值運算符

語法：

EqualityExpression : RelationalExpression EqualityExpression == RelationalExpression EqualityExpression != RelationalExpression EqualityExpression === RelationalExpression EqualityExpression !== RelationalExpressionEqualityExpressionNoIn : RelationalExpressionNoIn EqualityExpressionNoIn == RelationalExpressionNoIn EqualityExpressionNoIn != RelationalExpressionNoIn EqualityExpressionNoIn === RelationalExpressionNoIn EqualityExpressionNoIn !== RelationalExpressionNoIn

語義：

執行相等比較運算符的結果老是Boolean類型。表示是否由運算符指定的關係對兩操做數成立。

EqualityExpressionNoIn跟EqualityExpression徹底按相同的方式執行，出了RelationalExpressionNoIn要代替RelationalExpression被執行。

The Equals Operator ( == )

產生式 EqualityExpression : EqualityExpression == RelationalExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 EqualityExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 RelationalExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 返回作用相等比較算法於 rval == lval( 參見 11.9.3) 的結果

The Does-not-equals Operator ( != )

產生式 EqualityExpression : EqualityExpression != RelationalExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 EqualityExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 RelationalExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 r 爲作用相等比較算法於 rval == lval( 參見 11.9.3) 的結果
6. 若是 r 爲 true，返回 false. 不然 , 返回 true.

抽象相等比較算法

比較運算x==y, 其中x和 y是值，產生true或者false。這樣的比較按以下方式進行：

1. 若Type(x)與Type(y)相同， 則
   1. 若Type(x)爲Undefined， 返回true。
   2. 若Type(x)爲Null， 返回true。
   3. 若Type(x)爲Number， 則
      1. 若x爲NaN， 返回false。
      2. 若y爲NaN， 返回false。
      3. 若x與y爲相等數值， 返回true。
      4. 若x 爲 +0 且 y爲−0， 返回true。
      5. 若x 爲 −0 且 y爲+0， 返回true。
      6. 返回false。
   4. 若Type(x)爲String, 則當x和y爲徹底相同的字符序列（長度相等且相同字符在相同位置）時返回true。 不然， 返回false。
   5. 若Type(x)爲Boolean, 當x和y爲同爲true或者同爲false時返回true。 不然， 返回false。
   6. 當x和y爲引用同一對象時返回true。不然，返回false。
2. 若x爲null且y爲undefined， 返回true。
3. 若x爲undefined且y爲null， 返回true。
4. 若Type(x) 爲 Number 且 Type(y)爲String， 返回comparison x == ToNumber(y)的結果。
5. 若Type(x) 爲 String 且 Type(y)爲Number，
6. 返回比較ToNumber(x) == y的結果。
7. 若Type(x)爲Boolean， 返回比較ToNumber(x) == y的結果。
8. 若Type(y)爲Boolean， 返回比較x == ToNumber(y)的結果。
9. 若Type(x)爲String或Number，且Type(y)爲Object，返回比較x == ToPrimitive(y)的結果。
10. 若Type(x)爲Object且Type(y)爲String或Number， 返回比較ToPrimitive(x) == y的結果。
11. 返回false。

按以上相等之定義：

• 字符串比較能夠按這種方式強制執行: "" + a == "" + b。
• 數值比較能夠按這種方式強制執行: +a == +b。
• 布爾值比較能夠按這種方式強制執行: !a == !b。

等值比較操做保證如下不變：

• A != B等價於!(A==B)。
• A == B等價於B == A，除了A與B的執行順序。

相等運算符不老是傳遞的。例如，兩個不一樣的String對象，都表示相同的字符串值；==運算符認爲每一個String對象都與字符串值相等，可是兩個字符串對象互不相等。例如：

• new String("a") == "a" 和 "a" == new String("a")皆爲true。
• new String("a") == new String("a")爲false。

字符串比較使用的方式是簡單地檢測字符編碼單元序列是否相同。不會作更復雜的、基於語義的字符或者字符串相等的定義以及Unicode規範中定義的collating order。因此Unicode標準中認爲相等的String值可能被檢測爲不等。實際上這一算法認爲兩個字符串已是通過規範化的形式。

嚴格等於運算符 ( === )

產生式 EqualityExpression : EqualityExpression === RelationalExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 EqualityExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 RelationalExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 返回作用嚴格相等比較算法於 rval === lval( 參見 11.9.6) 的結果

The Strict Does-not-equal Operator ( !== )

產生式 EqualityExpression : EqualityExpression !== RelationalExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 EqualityExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 RelationalExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 r 爲作用嚴格相等比較算法於 rval === lval( 參見 11.9.6) 的結果
6. 若是 r 爲 true，返回 false. 不然 , 返回 true.

嚴格等於比較算法

比較 x===y，x 和 y 爲值，須要產出 true 或 false。比較過程以下：

1. 若是 Type(x) 與 Type(y) 的結果不一致，返回 false，不然
2. 若是 Type(x) 結果爲 Undefined，返回 true
3. 若是 Type(x) 結果爲 Null，返回 true
4. 若是 Type(x) 結果爲 Number，則
   1. 若是 x 爲 NaN，返回 false
   2. 若是 y 爲 NaN，返回 false
   3. 若是 x 與 y 爲同一個數字，返回 true
   4. 若是 x 爲 +0，y 爲 -0，返回 true
   5. 若是 x 爲 -0，y 爲 +0，返回 true
   6. 返回 false
5. 若是 Type(x) 結果爲 String，若是 x 與 y 爲徹底相同的字符序列（相同的長度和相同的字符對應相同的位置），返回 true，不然，返回 false
6. 若是 Type(x) 結果爲 Boolean，若是 x 與 y 都爲 true 或 false，則返回 true，不然，返回 false
7. 若是 x 和 y 引用到同一個 Object 對象，返回 true，不然，返回 false

此算法與 SameValue 算法在對待有符號的零和 NaN 上表現不一樣。

二進制位運算符

語法：

BitwiseANDExpression : EqualityExpression BitwiseANDExpression & EqualityExpressionBitwiseANDExpressionNoIn : EqualityExpressionNoIn BitwiseANDExpressionNoIn & EqualityExpressionNoInBitwiseXORExpression : BitwiseANDExpression BitwiseXORExpression ^ BitwiseANDExpressionBitwiseXORExpressionNoIn : BitwiseANDExpressionNoIn BitwiseXORExpressionNoIn ^ BitwiseANDExpressionNoInBitwiseORExpression : BitwiseXORExpression BitwiseORExpression | BitwiseXORExpressionBitwiseORExpressionNoIn : BitwiseXORExpressionNoIn BitwiseORExpressionNoIn | BitwiseXORExpressionNoIn

語義：

產生式 A : A' @ 'B, 其中 @ 是上述產生式中的位運算符之一，按照下面的過程執行 :

1. 令 lref 爲解釋執行 A 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 B 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 lnum 爲 ToInt32(lval).
6. 令 rnum 爲 ToInt32(rval).
7. 返回做用位運算符 @ 到 lnum 和 rnum. 結果是 32 位有符號整數。

二元邏輯運算符

語法

LogicalANDExpression : BitwiseORExpression LogicalANDExpression && BitwiseORExpressionLogicalANDExpressionNoIn : BitwiseORExpressionNoIn LogicalANDExpressionNoIn && BitwiseORExpressionNoInLogicalORExpression : LogicalANDExpression LogicalORExpression || LogicalANDExpressionLogicalORExpressionNoIn : LogicalANDExpressionNoIn LogicalORExpressionNoIn || LogicalANDExpressionNoIn

語義

產生式 LogicalANDExpression : LogicalANDExpression && BitwiseORExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 LogicalANDExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 若是 ToBoolean(lval) 爲 false ，返回 lval.
4. 令 rref 爲解釋執行 BitwiseORExpression 的結果 .
5. 返回 GetValue(rref).

產生式 LogicalORExpression : LogicalORExpression || LogicalANDExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 LogicalORExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 若是 ToBoolean(lval) 爲 true ，返回 lval.
4. 令 rref 爲解釋執行 LogicalANDExpression 的結果 .
5. 返回 GetValue(rref).

LogicalANDExpressionNoIn和LogicalORExpressionNoIn執行徹底按照LogicalANDExpression和LogicalORExpression相同的方式，BitwiseORExpressionNoIn和LogicalORExpressionNoIn替代了BitwiseORExpression和LogicalORExpression除外。

由&& 或者||運算符產生的值不是必須爲Boolean類型，產生的值始終爲兩個運算表達式的結果之一。

條件運算符

語法：

ConditionalExpression : LogicalORExpression LogicalORExpression ? AssignmentExpression : AssignmentExpressionConditionalExpressionNoIn : LogicalORExpressionNoIn LogicalORExpressionNoIn ? AssignmentExpressionNoIn : AssignmentExpressionNoIn

語義

產生式 ConditionalExpression : LogicalORExpression ? AssignmentExpression : AssignmentExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 LogicalORExpression 的結果 .
2. 若是 ToBoolean(GetValue(lref)) 爲 true ，那麼： 令 trueRef 爲解釋執行第一個 AssignmentExpression 的結果 . 返回 GetValue(trueRef).
3. Else 令 falseRef 爲解釋執行第二個 AssignmentExpression 的結果 . 返回 GetValue(falseRef).

ConditionalExpressionNoIn執行徹底按照ConditionalExpression 相同的方式，除了AssignmentExpression和AssignmentExpressionNoIn替代了第一個AssignmentExpression和第二個AssignmentExpression。

ECMAScript中的ConditionalExpression跟C和Java有一點點不一樣，它容許第二個子表達式是個Expression可是限制第三個表達式必須是ConditionalExpression。ECMAScript中這個差異的依據是能夠容許容許賦值表達式出如今條件的任意一側同時避免逗號表達式做爲中間的表達式時無用且易混淆的使用方式。

賦值運算符

語法

AssignmentExpression : ConditionalExpression LeftHandSideExpression = AssignmentExpression LeftHandSideExpression AssignmentOperator AssignmentExpressionAssignmentExpressionNoIn : ConditionalExpressionNoIn LeftHandSideExpression = AssignmentExpressionNoIn LeftHandSideExpression AssignmentOperator AssignmentExpressionNoInAssignmentOperator : one of *= /= %= += -= <<= >>= >>>= &= ^= |=

語義

AssignmentExpressionNoIn 執行徹底按照AssignmentExpression相同的方式，除了ConditionalExpressionNoIn替代了ConditionalExpression。

簡單賦值

產生式 AssignmentExpression : LeftHandSideExpression = AssignmentExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 LeftH 和 SideExpression 的結果 .
2. 令 rref 爲解釋執行 AssignmentExpression 的結果 .
3. 令 rval 爲 GetValue(rref).
4. 拋出一個 SyntaxError 異常，當如下條件都成立 :
   • Type(lref) 爲 Reference
   • IsStrictReference(lref) 爲 true
   • Type(GetBase(lref)) 爲環境記錄項
   • GetReferencedName(lref) 爲 "eval" 或 "arguments"
5. 調用 PutValue(lref, rval).
6. 返回 rval.

當賦值發生在嚴格模式中時其LeftHandSide執行結果不能是沒法解引用的引用類型。假如這樣它會在賦值時拋出ReferenceError異常。 LeftHandSide也不能是到具備{[[Writable]]:false}特性的數據屬性的引用，到具備{[[Set]]:undefined}特性的訪問器屬性的引用，或者 [[Extensible]]內部屬性值爲false的對象上不存在的屬性。這些狀況都會拋出TypeError異常。

組合賦值

產生式 AssignmentExpression : LeftHandSideExpression'@ = AssignmentExpression, where @ represents one of the operators indicated above, 按照下面的過程執行 :

1. 令 lref 爲解釋執行 LeftH 和 SideExpression 的結果 .
2. 令 lval 爲 GetValue(lref).
3. 令 rref 爲解釋執行 AssignmentExpression 的結果 .
4. 令 rval 爲 GetValue(rref).
5. 令 r 爲做用運算符 @ 於 lval 和 rval 的結果。
6. 拋出一個 SyntaxError 異常，當如下條件所有成立：
   • Type(lref) 爲 Reference
   • IsStrictReference(lref) 爲 true
   • Type(GetBase(lref)) 爲環境記錄項
   • GetReferencedName(lref) 爲 "eval" 或 "arguments"
7. 調用 PutValue(lref, r).
8. 返回 r.

見 注11.13.1。

逗號運算符

語法：

Expression : AssignmentExpression Expression , AssignmentExpressionExpressionNoIn : AssignmentExpressionNoIn ExpressionNoIn , AssignmentExpressionNoIn

語義：

產生式 Expression : Expression , AssignmentExpression 按照下面的過程執行 :

1. 令 lref 爲解釋執行 Expression 的結果 .
2. Call GetValue(lref).
3. 令 rref 爲解釋執行 AssignmentExpression 的結果 .
4. 返回 GetValue(rref).

ExpressionNoIn 執行徹底按照Expression相同的方式，除了AssignmentExpressionNoIn替代了AssignmentExpression。

GetValue必須調用，即便它的值沒有用，由於它可能有附加效果。

語句

語法：

Statement : Block VariableStatement EmptyStatement ExpressionStatement IfStatement IterationStatement ContinueStatement BreakStatement ReturnStatement WithStatement LabelledStatement SwitchStatement ThrowStatement TryStatement DebuggerStatement

語義：

一個 Statement 能夠是 LabelledStatement 的一部分，這個 LabelledStatement 自身也能夠是 LabelledStatement 的一部分，以此類推。當描述個別語句時引入標籤的這種方式統稱爲「當前標籤組」。一個 LabelledStatement 介紹了一個標籤到一個 標籤組 ，此外沒有其餘語義。一個 IterationStatement 或 SwitchStatement 的標籤組最初包含單個 空 元素。任何其餘語句的標籤組最初是空的。

The result of evaluating a Statement is always a Completion value.

已知幾個普遍使用的 ECMAScript 實現支持 FunctionDeclaration 看成語句使用。然而，在實現之間這種 FunctionDeclarations 應用的語義也有嚴重且不兼容的差別。因爲這些不兼容的差別，將 FunctionDeclaration 看成 Statement 使用的結果是代碼在實現之間的可移植性不可靠。建議 ECMAScript 實現禁止這樣運用 FunctionDeclaration，或遇到這樣的運用是發出一個警告。ECMAScript 的將來版本可能定義替代的兼容方案以在 Statement 上下文中聲明函數。

塊

語法：

Block : { StatementListopt }StatementList : Statement StatementList Statement

語義：

產生式 Block : { } 按照下面的過程執行 :

1. 返回 (normal, empty, empty)。

產生式 Block : { StatementList } 按照下面的過程執行 :

1. 返回解釋執行 StatementList 的結果。

產生式 StatementList :Statement 按照下面的過程執行 :

1. 令 s 爲解釋執行 Statement 的結果。
2. 若是有一個異常被拋出，返回 (throw, V, empty)，這裏的 V 是異常。( 彷彿沒有拋出異常同樣繼續運行。)
3. 返回 s。

產生式 StatementList :StatementList Statement 按照下面的過程執行 :

1. 令 sl 爲解釋執行 StatementList 的結果。
2. 若是 sl 是個很是規完結，返回 sl。
3. 令 s 爲解釋執行 Statement 的結果。
4. 若是有一個異常被拋出，返回 (throw, V, empty)，這裏的 V 是異常。 ( 彷彿沒有拋出異常同樣繼續運行。)
5. 若是 s.value 是 empty ，令 V = sl.value, 不然令 V = s.value。
6. 返回 (s.type, V, s.target)。

以上算法中步驟5和步驟6確保了StatementList的值是StatementList中最後一個產生值的Statement的值。例如如下eval函數的調用全都返回1

eval("1;;;;;") eval("1;{}") eval("1;var a;")

變量語句

語法：

VariableStatement : var VariableDeclarationList ;VariableDeclarationList : VariableDeclaration VariableDeclarationList , VariableDeclarationVariableDeclarationListNoIn : VariableDeclarationNoIn VariableDeclarationListNoIn , VariableDeclarationNoInVariableDeclaration : Identifier InitialiseroptVariableDeclarationNoIn : Identifier InitialiserNoInoptInitialiser : = AssignmentExpressionInitialiserNoIn : = AssignmentExpressionNoIn

一個變量語句聲明依 10.5 中定義建立的變量。當建立變量時初始化爲 undefined。當 VariableStatement 被執行時變量關聯的 Initialiser 會被分配 AssignmentExpression 的值，而不是在變量建立時。

語義：

產生式 VariableStatement : var VariableDeclarationList ; 按照下面的過程執行 :

1. 解釋執行 VariableDeclarationList.
2. 返回 (normal, empty, empty).

產生式 VariableDeclarationList : VariableDeclaration 按照下面的過程執行 :

1. 解釋執行 VariableDeclaration.

產生式 VariableDeclarationList : VariableDeclarationList , VariableDeclaration 按照下面的過程執行 :

1. 解釋執行 VariableDeclarationList.
2. 解釋執行 VariableDeclaration.

產生式 VariableDeclaration : Identifier 按照下面的過程執行 :

1. 返回一個包含跟 Identifier. 徹底相同的字符序列的字符串值

產生式 VariableDeclaration : Identifier Initialiser 按照下面的過程執行 :

1. 令 lhs 爲解釋執行 Identifier 的結果 as described in 11.1.2.
2. 令 rhs 爲解釋執行 Initialiser 的結果 .
3. 令 value 爲 GetValue(rhs).
4. Call PutValue(lhs, value).
5. 返回一個包含跟 Identifier. 徹底相同的字符序列的字符串值

VariableDeclaration 的字符串值用在 for-in 語句 (12.6.4) 的解釋執行。

若是 VariableDeclaration 嵌套在 with 語句裏而且 VariableDeclaration 裏的標識符與 with 語句的對象式環境記錄項關聯的綁定對象的一個屬性名相同，則第 4 步將給這個屬性分配值，而不是爲 Identifier 的 VariableEnvironment 綁定分配值。

產生式 Initialiser : = AssignmentExpression 按照下面的過程執行 :

1. 返回解釋執行 AssignmentExpression 的結果 .

產生式 VariableDeclarationListNoIn, VariableDeclarationNoIn, InitialiserNoIn 解釋執行的方式與產生式 VariableDeclarationList, VariableDeclaration，Initialiser 相同，除了他們包含的VariableDeclarationListNoIn, VariableDeclarationNoIn, InitialiserNoIn, AssignmentExpressionNoIn 會分別替代 VariableDeclarationList, VariableDeclaration, Initialiser, AssignmentExpression 來解釋執行。

嚴格模式的限制

若是一個 VariableDeclaration 或 VariableDeclarationNoIn 出如今 嚴格模式代碼 裏而且其 Identifier 是 "eval" 或 "arguments"，那麼這是個 SyntaxError。

空語句

語法 :

EmptyStatement : ;

語義：

產生式 EmptyStatement : ; 按照下面的過程執行 :

1. 返回 (normal, empty, empty).

表達式語句

語法：

ExpressionStatement : [lookahead ∉ {{, function}]Expression ;

一個 ExpressionStatement 不能用一個開大括號開始，由於這可能會使它和 Block 混淆。此外，ExpressionStatement 不能用 function 關鍵字開始，由於這可能會使它和FunctionDeclaration 混淆。

語義：

產生式 ExpressionStatement : [lookahead ∉ {{',' function}]Expression; 按照下面的過程執行 :

1. 令 exprRef 爲解釋執行 Expression 的結果 .
2. 返回 (normal, GetValue(exprRef), empty).

if 語句

語法：

IfStatement : if ( Expression ) Statement else Statement if ( Expression ) Statement

每一個 else 選擇與它相關聯的 if 是不肯定的，應與此 else 最近的而且本來沒有與其對應的 else 的可能的 if 對應。

語義：

產生式 IfStatement : if ( Expression ) Statement else Statement 按照下面的過程執行 :

1. 令 exprRef 爲解釋執行 Expression 的結果 .
2. 若是 ToBoolean(GetValue(exprRef)) is true ，then
   1. 返回解釋執行 the 的結果 first Statement.
3. Else,
   1. 返回解釋執行 the 的結果 second Statement.

產生式 IfStatement : if ( Expression ) Statement 按照下面的過程執行 :

1. 令 exprRef 爲解釋執行 Expression 的結果 .
2. 若是 ToBoolean(GetValue(exprRef)) is false ，return (normal, empty, empty).
3. 返回解釋執行 Statement 的結果 .

迭代語句

語法：

IterationStatement : do Statement while ( Expression ); while ( Expression ) Statement for ( ExpressionNoInopt; Expressionopt ; Expressionopt ) Statement for ( var VariableDeclarationListNoIn; Expressionopt ; Expressionopt ) Statement for ( LeftHandSideExpression in Expression ) Statement for ( var VariableDeclarationNoIn in Expression ) Statement

do-while 語句

產生式 do Statement while ( Expression ); 按照下面的過程執行 :

1. 令 V = empty。
2. 令 iterating 爲 true。
3. 只要 iterating 爲 true，就重複
   1. 令 stmt 爲解釋執行 Statement 的結果。
   2. 若是 stmt.value 不是 empty，令 V = stmt.value。
   3. 若是 stmt.type 不是 continue || stmt.target 不在當前標籤組，則
      1. 若是 stmt.type 是 break 而且 stmt.target 在當前標籤組內，返回 (normal, V, empty)。
      2. 若是 stmt 是個 很是規完結 ，返回 stmt。
   4. 令 exprRef 爲解釋執行 Expression 的結果。
   5. 若是 ToBoolean(GetValue(exprRef)) 是 false，設定 iterating 爲 false。
4. 返回 (normal, V, empty);

while 語句

產生式 IterationStatement : while ( Expression ) Statement 按照下面的過程執行 :

1. 令 V = empty.
2. 重複
   1. 令 exprRef 爲解釋執行 Expression 的結果 .
   2. 若是 ToBoolean(GetValue(exprRef)) 是 false，返回 (normal, V, empty).
   3. 令 stmt 爲解釋執行 Statement 的結果 .
   4. 若是 stmt.value 不是 empty，令 V = stmt.value.
   5. 若是 stmt.type 不是 continue || stmt.target 不在當前標籤組內，則
      1. 若是 stmt.type 是 break 而且 stmt.target 在當前標籤組內，則
         1. 返回 (normal, V, empty).
      2. 若是 stmt 是一個很是規完結，返回 stmt.

for 語句

產生式 IterationStatement : for ( ExpressionNoIn_opt ; Expression_opt ; Expression_opt) Statement 按照下面的過程執行 :

1. 若是 ExpressionNoIn 是 present，則 .
   1. 令 exprRef 爲解釋執行 ExpressionNoIn 的結果 .
   2. 調用 GetValue(exprRef). ( 不會用到此值。)
2. 令 V = empty.
3. 重複
   1. 若是第一個 Expression 是 present，則
      1. 令 testExprRef 爲解釋執行第一個 Expression 的結果 .
      2. 若是 ToBoolean(GetValue(testExprRef)) 是 false，返回 (normal, V, empty).
   2. 令 stmt 爲解釋執行 Statement 的結果 .
   3. 若是 stmt.value 不是 empty，令 V = stmt.value
   4. 若是 stmt.type 是 break 而且 stmt.target 在當前標籤組內，返回 (normal, V, empty).
   5. 若是 stmt.type 不是 continue || stmt.target 不在當前標籤組內，則
      1. 若是 stmt 是個很是規完結，返回 stmt.
   6. 若是第二個 Expression 是 present，則
      1. 令 incExprRef 爲解釋執行第二個 Expression 的結果 .
      2. 調用 GetValue(incExprRef). ( 不會用到此值 .)

產生式 IterationStatement : for ( var VariableDeclarationListNoIn ; Expression_opt ; Expression_opt ) Statement 按照下面的過程執行 :

1. 解釋執行 VariableDeclarationListNoIn.
2. 令 V = empty.
3. 重複
   1. 若是第一個 Expression 是 present，則
      1. 令 testExprRef 爲解釋執行第一個 Expression 的結果 .
      2. 若是 ToBoolean(GetValue(testExprRef)) 是 false，則返回 (normal, V, empty).
   2. 令 stmt 爲解釋執行 Statement 的結果 .
   3. 若是 stmt.value 不是 empty，令 V = stmt.value.
   4. 若是 stmt.type 是 break 而且 stmt.target 在當前標籤組內，返回 (normal, V, empty).
   5. 若是 stmt.type 不是 continue || stmt.target 不在當前標籤組內，則
      1. 若是 stmt 是個很是規完結，返回 stmt.
   6. 若是第二個 Expression 是 present，則 .
      1. 令 incExprRef 爲解釋執行第二個 Expression 的結果 .
      2. 調用 GetValue(incExprRef). ( 不會用到此值 .)

for-in 語句

產生式 IterationStatement : for ( LeftHandSideExpression in Expression ) Statement 按照下面的過程執行 :

1. 令 exprRef 爲解釋執行 Expression 的結果 .
2. 令 experValue 爲 GetValue(exprRef).
3. 若是 experValue 是 null 或 undefined，返回 (normal, empty, empty).
4. 令 obj 爲 ToObject(experValue).
5. 令 V = empty.
6. 重複
   1. 令 P 爲 obj 的下一個 [[Enumerable]] 特性爲 true 的屬性的名。若是不存在這樣的屬性，返回 (normal, V, empty).
   2. 令 lhsRef 爲解釋執行 LeftHandSideExpression 的結果 ( 它可能解釋執行屢次 ).
   3. 調用 PutValue(lhsRef, P).
   4. 令 stmt 爲解釋執行 Statement 的結果 .
   5. 若是 stmt.value 不是 empty，令 V = stmt.value.
   6. 若是 stmt.type 是 break 而且 stmt.target 在當前標籤組內，返回 (normal, V, empty).
   7. 若是 stmt.type 不是 continue || stmt.target 不在當前標籤組內，則
      1. 若是 stmt 是很是規完結，返回 stmt.

產生式 IterationStatement : for ( var VariableDeclarationNoIn in Expression ) Statement 按照下面的過程執行 :

1. 令 varName 爲解釋執行 VariableDeclarationNoIn 的結果 .
2. 令 exprRef 爲解釋執行 Expression 的結果 .
3. 令 experValue 爲 GetValue(exprRef).
4. 若是 experValue 是 null 或 undefined，返回 (normal, empty, empty).
5. 令 obj 爲 ToObject(experValue).
6. 令 V = empty.
7. 重複
   1. 令 P 爲 obj 的下一個 [[Enumerable]] 特性爲 true 的屬性的名。若是不存在這樣的屬性，返回 (normal, V, empty).
   2. 令 varRef 爲解釋執行 varName 的結果，彷彿它是個標示符引用 (11.1.2); 它可能解釋執行屢次 .
   3. 調用 PutValue(varRef, P).
   4. 令 stmt 爲解釋執行 Statement 的結果 .
   5. 若是 stmt.value 不是 empty，令 V = stmt.value.
   6. 若是 stmt.type 是 break 而且 stmt.target 在當前標籤組內，返回 (normal, V, empty).
   7. 若是 stmt.type 不是 continue || stmt.target 不在當前標籤組內，則
      1. 若是 stmt 是很是規完結，返回 stmt.

枚舉的屬性 ( 第一個算法中的步驟 6.a，第二個算法中的步驟 7.a) 的機制和順序並無指定。在枚舉過程當中枚舉的對象屬性可能被刪除。若是在枚舉過程當中，刪除了尚未被訪問到的屬性，那麼它將不會被訪問到。若是在枚舉過程當中添加新屬性到列舉的對象，新增長的屬性也沒法保證被當前執行中的枚舉訪問到。在任何枚舉中對同一個屬性名稱的訪問不得超過一次。

枚舉一個對象的屬性包括枚舉其原型的屬性，還有原型的原型，等等，遞歸；可是若是原型的一個屬性是「陰影裏的」那麼不會枚舉這個屬性，由於原型鏈中以前某個對象有同名的屬性了。當一個原型對象的一個屬性是在原型鏈中以前對象的陰影裏的，那麼在決定是否枚舉時不須要考慮 [[Enumerable]] 特性的值。

見 注11.13.1。

continue 語句

語法：

ContinueStatement : continue ; continue [ 此處無換行 ] Identifier ;

語義：

若是如下任意一個爲真，那麼程序被認爲是語法錯誤的：

• 程序包含一個不帶可選的 Identifier 的 continue 語句，沒有直接或間接 ( 不跨越函數邊界 ) 的嵌套在 IterationStatement 裏。
• 程序包含一個有可選的 Identifier 的 continue 語句，這個 Identifier 沒有出如今 IterationStatement 中閉合標籤組裏 ( 不跨越函數邊界 )。

一個沒有 Identifier 的 ContinueStatement 按照下面的過程執行 :

1. 返回 (continue, empty, empty).

一個有可選的 Identifier 的 ContinueStatement 按照下面的過程執行 :

1. 返回 (continue, empty, Identifier).

break 語句

語法：

BreakStatement : break ; break [ 此處無換行 ] Identifier ;

語義：

若是如下任意一個爲真，那麼程序被認爲是語法錯誤的：

• 程序包含一個不帶可選的 Identifier 的 break 語句，沒有直接或間接 ( 不跨越函數邊界 ) 的嵌套在 IterationStatement 或 SwitchStatement 裏。
• 程序包含一個有可選的 Identifier 的 break 語句，這個 Identifier 沒有出如今 Statement 中閉合標籤組裏 ( 不跨越函數邊界 )。

一個沒有 Identifier 的 BreakStatement 按照下面的過程執行 :

1. 返回 (continue, empty, empty).

一個有可選的 Identifier 的 BreakStatement 按照下面的過程執行 :

1. 返回 (continue, empty, Identifier).

return 語句

語法：

ReturnStatement : return ; return [ 此處無換行 ] Expression ;

語義：

在一個 ECMAScript 程序中包含的 return 語句沒有在 FunctionBody 裏面，那麼就是語法錯誤的。一個 return 語句致使函數中止執行，並返回一個值給調用者。若是省略Expression，返回值是 undefined。不然，返回值是 Expression 的值。

產生式 ReturnStatement :' return' [no LineTerminator here] Expression_opt ; 按照下面的過程執行 :

1. 若是 Expression 不是 present，返回 (return, undefined, empty).
2. 令 exprRef 爲解釋執行 Expression 的結果 .
3. 返回 (return, GetValue(exprRef), empty).

with 語句

語法：

WithStatement : with ( Expression ) Statement

with 語句爲計算對象給當前執行環境的 詞法環境 添加一個對象 環境記錄項 。而後，用這個加強的 詞法環境 執行一個語句。最後，恢復到原來的 詞法環境 。

語義 :

產生式 WithStatement : with ( Expression ) Statement 按照下面的過程執行 :

1. 令 val 爲解釋執行 Expression 的結果 .
2. 令 obj 爲 ToObject(GetValue(val)).
3. 令 oldEnv 爲運行中的執行環境的 LexicalEnvironment.
4. 令 newEnv 爲以 obj 和 oldEnv 爲參數調用 NewObjectEnvironment 的結果。
5. 設定 newEnv 的 provideThis 標誌爲 true。
6. 設定運行中的執行環境的 LexicalEnvironment 爲 newEnv.
7. 令 C 爲解釋執行 Statement 的結果，但若是解釋執行是由異常拋出，則令 C 爲 (throw, V, empty)，這裏的 V 是異常。( 如今繼續執行，彷彿沒有拋出異常。)
8. 設定運行中的執行環境的 LexicalEnvironment 爲 oldEnv.
9. 返回 C.

不管控制是從嵌入的 Statement 怎樣離開的，不管是正常離開仍是以 很是規完結 或異常，LexicalEnvironment 老是恢復到它以前的狀態。

嚴格模式的限制

嚴格模式代碼中不能包含 WithStatement。出現 WithStatement 的上下文被看成一個 SyntaxError。

switch 語句

語法：

SwitchStatement : switch ( Expression ) CaseBlockCaseBlock : { CaseClausesopt } { CaseClausesoptDefaultClause CaseClausesopt }CaseClauses : CaseClause CaseClauses CaseClauseCaseClause : case Expression : StatementListoptDefaultClause : default : StatementListopt

語義：

產生式 SwitchStatement : switch ( Expression ) CaseBlock 按照下面的過程執行 :

1. 令 exprRef 爲解釋執行 Expression 的結果 .
2. 令 R 爲以 GetValue(exprRef) 做爲參數解釋執行 CaseBlock 的結果。
3. 若是 R.type 是 break 而且 R.target 在當前標籤組內，返回 (normal, R.value, empty).
4. 返回 R.

產生式 CaseBlock : { CaseClauses_opt } 以一個給定輸入參數 input, 按照下面的過程執行 :

1. 令 V = empty.
2. 令 A 爲以源代碼中順序排列的 CaseClause 列表。
3. 令 searching 爲 true.
4. 只要 searching 爲 true，就重複
   1. 令 C 爲 A 裏的下一個 CaseClause。 若是沒有 CaseClause 了，返回 (normal, V, empty).
   2. 令 clauseSelector 爲解釋執行 C 的結果 .
   3. 若是 input 和 clauseSelector 是 === 操做符定義的相等，則
      1. 設定 searching 爲 false.
      2. 若是 C 有一個 StatementList, 則
         1. 令 R 爲解釋執行 C 的 StatementList 的結果。
         2. 若是 R 是個很是規完結 , 則返回 R。
         3. 令 V =R.value
5. 重複
   1. 令 C 爲 A 裏的下一個 CaseClause。 若是沒有 CaseClause 了，返回 (normal, V, empty).
   2. 若是 C 有一個 StatementList, 則
      1. 令 R 爲解釋執行 C 的 StatementList 的結果。
      2. 若是 R.value 不是 empty, 則令 V =R.value.
      3. 若是 R 是個很是規完結 , 則返回 (R.type,V,R.target).

產生式 CaseBlock : { CaseClauses_optDefaultClause CaseClauses_opt } 以一個給定輸入參數 input, 按照下面的過程執行 :

1. 令 V = empty.
2. 令 A 爲第一個 CaseClauses 中以源代碼中順序排列的 CaseClause 列表。
3. 令 B 爲第二個 CaseClauses 中以源代碼中順序排列的 CaseClause 列表。
4. 令 found 爲 false.
5. 重複，使 C 爲 A 中的依次每一個 CaseClause。
   1. 若是 found 是 false，則
      1. 令 clauseSelector 爲解釋執行 C 的結果 .
      2. 若是 input 和 clauseSelector 是 === 操做符定義的相等，則設定 found 爲 true.
   2. 若是 found 是 true，則
      1. 若是 C 有一個 StatementList，則
         1. 令 R 爲解釋執行 C 的 StatementList 的結果。
         2. 若是 R.value 不是 empty, 則令 V =R.value.
         3. R 是個很是規完結 , 則返回 (R.type,V,R.target).
6. 令 foundInB 爲 false.
7. 若是 found 是 false，則
   1. 只要 foundInB 爲 false 而且全部 B 中的元素都沒有被處理，就重複
      1. 令 C 爲 B 裏的下一個 CaseClause.
      2. 令 clauseSelector 爲解釋執行 C 的結果 .
      3. 若是 input 和 clauseSelector 是 === 操做符定義的相等，則
         1. 設定 foundInB 爲 true.
         2. 若是 C 有一個 StatementList, 則
            1. 令 R 爲解釋執行 C 的 StatementList 的結果。
            2. 若是 R.value 不是 empty, 則令 V =R.value.
            3. R 是個很是規完結 , 則返回 (R.type,V,R.target).
8. 若是 foundInB 是 false 而且 DefaultClause 有個 StatementList, 則
   1. 令 R 爲解釋執行 DefaultClause 的 StatementList 的結果 .
   2. 若是 R.value 不是 empty, 則令 V = R.value.
   3. 若是 R 是個很是規完結 , 則返回 (R.type, V, R.target).
9. 重複 ( 注 : 若是已執行步驟 7.a.i, 此循環不從 B 的開頭開始。)
   1. 令 C 爲 B 的下一個 CaseClause。若是沒有 CaseClause 了 , 返回 (normal, V, empty).
   2. 若是 C 有個 StatementList, 則
      1. 令 R 爲解釋執行 C 的 StatementList 的結果。
      2. 若是 R.value 不是 empty, 則令 V = R.value.
      3. 若是 R 是個很是規完結 , 則返回 (R.type, V, R.target).

產生式 CaseClause : case Expression : StatementList_opt 按照下面的過程執行 :

1. 令 exprRef 爲解釋執行 Expression 的結果 .
2. 返回 GetValue(exprRef).

解釋執行 CaseClause 不會運行相關的 StatementList。它只簡單的解釋執行 Expression 並返回值，這裏的 CaseBlock 算法用於肯定 StatementList 開始執行。

標籤語句

語法：

LabelledStatement : Identifier : Statement

語義：

一個 Statement 能夠由一個標籤做爲前綴。標籤語句僅與標籤化的 break 和 continue 語句一塊兒使用。ECMAScript 沒有 goto 語句。

若是一個 ECMAScript 程序包含有相同 Identifier 做爲標籤的 LabelledStatement 閉合的 LabelledStatement，那麼認爲它是是語法錯誤的 。這不適用於直接或間接嵌套在標籤語句裏面的 FunctionDeclaration 的 body 裏出現標籤的狀況。

產生式 Identifier : Statement 的解釋執行方式是，先添加 Identifier 到 Statement 的標籤組，再解釋執行 Statement。若是 LabelledStatement 自身有一個非空標籤組，這些標籤仍是會添加到解釋執行前的 Statement 的標籤組裏。若是 Statement 的解釋執行結果是 (break, V, L)，這裏的 L 等於 Identifier，則產生式的結果是 (normal, V, empty)。

在解釋執行 LabelledStatement 以前，認爲包含的 Statement 擁有一個空標籤組，除非它是 IterationStatement 或 SwitchStatement，這種狀況下認爲它擁有一個包含單個元素 empty 的標籤組。

throw 語句

語法：

ThrowStatement : throw [no LineTerminator here] Expression ;

語義：

產生式 ThrowStatement : throw [no LineTerminator here] Expression ; 按照下面的過程執行 :

1. 令 exprRef 爲解釋執行 Expression 的結果 .
2. 返回 (throw, GetValue(exprRef), empty).

try 語句

語法：

TryStatement : try Block Catch try Block Finally try Block Catch FinallyCatch : catch ( Identifier ) BlockFinally : finally Block

try 語句包裹一個能夠出現特殊情況，若是運行時錯誤或 throw 語句的代碼塊。catch 子句提供了異常處理代碼。若是 catch 子句捕獲到一個異常，這個異常會綁定到它的 Identifier 上。

語義：

產生式 TryStatement : try Block Catch 按照下面的過程執行 :

1. 令 B 爲解釋執行 Block 的結果 .
2. 若是 B.type 不是 throw，返回 B.
3. 返回一參數 B 解釋執行 Catch 的結果 .

產生式 TryStatement : try Block Finally 按照下面的過程執行 :

1. 令 B 爲解釋執行 Block 的結果 .
2. 令 F 爲解釋執行 Finally 的結果 .
3. 若是 F.type 是 normal，返回 B.
4. 返回 F.

產生式 TryStatement : try Block Catch Finally 按照下面的過程執行 :

1. 令 B 爲解釋執行 Block 的結果 .
2. 若是 B.type 是 throw，則
   1. 令 C 爲以參數 B 解釋執行 Catch 的結果 .
3. 不然 , B.type 不是 throw,
   1. 令 C 爲 B.
4. 令 F 爲解釋執行 Finally 的結果 .
5. 若是 F.type 是 normal，返回 C.
6. 返回 F.

產生式 Catch : catch ( Identifier ) Block 按照下面的過程執行 :

1. 令 C 爲傳給這個產生式的參數 .
2. 令 oldEnv 爲運行中執行環境的 LexicalEnvironment.
3. 令 catchEnv 爲以 oldEnv 爲參數調用 NewDeclarativeEnvironment 的結果
4. 以 Identifier 字符串值爲參數調用 catchEnv 的 CreateMutableBinding 具體方法。
5. 以 Identifier, C, false 爲參數調用 catchEnv 的 SetMutableBinding 具體方法。注：這種狀況下最後一個參數可有可無。
6. 設定運行中執行環境的 LexicalEnvironment 爲 catchEnv.
7. 令 B 爲解釋執行 Block 的結果 .
8. 設定運行中執行環境的 LexicalEnvironment 爲 oldEnv.
9. 返回 B.

無論控制是怎樣退出 Block 的，LexicalEnvironment 老是會恢復到其以前的狀態。

產生式 Finally : finally Block 按照下面的過程執行 :

1. 返回解釋執行 Block 的結果 .

嚴格模式的限制

若是一個有 Catch 的 TryStatement 出如今 嚴格模式代碼 裏，而且 Catch 產生式的 Identifier 是 "eval" 或 "arguments"，那麼這是個 SyntaxError

debugger 語句

語法：

DebuggerStatement : debugger ;

語義：

解釋執行 DebuggerStatement 產生式可容許讓一個實如今調試器下運行時設置斷點。若是調試器不存在或是非激活狀態，這個語句沒有可觀測效果。

產生式 DebuggerStatement : debugger ; 按照下面的過程執行 :

1. 若是一個實現定義了可用的調試工具而且是開啓的，則
   1. 執行實現定義的調試動做。
   2. 令 result 爲實現定義的 Completion 值 .
2. 不然
   1. 令 result 爲 (normal, empty, empty).
3. 返回 result.

函數定義

語法

FunctionDeclaration : function Identifier ( FormalParameterListopt ) { FunctionBody }FunctionExpression : function Identifieropt ( FormalParameterListopt ) { FunctionBody }FormalParameterList : Identifier FormalParameterList , IdentifierFunctionBody : SourceElementsopt

語義

產生式 FunctionDeclaration : function Identifier ( FormalParameterList_opt ) { FunctionBody } 依照定義綁定初始化 (10.5) 以下初始化：

1. 依照 13.2，指定 FormalParameterList_opt 爲參數，指定 FunctionBody 爲 body，建立一個新函數對象，返回結果。運行中的執行環境的 VariableEnvironment 傳遞爲 Scope。若是 FunctionDeclaration 包含在 嚴格模式代碼 裏或 FunctionBody 是 嚴格模式代碼 ，那麼傳遞 true 爲 Strict 標誌。

產生式 FunctionExpression : function ( FormalParameterList_opt ) { FunctionBody } 的解釋執行以下：

1. 依照 13.2，指定 FormalParameterList_opt 爲參數，指定 FunctionBody 爲 body，建立一個新函數對象，返回結果。運行中的執行環境的 LexicalEnvironment 傳遞爲 Scope。若是 FunctionExpression 包含在 嚴格模式代碼 裏或 FunctionBody 是 嚴格模式代碼 ，那麼傳遞 true 爲 Strict 標誌。

產生式 FunctionExpression : function Identifier_opt ( FormalParameterList_opt ) { FunctionBody } 的解釋執行以下：

1. 令 funcEnv 爲以運行中執行環境的 Lexical Environment 爲參數調用 NewDeclarativeEnvironment 的結果。
2. 令 envRec 爲 funcEnv 的環境記錄項。
3. 以 Identifier 的字符串值爲參數調用 envRec 的具體方法 CreateImmutableBinding(N)。
4. 令 closure 爲依照 13.2，指定 FormalParameterList_opt 爲參數，指定 FunctionBody 爲 body，建立一個新函數對象的結果。傳遞 funcEnv 爲 Scope。若是 FunctionExpression 包含在嚴格模式代碼 裏或 FunctionBody 是 嚴格模式代碼 ，那麼傳遞 true 爲 Strict 標誌。
5. 以 Identifier 的字符串值和 closure 爲參數調用 envRec 的具體方法 InitializeImmutableBinding(N,V)。
6. 返回 closure。

能夠從 FunctionExpression 的 FunctionBody 裏面引用 FunctionExpression 的 Identifier，以容許函數遞歸調用自身。然而不像 FunctionDeclaration，FunctionExpression 的 Identifier 不能被範圍封閉的 FunctionExpression 引用，也不會影響它。

產生式 FunctionBody : SourceElements_opt 的解釋執行以下：

1. 若是這個 FunctionBody 所在 FunctionDeclaration 或 FunctionExpression 包含在嚴格模式代碼內，或其 SourceElements 的指令序言 (14.1) 包含一個 use strict 指令，或知足 10.1 的任何條件，那麼其代碼是嚴格模式代碼。若是 FunctionBody 的代碼是嚴格模式代碼，SourceElements 的解釋執行爲如下的嚴格模式代碼步驟。不然，SourceElements 的解釋執行爲如下的非嚴格模式步驟。
2. 若是 SourceElements 是當前的，則返回 SourceElements 的解釋執行結果。
3. 不然返回 (normal, undefined, empty)。

嚴格的模式的限制

若是嚴格模式 FunctionDeclaration 或 FunctionExpression 的 FormalParameterList 裏出現多個相同 Identifier 值，那麼這是個 SyntaxError。

若是嚴格模式 FunctionDeclaration 或 FunctionExpression 的 FormalParameterList 裏出現標識符 "eval" 或標識符 "arguments"，那麼這是個 SyntaxError。

若是嚴格模式 FunctionDeclaration 或 FunctionExpression 的 Identifier 是標識符 "eval" 或標識符 "arguments"，那麼這是個 SyntaxError。

建立函數對象

指定 FormalParameterList 爲可選參數列表，指定 FunctionBody 爲函數體，指定 Scope 爲 詞法環境 ，Strict 爲布爾標記，按照以下步驟構建函數對象：

1. 建立一個新的 ECMAScript 原生對象，令 F 爲此對象。
2. 依照 8.12 描述設定 F 的除 [[Get]] 之外的全部內部方法。
3. 設定 F 的 [[Class]] 內部屬性爲 "Function"。
4. 設定 F 的 [[Prototype]] 內部屬性爲 15.3.3.1 指定的標準內置 Function 對象的 prototype 屬性。
5. 依照 15.3.5.4 描述，設定 F 的 [[Get]] 內部屬性。
6. 依照 13.2.1 描述，設定 F 的 [[Call]] 內部屬性。
7. 依照 13.2.2 描述，設定 F 的 [[Construct]] 內部屬性。
8. 依照 15.3.5.3 描述，設定 F 的 [[HasInstance]] 內部屬性。
9. 設定 F 的 [[Scope]] 內部屬性爲 Scope 的值。
10. 令 names 爲一個列表容器，其中元素是以從左到右的文本順序對應 FormalParameterList 的標識符的字符串。
11. 設定 F 的 [[FormalParameters]] 內部屬性爲 names。
12. 設定 F 的 [[Code]] 內部屬性爲 FunctionBody。
13. 設定 F 的 [[Extensible]] 內部屬性爲 true。
14. 令 len 爲 FormalParameterList 指定的形式參數的個數。若是沒有指定參數，則令 len 爲 0。
15. 以參數 "length"，屬性描述符 {[[Value]]: len, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false}，false 調用 F 的 [[DefineOwnProperty]] 內部方法。
16. 令 proto 爲彷彿使用 new Object() 表達式建立新對象的結果，其中 Object 是標準內置構造器名。
17. 以參數 "constructor", 屬性描述符 {[[Value]]: F, { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}, false 調用 proto 的 [[DefineOwnProperty]] 內部方法。
18. 以參數 "prototype", 屬性描述符 {[[Value]]: proto, { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}, false 調用 F 的 [[DefineOwnProperty]] 內部方法。
19. 若是 Strict 是 true，則
    1. 令 thrower 爲 [[ThrowTypeError]] 函數對象 (13.2.3)。
    2. 以參數 "caller", 屬性描述符 {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, false 調用 F 的 [[DefineOwnProperty]] 內部方法。
    3. 以參數 "caller", 屬性描述符 {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, false 調用 F 的 [[DefineOwnProperty]] 內部方法。
20. 返回 F。

每一個函數都會自動建立一個 prototype 屬性，以知足函數會被看成構造器的可能性。

[[call]]

當用一個 this 值，一個參數列表調用函數對象 F 的 [[Call]] 內部方法，採用如下步驟：

1. 用 F 的 [[FormalParameters]] 內部屬性值，參數列表 args，10.4.3 描述的 this 值來創建 函數代碼 的一個新執行環境，令 funcCtx 爲其結果。
2. 令 result 爲 FunctionBody（也就是 F 的 [[Code]] 內部屬性）解釋執行的結果。若是 F 沒有 [[Code]] 內部屬性或其值是空的 FunctionBody，則 result 是 (normal, undefined, empty)。
3. 退出 funcCtx 執行環境，恢復到以前的執行環境。
4. 若是 result.type 是 throw 則拋出 result.value。
5. 若是 result.type 是 return 則返回 result.value。
6. 不然 result.type 一定是 normal。返回 undefined。

[[Construct]]

當以一個可能的空的參數列表調用函數對象 F 的 [[Construct]] 內部方法，採用如下步驟：

1. 令 obj 爲新建立的 ECMAScript 原生對象。
2. 依照 8.12 設定 obj 的全部內部方法。
3. 設定 obj 的 [[Class]] 內部方法爲 "Object"。
4. 設定 obj 的 [[Extensible]] 內部方法爲 true。
5. 令 proto 爲以參數 "prototype" 調用 F 的 [[Get]] 內部屬性的值。
6. 若是 Type(proto) 是 Object，設定 obj 的 [[Prototype]] 內部屬性爲 proto。
7. 若是 Type(proto) 不是 Object，設定 obj 的 [[Prototype]] 內部屬性爲 15.2.4 描述的標準內置的 Object 的 prototype 對象。
8. 以 obj 爲 this 值，調用 [[Construct]] 的參數列表爲 args，調用 F 的 [[Call]] 內部屬性，令 result 爲調用結果。
9. 若是 Type(result) 是 Object，則返回 result。
10. 返回 obj

[[ThrowTypeError]] 函數對象

[[ThrowTypeError]] 對象是個惟一的函數對象，以下只定義一次：

1. 建立一個新 ECMAScript 原生對象，令 F 爲此對象。
2. 依照 8.12 設定 F 的全部內部屬性。
3. 設定 F 的 [[Class]] 內部屬性爲 "Function"。
4. 設定 F 的 [[Prototype]] 內部屬性爲 15.3.3.1 指定的標準內置 Function 的 prototype 對象。
5. 依照 13.2.1 描述設定 F 的 [[Call]] 內部屬性。
6. 設定 F 的 [[Scope]] 內部屬性爲 全局環境 。
7. 設定 F 的 [[FormalParameters]] 內部屬性爲一個空 列表 。
8. 設定 F 的 [[Code]] 內部屬性爲一個 FunctionBody，它無條件拋出一個 TypeError 異常，不作其餘事情。
9. 以參數 "length", 屬性描述符 {[[Value]]: 0, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false}, false 調用 F 的 [[DefineOwnProperty]] 內部方法。
10. 設定 F 的 [[Extensible]] 內部屬性爲 false。
11. 令 [[ThrowTypeError]] 爲 F。

程序

語法：

Program : SourceElementsoptSourceElements : SourceElement SourceElements SourceElementSourceElement : Statement FunctionDeclaration

語義：

產生式 Program : SourceElements_opt 依照下面的步驟來解釋執行 :

1. 若 SourceElements 的指令序言 ( 參考 14.1 章 ) 中 , 包含嚴格模式指令 , 或者知足 10.1.1 章節所描述的任何一個條件 . 則 Program 的代碼 . 就是一段嚴格模式代碼 . 並對應性的 , 以嚴格模式或非嚴格模式 , 依照下面列出的步驟來解釋執行代碼 .
2. 若沒有 SourceElements 部分 , 則返回 (normal, empty, empty).
3. 令 progCxt 爲一個新的 , 如 10.4.1 章節所描述的 , 應用於全局代碼的執行環境 .
4. 令 result 爲解釋執行 SourceElements 的結果 .
5. 退出 progCxt 這個執行環境 .
6. 返回 result.

本規範不會規定 , 具體如何解釋執行一個 Program 以及如何處理其結果 . 其具體行爲由 ECMAScript 實現 , 自行定義

產生式 SourceElements : SourceElements SourceElement 依照下面的步驟來解釋執行 :

1. 令 headResult 爲解釋執行 SourceElements 的結果 .
2. 若 headResult 是很是規性完結的 , 返回 headResult.
3. 令 tailResult 爲解釋執行 SourceElement 的結果 .
4. 若 tailResult.value 爲 empty, 令 V = headResult.value, 其餘狀況 , 另 V = tailResult.value.
5. 返回 (tailResult.type, V, tailResult.target).

產生式 : SourceElement : Statement 依照下面的步驟來解釋執行 :

1. 返回解釋執行 Statement 的結果 .

產生式 : SourceElement : FunctionDeclaration 依照下面的步驟來解釋執行 :

1. 返回 (normal, empty, empty)

指令序言和嚴格模式指令 .

一個指令序言 , 是那些從 Program 或 FunctionBody 的首個 SourceElement 開始，到那些徹底由一個字符串字面量後面跟一個分號 , 所構成的最長的 . 那一組 ExpressionStatement 序列中的每個 . 字符串字面量後面的分號 , 能夠顯式的插入 , 或者藉助分號自動插入機制來插入 . 一個指令序言 , 也能夠是一個空的序列 .

嚴格模式指令是一個 "use strict" 或 'use strict' 的字符串字面量 . 一個嚴格模式指令中 , 不該該包含 EscapeSequence 或 LineContinuation.

一個指令序言 , 能夠不只僅包含一個嚴格模式指令 . 然而 , 當這種狀況出現的時候 ,ECMAScript 實現 , 能夠發出一個相關警告 .

指令序言包含的 ExpressionStatement 產生式們，會在解釋執行包含他們的 SourceElements 產生式期間 , 被正常的解析執行 . ECMAScript 實現 , 能夠在一個指令序言中定義其餘非嚴格模式指令 . 當一個指令序言中的某個 ExpressionStatement 並非一個嚴格模式指令，也不是一個被 ECMAScript 實現所定義的指令 . 且存在某種通知機制的話 . 就要藉助該機制 , 發出一個警告 .

標準 ECMAScript 內置對象

ECMAScript 代碼運行時會有一些可用的內置對象。一是做爲執行程序詞法環境的一部分的全局對象。其餘的可經過全局對象的初始屬性訪問。

除非另外指明，若是內置對象擁有 [[Call]] 內部屬性，那麼它的 [[Class]] 內部屬性是 "Function"，若是沒有 [[Call]] 內部屬性，那麼它的 [[Class]] 內部屬性是 "Object"。除非另外指明，內置對象的 [[Extensible]] 內部屬性的初始值是 true。

許多內置對象是函數：它們能夠經過參數調用。其中有些還做爲構造器：這些函數可被 new 運算符調用。對於每一個內置函數，本規範描述了這些函數的必須參數和 Function 對象的屬性。對於每一個內置構造器，本規範還描述了這些構造器的 prototype 對象的屬性，還描述了用 new 表達式調用這個構造器後返回的具體實例對象的屬性。

除非另外指明瞭某一特定函數的描述，若是在調用本章中描述的函數或構造器時傳入的參數少於必須的參數個數，那麼這些函數或構造器將表現爲彷彿傳入了足夠的參數，而那些缺乏的參數會設定爲 undefined 值。

除非另外指明瞭某一特定函數的描述，若是在調用本章中描述的函數或構造器時傳入了比函數指定容許的更多的參數時，額外的參數會被函數忽略。然而，一個實現能夠爲這樣的參數列表定義依賴於實現的特別行爲，只要這種行爲在單純添加額外參數時不拋出 TypeError 異常。

實現爲了給內置函數集合增添一些額外功能而添加新函數是被鼓勵的，而不是爲現有函數增長新參數。

每一個內置函數和每一個內置構造器都有 Function 原型對象 ，Function.prototype（15.3.4）表達式的初始值做爲其 [[Prototype]] 內部屬性的值。

除非另外指明，每一個內置的原型對象都有 Object 原型對象 ，Object.prototype(15.2.4) 表達式的初始值做爲其 [[Prototype]] 內部屬性的值，除了 Object 的原型對象自身。

除非另外指明瞭特定函數的描述，不然本章描述的內置函數中不存在不是構造器而要實現 [[Construct]] 內部方法的內置函數。除非另外指明瞭特定函數的描述，不然本章描述的內置函數都沒有 prototype 屬性。

本章一般描述構造器的「做爲函數調用」和「用 new 表達式調用」 有不一樣行爲。" 做爲函數調用 " 的行爲對應於調用構造器的 [[Call]] 內部方法，「用 new 表達式調用」的行爲對應於調用構造器的 [[Construct]] 內部方法。

本章描述的每一個內置 Function 對象 -- 無論是構造器仍是普通函數，或兩者都是 -- 擁有一個 length 屬性，其值是個整數。除非另外指明，此值等於顯示在函數描述的子章節標題的形式參數的個數，包括可選參數。

例如描述 String 的 prototype 對象的 slice 屬性初始值的函數對象的子章節標題是「String.prototype.slice (start, end)」，這說明有兩個形參 start 和 end，因此這個函數對象的 length 屬性值是 2。

任何狀況下，本章描述的內置函數對象的 length 屬性擁有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。除非另外指明，本章描述的全部其餘屬性擁有特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }。

全局對象

惟一的全局對象創建在控制進入任何執行環境以前。

除非另外指明，全局對象的標準內置屬性擁有特性 {[[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}。

全局對象沒有 [[Construct]] 內部屬性 ; 全局對象不可能當作構造器用 new 運算符調用。

全局對象沒有 [[Call]] 內部屬性，全局對象不可能當作函數來調用。

全局對象的 [[Prototype]] 和 [[Class]] 內部屬性值是依賴於實現的。

除了本規範定義的屬性以外，全局對象還能夠擁有額外的宿主定義的屬性。全局對象可包含一個值是全局對象自身的屬性；例如，在 HTML 文檔對象模型中全局對象的 window 屬性是全局對象自身。

全局對象的值屬性

NaN

NaN 的值是 NaN（見 8.5）。這個屬性擁有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Infinity

Infinity 的值是 +∞（見 8.5）。這個屬性擁有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

undefined

undefined 的值是 undefined（見 8.1）。這個屬性擁有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

全局對象的函數屬性

eval (x)

當用一個參數 x 調用 eval 函數，採用以下步驟：

1. 若是 Type(x) 不是 String, 返回 x.
2. 令 prog 爲 ECMAScript 代碼，它是將 x 做爲一個程序解析的結果。若是解析失敗，拋出一個 SyntaxError 異常 ( 見 16 章 )。
3. 令 evalCtx 爲給 eval 代碼 prog 創建的新執行環境 (10.4.2)。
4. 令 result 爲解釋執行程序 prog 的結果。
5. 退出執行環境 evalCtx, 恢復到以前的執行環境。
6. 若是 result.type 是 normal 而且其完結類型值是 V, 則返回 V 值 .
7. 若是 result.type 是 normal 而且其完結類型值是 empty, 則返回 undefined 值 .
8. 不然，result.type 一定是 throw。將 result.value 做爲異常拋出 .

直接調用 Eval

一個 eval 函數的直接調用是表示爲符合如下兩個條件的 CallExpression：

解釋執行 CallExpression 中的 MemberExpression 的結果是個 引用 ，這個引用擁有一個 環境記錄項 做爲其基值，而且這個引用的名稱是 "eval"。

以這個 引用 做爲參數調用 GetValue 抽象操做的結果是 15.1.2.1 定義的標準內置函數。

parseInt (string , radix)

parseInt 函數根據指定的參數 radix，和 string 參數的內容解釋結果來決定，產生一個整數值。string 開頭的空白會被忽略。若是 radis 是 undefined 或 0，假定它是 10，除非數字是以字符對 0x 或 0X 開頭的，這時假定 radix 是 16。若是 radix 是 16，數字開頭的字符對 0x 或 0X 是可選的。

當調用 parseInt 函數時，採用如下步驟：

1. 令 inputString 爲 ToString(string)。
2. 令 S 爲一個新建立的子字符串，它由 inputString 的第一個非 StrWhiteSpaceChar 字符和它後面跟着的全部字符組成。( 換句話說 , 刪掉前面的空白。) 若是 inputString 不包含任何這樣的字符 , 則令 S 爲空字符串。
3. 令 sign 爲 1。
4. 若是 S 不是空而且 S 的第一個字符是減號 -, 則令 sign 爲−1。
5. 若是 S 不是空而且 S 的第一個字符加號 + 或減號 -, 則刪除 S 的第一個字符。
6. 令 R = ToInt32(radix).
7. 令 stripPrefix 爲 true.
8. 若是 R ≠ 0, 則
   1. 若是 R < 2 或 R > 36, 則返回 NaN。
   2. 若是 R ≠ 16, 令 stripPrefix 爲 false.
9. 不然 , R = 0
   1. 令 R = 10.
10. 若是 stripPrefix 是 true, 則
    1. 若是 S 長度大於 2 而且 S 的頭兩個字符是「0x」或「0X」, 則刪除 S 的頭兩個字符而且令 R = 16.
11. 若是 S 包含任何不是 radix-R 進制的字符，則令 Z 爲 S 的這樣的字符以前的全部字符組成的子字符串；不然令 Z 爲 S。.
12. 若是 Z 是空 , 返回 NaN.
13. 令 mathInt 爲 Z 的 radix-R 進製表示的數學值，用字母 A-Z 和 a-z 來表示 10 到 35 之間的值。( 可是 , 若是 R 是 10 而且 Z 包含多餘 20 位的值 , 能夠替換 20 位後的每一個數字爲 0, 這是實現可選的功能 ; 若是 R 不是 2, 4, 8, 10, 16, 32, 則 mathInt 能夠是 Z 的 radix-R 進製表示的依賴於實現的近似值。)
14. 令 number 爲 mathInt 的數值 .
15. 返回 sign × number.

parseInt 能夠只把 string 的開頭部分解釋爲整數值；它會忽略全部不能解釋爲整數記法的一部分的字符，而且沒有指示會給出任何這些忽略的字符。

parseFloat (string)

parseFloat 函數根據 string 參數的內容解釋爲十進制字面量的結果來決定，產生一個數值。

當調用 parseFloat 函數，採用如下步驟：

1. 令 inputString 爲 ToString(string).
2. 令 trimmedString 爲一個新建立的子字符串，它由 inputString 的非 StrWhiteSpaceChar 字符的最左邊字符和它右邊跟着的全部字符組成。( 換句話說 , 刪掉前面的空白。) 若是 inputString 不包含任何這樣的字符 , 則令 trimmedString 爲空字符串。
3. 若是 trimmedString 或 trimmedString 的任何前綴都不知足 StrDecimalLiteral ( 見 9.3.1) 的語法 , 返回 NaN。
4. 令 numberString 爲知足 StrDecimalLiteral 語法的 trimmedString 的最長前綴，多是 numberString 自身。
5. 返回 numberString 的 MV 的數值。

parseFloat 能夠只把 string 的開頭部分解釋爲數值；它會忽略全部不能解釋爲數值字面量記法的一部分的字符，而且沒有指示會給出任何這些忽略的字符。

isNaN (number)

若是指定參數爲 NaN，則返回 true，不然返回 false。

1. 若是 ToNumber(number) 是 NaN, 返回 true.
2. 不然 , 返回 false.

一個用 ECMAScript 代碼來測試值 X 是不是 NaN 的方式是用 X !== X 表達式。當且僅當 X 是 NaN 時結果纔是 true。

isFinite (number)

若是指定參數爲 NaN 或 +∞或−∞，則返回 false，不然返回 true。

1. 若是 ToNumber(number) 是 NaN 或 +∞或−∞, 返回 false.
2. 不然 , 返回 true.

處理 URI 的函數屬性

統一資源標識符，或叫作 URI，是用來標識互聯網上的資源（例如，網頁或文件）和怎樣訪問這些資源的傳輸協議（例如，HTTP 或 FTP）的字符串。除了 15.1.3.1, 15.1.3.2, 15.1.3.3，15.1.3.4 說明的用來編碼和解碼 URI 的函數以外 ECMAScript 語言自身不提供任何使用 URL 的支持。

許多 ECMAScript 實現提供額外的函數，方法來操做網頁；這些函數超出了本標準的範圍。

一個 URI 是由組件分隔符分割的組件序列組成。其通常形式是：

Scheme : First / Second ; Third ? Fourth

其中斜體的名字表明組件；「:」, 「/」, 「;」，「?」是看成分隔符的保留字符。encodeURI 和 decodeURI 函數操做的是完整的 URI；這倆函數假定 URI 中的任何保留字符都有特殊意義，全部不會編碼它們。encodeURIComponent 和 decodeURIComponent 函數操做的是組成 URI 的個別組件；這倆函數假定任何保留字符都表明普通文本，因此必須編碼它們，因此它們出如今組成一個完整 URI 的組件裏面時不會解釋成保留字符了。

如下詞法文法指定了編碼後 URI 的形式。

語法

uri ::: uriCharactersopturiCharacters ::: uriCharacter uriCharactersopturiCharacter ::: uriReserved uriUnescaped uriEscaped uriReserved ::: one of ; / ? : @ & = + $ ,uriUnescaped ::: uriAlpha DecimalDigit uriMarkuriEscaped ::: % HexDigit HexDigit uriAlpha ::: one of a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z uriMark ::: one of - _ . ! ~ * ' ( )

以上語法是基於 RFC 2396 的，而且較新的 RFC 3986 引入的更改沒有反應在這裏。

當 URI 裏包含一個沒在上面列出的字符或有時不想讓給定的保留字符有特殊意義，那麼必須編碼這個字符。字符被轉換成 UTF-8 編碼，首先從 UT F-16 轉換成相應的代碼點值的替代對。（注：在 [0,127] 範圍的代碼單元在單字節中具備相同返回值。）而後返回的字節序列轉換爲一個字符串，每一個字節用一個「%xx」形式的轉移序列表示。

描述編碼和轉義過程的抽象操做 Encode 須要兩個字符串參數 string 和 unescapedSet。

1. 令 strLen 爲 string 的字符個數 .
2. 令 R 爲空字符串 .
3. 令 k 爲 0.
4. 重複
   1. 若是 k 等於 strLen, 返回 R.
   2. 令 C 爲 string 中位置爲 k 的字符 .
   3. 若是 C 在 unescapedSet 裏 , 則
      1. 令 S 爲一個只包含字符 C 的字符串 .
      2. 令 R 爲以前 R 的值和 S 鏈接獲得的一個新字符串值 .
   4. 不然 , C 不在 unescapedSet 裏
      1. 若是 C 的代碼單元值不小於 0xDC00 而且不大於 0xDFFF, 則拋出一個 URIError 異常 .
      2. 若是 C 的代碼單元值小於 0xD800 或大於 0xDBFF, 則
         1. 令 V 爲 C 的代碼單元值 .
      3. 不然 ,
         1. k 遞增 1.
         2. 若是 k 等於 strLen, 拋出一個 URIError 異常 .
         3. 令 kChar 爲 string 的 k 位置的字符的代碼單元值 .
         4. 若是 kChar 小於 0xDC00 或大於 0xDFFF, 則拋出一個 URIError 異常 .
         5. 令 V 爲 (((C 的代碼單元值 ) – 0xD800) * 0x400 + (kChar – 0xDC00) + 0x10000).
      4. 令 Octets 爲 V 執行 UTF-8 轉換的結果字節排列 , 令 L 爲這個字節排列的長度 .
      5. 令 j 爲 0.
      6. 只要 j < L，就重複
         1. 令 jOctet 爲 Octets 的 j 位置的值 .
         2. 令 S 爲一個包含三個字符「%XY」的字符串，這裏 XY 是編碼 jOctet 值的兩個大寫 16 進制數字 .
         3. 令 R 爲以前 R 的值和 S 鏈接獲得的一個新字符串值 .
         4. j 遞增 1.
   5. k 遞增 1.

描述反轉義和解碼過程的抽象操做 Decode 須要兩個字符串參數 string 和 reservedSet。

1. 令 strLen 爲 string 的字符個數 .
2. 令 R 爲空字符串 .
3. 令 k 爲 0.
4. 重複
   1. 若是 k 等於 strLen, 返回 R.
   2. 令 C 爲 string 的 k 位置的字符 .
   3. 若是 C 不是‘%’, 則
      1. 令 S 爲只包含字符 C 的字符串 .
   4. 不然 , C 是‘%’
      1. 令 start 爲 k.
      2. 若是 k + 2 大於或等於 strLen, 拋出一個 URIError 異常 .
      3. 若是 string 的 (k+1) 和 (k + 2) 位置的字符沒有表示爲 16 進制數字，則拋出一個 URIError 異常 .
      4. 令 B 爲 (k + 1) 和 (k + 2) 位置的兩個 16 進制數字表示的 8 位值 .
      5. k 遞增 2.
      6. 若是 B 的最高有效位是 0, 則
         1. 令 C 爲代碼單元值是 B 的字符 .
         2. 若是 C 不在 reservedSet 裏 , 則
            1. 令 S 爲只包含字符 C 的字符串 .
         3. 不然 , C 在 reservedSet 裏
            1. 令 S 爲 string 的從位置 start 到位置 k 的子字符串 .
      7. 不然 , B 的最高有效位是 1
         1. 令 n 爲知足 (B << n) & 0x80 等於 0 的最小非負數 .
         2. 若是 n 等於 1 或 n 大於 4, 拋出一個 URIError 異常 .
         3. 令 Octets 爲一個長度爲 n 的 8 位整數排列 .
         4. 將 B 放到 Octets 的 0 位置 .
         5. 若是 k + (3 * (n – 1)) 大於或等於 strLen, 拋出一個 URIError 異常 .
         6. 令 j 爲 1.
         7. 重複 , 直到 j < n
            1. k 遞增 1.
            2. 若是 string 的 k 位置的字符不是‘%’, 拋出一個 URIError 異常 .
            3. 若是 string 的 (k +1) 和 (k+2) 位置的字符沒有表示爲 16 進制數字 , 拋出一個 URIError 異常 .
            4. 令 B 爲 string 的 (k +1) 和 (k+2) 位置的兩個 16 進制數字表示的 8 位值 .
            5. 若是 B 的兩個最高有效位不是 10，拋出一個 URIError 異常 .
            6. k 遞增 2.
            7. 將 B 放到 Octets 的 j 位置 .
            8. j 遞增 1.
         8. 令 V 爲給 Octets 執行 UTF-8 轉換獲得的值，這是從一個字節排列到一個 32 位值的過程。 若是 Octets 不包含有效的 UTF-8 編碼的 Unicode 代碼點，則拋出一個 URIError 異常 .
         9. 若是 V 小於 0x10000, 則
            1. 令 C 爲代碼單元值是 V 的字符 .
            2. 若是 C 不在 reservedSet 裏 , 則
               1. 令 S 爲只包含字符 C 的字符串 .
            3. 不然 , C 在 reservedSet 裏
               1. 令 S 爲 string 的從位置 start 到位置 k 的子字符串 .
         10. 不然 , V ≥ 0x10000
             1. 令 L 爲 (((V – 0x10000) & 0x3FF) + 0xDC00).
             2. 令 H 爲 ((((V – 0x10000) >> 10) & 0x3FF) + 0xD800).
             3. 令 S 爲代碼單元值是 H 和 L 的兩個字符組成的字符串 .
5. 令 R 爲以前的 R 和 S 鏈接成的新字符串 .
6. k 遞增 1.

統一資源標識符的語法由 RFC 2396 給出，這裏並無反應更新的替換了 RFC 2396 的 RFC 3986。RFC 3629 給出了實現 UTF-8 的正式描述。

在 UTF-8 中，用 1 到 6 個字節的序列來編碼字符。只有「序列」中高階位設置爲 0 的字節，其他的 7 位才用於編碼字符值。在一個 n 個字節的序列中，n>1，初始字節有 n 個設置爲 1 的高階位，其後的位設置爲 0。這個字節的其餘位包含是用來編碼字符的比特。後面跟着的其字節都包含設定爲 1 的高階位，而且都跟着設定爲 0 的位，剩下的 6 位都用做編碼字符。表 21 指定了 ECMAScript 字符可能的 UTF-8 編碼。

UTF-8編碼

字符編碼值	表示	第1十六進制位	第2六進制位	第3十六進制位	第4十六進制位
0x0000 - 0x007F	00000000 0zzzzzzz	0zzzzzzz
0x0080 - 0x07FF	00000yyy yyzzzzzz	110yyyyy	10zzzzzz
0x0800 - 0xD7FF	xxxxyyyy yyzzzzzz	1110xxxx	10yyyyyy	10zzzzzz
0xD800 - 0xDBFF 後跟 0xDC00 - 0xDFFF	110110vv vvwwwwxx後跟110111yy yyzzzzzz	11110uuu	10uuwwww	10xxyyyy	10zzzzzz
0xD800 - 0xDBFF 後無 0xDC00 - 0xDFFF	致使URIError
0xDC00 - 0xDFFF	致使URIError
0xE000 - 0xFFFF	xxxxyyyy yyzzzzzz	1110xxxx	10yyyyyy	10zzzzzz

在這裏

uuuuu = vvvv + 1

來訪問附加的做爲代理項的 0x10000，在 Unicode 標準 3.7 章節。

0xD800-0xDFFF 範圍的代碼單元值用來編碼代理對；如上將 UTF-16 代理對轉換組合成一個 UTF-32 表示，並編碼 UTF-8 值的 21 位結果。解碼重建代理對。

RFC 3629 禁止對無效 UTF-8 字節序列的解碼。例如，無效序列 C0 80 不能解碼成字符 U+0000。當 Decode 算法的實現遇到這樣的無效序列必須拋出一個 URIError 異常。

decodeURI (encodedURI)

decodeURI 函數計算出一個新版 URI，將 URI 中多是 encodeURI 函數引入的每一個轉義序列和 UTF-8 編碼組替換爲表明它們的字符。不是 encodeURI 導入的轉義序列不會被替換。

當以一個參數 encodedURI 調用 decodeURI 函數，採用以下步驟：

1. 令 uriString 爲 ToString(encodedURI).
2. 令 reservedURISet 爲一個字符串，包含 uriReserved 的每一個有效字符加上 "#" 的實例。
3. 返回調用 Decode(uriString, reservedURISet) 的結果。

"#" 字符不會從轉義序列中解碼，即便它不是 URI 保留字符。

decodeURIComponent (encodedURIComponent)

decodeURIComponent 函數計算出一個新版 URI，將 URI 中多是 encodeURIComponent 函數引入的每一個轉義序列和 UTF-8 編碼組替換爲表明它們的字符。

當以一個參數 encodedURIComponent 調用 decodeURIComponent 函數，採用以下步驟：

1. 令 componentString 爲 ToString(encodedURIComponent).
2. 令 reservedURIComponentSet 爲一個空字符串。
3. 返回調用 Decode(componentString, reservedURIComponentSet) 的結果。

encodeURI (uri)

encodeURI 函數計算出一個新版 URI，將 URI 中某些字符的每一個實例替換爲表明這些字符 UTF-8 編碼的一個，兩個或三個轉義序列。

當以一個參數 uri 調用 encodeURI 函數，採用以下步驟：

1. 令 uriString 爲 ToString(uri).
2. 令 unescapedURISet 爲一個字符串，包含 uriReserved 和 uriUnescaped 的每一個有效字符加上 "#" 的實例。
3. 返回調用 Encode(uriString, unescapedURISet) 的結果。

字符 "#" 不會被編碼爲一個轉義序列，即便它不是 URI 保留字符或非轉義字符。

encodeURIComponent (uriComponent)

encodeURIComponent 函數計算出一個新版 URI，將 URI 中某些字符的每一個實例替換爲表明這些字符 UTF-8 編碼的一個，兩個或三個轉義序列。

當以一個參數 uriComponent 調用 encodeURIComponent 函數，採用以下步驟：

1. 令 componentString 爲 ToString(uriComponent).
2. 令 unescapedURIComponentSet 爲一個字符串，包含 uriUnescaped 的每一個有效字符的實例。
3. 返回調用 Encode(componentString, unescapedURIComponentSet) 的結果。

全局對象的構造器屬性

Object ( . . . )

見 15.2.1 和 15.2.2.

Function ( . . . )

見 15.3.1 和 15.3.2

Array ( . . . )

見 15.4.1 和 15.4.2.

String ( . . . )

見 15.5.1 和 15.5.2.

Boolean ( . . . )

見 15.6.1 和 15.6.2.

Number ( . . . )

見 15.7.1 和 15.7.2.

Date ( . . . )

見 15.9.2.

RegExp ( . . . )

見 15.10.3 和 15.10.4.

Error ( . . . )

見 15.11.1 和 15.11.2.

EvalError ( . . . )

見 15.11.6.1.

RangeError ( . . . )

見 15.11.6.2.

ReferenceError ( . . . )

見 15.11.6.3.

SyntaxError ( . . . )

見 15.11.6.4.

TypeError ( . . . )

見 15.11.6.5.

URIError ( . . . )

見 15.11.6.6.

全局對象的其餘屬性

Math

見 15.8.

JSON

見 15.12.

Object 對象

做爲函數調用 Object 構造器

當把 Object 當作一個函數來調用，而不是一個構造器，它會執行一個類型轉換。

Object ( [ value ] )

當以一個參數 value 或者無參數調用 Object 函數，採用以下步驟：

1. 若是 value 是 null, undefined 或未指定，則建立並返回一個新 Object 對象 , 這個對象與彷彿用相同參數調用標準內置的 Object 構造器 (15.2.2.1) 的結果同樣 .
2. 返回 ToObject(value).

Object 構造器

當 Object 是 new 表達式調用的一部分時，它是一個構造器，可建立一個對象。

new Object ( [ value ] )

當以一個參數 value 或者無參數調用 Object 構造器，採用以下步驟：

1. 若是提供了 value, 則
   1. 若是 Type(value) 是 Object, 則
      1. 若是 value 是個原生 ECMAScript 對象 , 不建立新對象，簡單的返回 value.
      2. 若是 value 是宿主對象 , 則採起動做和返回依賴實現的結果的方式能夠使依賴於宿主對象的 .
   2. 若是 Type(value) 是 String, 返回 ToObject(value).
   3. 若是 Type(value) 是 Boolean, 返回 ToObject(value).
   4. 若是 Type(value) 是 Number, 返回 ToObject(value).
2. 斷言 : 未提供參數 value 或其類型是 Null 或 Undefined.
3. 令 obj 爲一個新建立的原生 ECMAScript 對象 .
4. 設定 obj 的 [[Prototype]] 內部屬性爲標準內置的 Object 的 prototype 對象 (15.2.4).
5. 設定 obj 的 [[Class]] 內部屬性爲 "Object".
6. 設定 obj 的 [[Extensible]] 內部屬性爲 true.
7. 設定 obj 的 8.12 指定的全部內部方法
8. 返回 obj.

Object 構造器的屬性

Object 構造器的 [[Prototype]] 內部屬性值是標準內置 Function 的 prototype 對象。

除了內部屬性和 length 屬性（其值是 1）以外，Object 構造器擁有如下屬性：

Object.prototype

Object.prototype 的初始值是標準內置 Object 的 prototype 對象（15.2.4）。

這個屬性包含特性 {[[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }

Object.getPrototypeOf ( O )

當以參數 O 調用 getPrototypeOf 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 返回 O 的 [[Prototype]] 內部屬性的值 .

Object.getOwnPropertyDescriptor ( O, P )

當調用 getOwnPropertyDescriptor 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 令 name 爲 ToString(P).
3. 令 desc 爲以參數 name 調用 O 的 [[GetOwnProperty]] 內部方法的結果 .
4. 返回調用 FromPropertyDescriptor(desc) 的結果 (8.10.4).

Object.getOwnPropertyNames ( O )

當調用 getOwnPropertyNames 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 令 array 爲彷彿是用表達式 new Array () 建立新對象的結果，這裏的 Array 是標準內置構造器名。
3. 令 n 爲 0.
4. 對 O 的每一個自身屬性 P
   1. 令 name 爲值是 P 的名稱的字符串 .
   2. 以 ToString(n) 和屬性描述 {[[Value]]: name, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 爲參數調用 array 的 [[DefineOwnProperty]] 內部方法 .
   3. n 遞增 1.
5. 返回 array.

若是 O 是一個字符串實例，第 4 步處理的自身屬性集合包含 15.5.5.2 定義的隱藏屬性，他們對應對象的 [[PrimitiveValue]] 字符串中相應位置的字符。

Object.create ( O [, Properties] )

create 函數按照指定的原型建立一個新對象。當調用 create 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object 或 Null，則拋出一個 TypeError 異常 .
2. 令 obj 爲爲彷彿是用表達式 new Object() 建立新對象的結果，這裏的 Object 是標準內置構造器名。
3. 設定 obj 的 [[Prototype]] 內部屬性爲 O.
4. 若是傳入了 Properties 參數而且不是 undefined, 則彷彿是用 obj 和 Properties 看成參數調用標準內置函數 Object.defineProperties 同樣給 obj 添加自身屬性。
5. 返回 obj.

Object.defineProperty ( O, P, Attributes )

defineProperty 函數用於給一個對象添加一個自身屬性 並 / 或 更新現有自身屬性的特性。當調用 defineProperty 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 令 name 爲 ToString(P).
3. 令 desc 爲以 Attributes 做爲參數調用 ToPropertyDescriptor 的結果 .
4. 以 name, desc, true 做爲參數調用 O 的 [[DefineOwnProperty]] 內部方法 .
5. 返回 O.

Object.defineProperties ( O, Properties )

defineProperties 函數用於給一個對象添加一些自身屬性 並 / 或 更新現有的一些自身屬性的特性。當調用 defineProperties 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 令 props 爲 ToObject(Properties).
3. 令 names 爲一個內部列表，它包含 props 的每一個可遍歷自身屬性的名稱 .
4. 令 descriptors 爲一個空的內部列表 .
5. 對 names 的每一個元素 P，按照列表順序 ,
   1. 令 descObj 爲以 P 做爲參數調用 props 的 [[Get]] 內部方法的結果 .
   2. 令 desc 爲以 descObj 做爲參數調用 ToPropertyDescriptor 的結果 .
   3. 將 desc 插入 descriptors 的尾部 .
6. 對 descriptors 的每一個元素 desc，按照列表順序 ,
   1. 以參數 P, desc, true 調用 O 的 [[DefineOwnProperty]] 內部方法 .
7. 返回 O

若是一個實現爲 for-in 語句的定義了特定的枚舉順序，那麼在這個算法的第 3 步中的列表元素必須也用相同的順序排列。

Object.seal ( O )

當調用 seal 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 對 O 的每一個命名自身屬性名 P,
   1. 令 desc 爲以參數 P 調用 O 的 [[GetOwnProperty]] 內部方法的結果 .
   2. 若是 desc.[[Configurable]] 是 true, 設定 desc.[[Configurable]] 爲 false.
   3. 以 P, desc, true 爲參數調用 O 的 [[DefineOwnProperty]] 內部方法 .
3. 設定 O 的 [[Extensible]] 內部屬性爲 false.
4. 返回 O.

Object.freeze ( O )

當調用 freeze 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 對 O 的每一個命名自身屬性名 P,
   1. 令 desc 爲以參數 P 調用 O 的 [[GetOwnProperty]] 內部方法的結果 .
   2. 若是 IsDataDescriptor(desc) 是 true, 則
      1. 若是 desc.[[Writable]] 是 true, 設定 desc.[[Writable]] 爲 false.
   3. 若是 desc.[[Configurable]] 是 true, 設定 desc.[[Configurable]] 爲 false.
   4. 以 P, desc, true 做爲參數調用 O 的 [[DefineOwnProperty]] 內部方法 .
3. 設定 O 的 [[Extensible]] 內部屬性爲 false.
4. 返回 O.

Object.preventExtensions ( O )

當調用 preventExtensions 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 設定 O 的 [[Extensible]] 內部屬性爲 false.
3. 返回 O.

Object.isSealed ( O )

當以參數 O 調用 isSealed 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 對 O 的每一個命名自身屬性名 P,
   1. 令 desc 爲以參數 P 調用 O 的 [[GetOwnProperty]] 內部方法的結果 .
   2. 若是 desc.[[Configurable]] 是 true, 則返回 false.
3. 若是 O 的 [[Extensible]] 內部屬性是 false, 則返回 true.
4. 不然 , 返回 false.

Object.isFrozen ( O )

當以參數 O 調用 isFrozen 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 對 O 的每一個命名自身屬性名 P,
   1. 令 desc 爲以參數 P 調用 O 的 [[GetOwnProperty]] 內部方法的結果 .
   2. 若是 IsDataDescriptor(desc) 是 true，則
      1. 若是 desc.[[Writable]] 是 true, 則返回 false.
   3. 若是 desc.[[Configurable]] 是 true, 則返回 false.
3. 若是 O 的 [[Extensible]] 內部屬性是 false, 則返回 true.
4. 不然 , 返回 false.

Object.isExtensible ( O )

當以參數 O 調用 isExtensible 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 返回 O 的 [[Extensible]] 內部屬性布爾值 .

Object.keys ( O )

當以參數 O 調用 keys 函數，採用以下步驟：

1. 若是 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
2. 令 n 爲 O 的可遍歷自身屬性的個數
3. 令 array 爲彷彿是用表達式 new Array () 建立新對象的結果，這裏的 Array 是標準內置構造器名。
4. 令 index 爲 0.
5. 對 O 的每一個可遍歷自身屬性名 P,
   1. 以 ToString(index)，屬性描述 {[[Value]]: P, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}，和 false 做爲參數調用 array 的 [[DefineOwnProperty]] 內部方法。
   2. index 遞增 1.
6. 返回 array.

若是一個實現爲 for-in 語句的定義了特定的枚舉順序，那麼在這個算法的第 5 步中的必須使用相同的枚舉順序。

Object 的 prototype 對象的屬性

Object 的 prototype 對象的 [[Prototype]] 內部屬性的值是 null，[[Class]] 內部屬性的值是 "Object"，[[Extensible]] 內部屬性的初始值是 true。

Object.prototype.constructor

Object.prototype.constructor 的初始值是標準內置的 Object 構造器。

Object.prototype.toString ( )

當調用 toString 方法，採用以下步驟：

1. 若是 this 的值是 undefined, 返回 "[object Undefined]".
2. 若是 this 的值是 null, 返回 "[object Null]".
3. 令 O 爲以 this 做爲參數調用 ToObject 的結果 .
4. 令 class 爲 O 的 [[Class]] 內部屬性的值 .
5. 返回三個字符串 "[object ", class, and "]" 連起來的字符串 .

Object.prototype.toLocaleString ( )

當調用 toLocaleString 方法，採用以下步驟：

1. 令 O 爲以 this 做爲參數調用 ToObject 的結果 .
2. 令 toString 爲以 "toString" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 若是 IsCallable(toString) 是 false, 拋出一個 TypeError 異常 .
4. 返回以 O 做爲 this 值，無參數調用 toString 的 [[Call]] 內部方法的結果 .

這個函數給全部 Object 對象提供一個通用的 toLocaleString 接口，即便並非全部的都使用它。目前，Array, Number, Date 提供了它們自身的語言環境敏感的 toLocaleString 方法。

這個函數的第一個參數可能會在此標準的將來版本中使用到；所以建議實現不要用這個位置參數來作其餘事情。

Object.prototype.valueOf ( )

當調用 valueOf 方法，採用以下步驟：

1. 令 O 爲以 this 做爲參數調用 ToObject 的結果 .
2. 若是 O 是以一個宿主對象 (15.2.2.1) 爲參數調用 Object 構造器的結果，則
   1. 返回 O 或傳遞給構造器的原來的宿主對象 . 返回的具體結果是由實現定義的 .
3. 返回 O.

Object.prototype.hasOwnProperty (V)

當以參數 V 調用 hasOwnProperty 方法，採用以下步驟：

1. 令 P 爲 ToString(V).
2. 令 O 爲以 this 值做爲參數調用 ToObject 的結果 .
3. 令 desc 爲以 P 爲參數調用 O 的 [[GetOwnProperty]] 內部方法的結果 .
4. 若是 desc 是 undefined, 返回 false.
5. 返回 true.

不像 [[HasProperty]](8.12.6)，這個方法不考慮原形鏈中的對象。

爲步驟 1 和 2 的選擇這樣的順序，是爲了確保在本規範以前版本中會在這裏的步驟 1 裏拋出的任何異常，即便 this 值是 undefined 或 null，也會繼續拋出。

Object.prototype.isPrototypeOf (V)

當以參數 V 調用 isPrototypeOf 方法，採用以下步驟：

1. 若是 V 不是個對象 , 返回 false.
2. 令 O 爲以 this 做爲參數調用 ToObject 的結果 .
3. 重複
   1. 令 V 爲 V 的 [[Prototype]] 內部屬性的值 .
   2. 若是 V 是 null, 返回 false
   3. 若是 O 和 V 指向同一個對象 , 返回 true.

爲步驟 1 和 2 的選擇這樣的順序，是爲了當 V 不是對象而且 this 值是 undefined 或 null 時可以保持本規範以前版本指定的行爲。

Object.prototype.propertyIsEnumerable (V)

當以參數 V 調用 propertyIsEnumerable 方法，採用以下步驟：

1. 令 P 爲 ToString(V).
2. 令 O 爲以 this 做爲參數調用 ToObject 的結果 .
3. 令 desc 爲以 P 做爲參數調用 O 的 [[GetOwnProperty]] 內部方法的結果 .
4. 若是 desc 是 undefined, 返回 false.
5. 返回 desc.[[Enumerable]] 的值 .

這個方法不考慮原型鏈中的對象。

爲步驟 1 和 2 的選擇這樣的順序，是爲了確保在本規範以前版本中會在這裏的步驟 1 裏拋出的任何異常，即便 this 值是 undefined 或 null，也會繼續拋出。

Object 的實例的屬性

Object 的實例除了擁從 Object 的 prototype 對象繼承來的屬性以外不包含特殊的屬性。

Function 對象

做爲函數調用 Function 構造器

當將 Function 做爲函數來調用，而不是做爲構造器，它會建立並初始化一個新函數對象。因此函數調用 Function(…) 與用相同參數的 new Function(…) 表達式建立的對象相同。

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

當以 p1, p2, … , pn, body 做爲參數調用 Function 函數（這裏的 n 能夠是 0，也就是說沒有「p」參數，這時還能夠不提供 body），採用以下步驟：

1. 建立並返回一個新函數對象，它彷彿是用相同參數給標準內置構造器 Function (15.3.2.1). 用一個 new 表達式建立的。

Function 構造器

當 Function 做爲 new 表達式的一部分被調用時，它是一個構造器：它初始化新建立的對象。

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

最後一個參數指定爲函數的 body( 可執行代碼 )；以前的任何參數都指定爲形式參數。

當以 p1, p2, … , pn, body 做爲參數調用 Function 構造器（這裏的 n 能夠是 0，也就是說沒有「p」參數，這時還能夠不提供 body），採用以下步驟：

1. 令 argCount 爲傳給這個函數調用的參數總數 .
2. 令 P 爲空字符串 .
3. 若是 argCount = 0, 令 body 爲空字符串 .
4. 不然若是 argCount = 1, 令 body 爲那個參數 .
5. 不然 , argCount > 1
   1. 令 firstArg 爲第一個參數 .
   2. 令 P 爲 ToString(firstArg).
   3. 令 k 爲 2.
   4. 只要 k < argCount 就重複
      1. 令 nextArg 爲第 k 個參數 .
      2. 令 P 爲以前的 P 值，字符串 ","（一個逗號），ToString(nextArg) 串聯的結果。
      3. k 遞增 1.
   5. 令 body 爲第 k 個參數 .
6. 令 body 爲 ToString(body).
7. 若是 P 不可解析爲一個 FormalParameterListopt，則拋出一個 SyntaxError 異常 .
8. 若是 body 不可解析爲 FunctionBody，則拋出一個 SyntaxError 異常 .
9. 若是 body 是嚴格模式代碼 ( 見 10.1.1)，則令 strict 爲 true, 不然令 strict 爲 false.
10. 若是 strict 是 true, 適用 13.1 指定拋出的任何異常 .
11. 返回一個新建立的函數對象，它是依照 13.2 指定 -- 專遞 P 做爲 FormalParameterList，body 做爲 FunctionBody，全局環境做爲 Scope 參數，strict 做爲嚴格模式標誌 -- 建立的。

每一個函數都會自動建立一個 prototype 屬性，用來支持函數被當作構造器使用的可能性。

爲每一個形參指定一個參數是容許的，但不必。例如如下三個表達式產生相同的結果： new Function("a", "b", "c", "return a+b+c") new Function("a, b, c", "return a+b+c") new Function("a,b", "c", "return a+b+c")

Function 構造器的屬性

Function 構造器自身是個函數對象，它的 [[Class]] 是 "Function"。Function 構造器的 [[Prototype]] 內部屬性值是標準內置 Function 的 prototype 對象 (15.3.4)。

Function 構造器的 [[Extensible]] 內部屬性值是 true.

Function 構造器有以下屬性 :

Function.prototype

Function.prototype 的初始值是標準內置 Function 的 prototype 對象 (15.3.4)。

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

Function.length

這是個值爲 1 的數據屬性。此屬性擁有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Function 的 prototype 對象的屬性

Function 的 prototype 對象自身是一個函數對象 ( 它的 [[Class]] 是 "Function")，調用這個函數對象時，接受任何參數並返回 undefined。

Function 的 prototype 對象的 [[Prototype]] 內部屬性值是標準內置 Object 的 prototype 對象 (15.2.4)。Function 的 prototype 對象的 [[Extensible]] 內部屬性的初始值是 true。

Function 的 prototype 對象自身沒有 valueOf 屬性 ; 可是，它從 Object 的 prototype 對象繼承了 valueOf 屬性。

Function 的 prototype 對象的 length 屬性是 0。

Function.prototype.constructor

Function.prototype.constructor 的初始值是內置 Function 構造器。

Function.prototype.toString ( )

此函數的返回值的表示是依賴於實現的。這個表示包含 FunctionDeclaration 的語法。特別注意，怎樣在這個字符串表示中使用和放置空白，行終結符，分號是依賴於實現的。

這個 toString 不是通用的；若是它的 this 值不是一個函數對象，它會拋出一個 TypeError 異常。所以，它不能當作方法來轉移到其餘類型的對象中。

Function.prototype.apply (thisArg, argArray)

當以 thisArg 和 argArray 爲參數在一個 func 對象上調用 apply 方法，採用以下步驟：

1. 若是 IsCallable(func) 是 false, 則拋出一個 TypeError 異常 .
2. 若是 argArray 是 null 或 undefined, 則
   1. 返回提供 thisArg 做爲 this 值並以空參數列表調用 func 的 [[Call]] 內部方法的結果。
3. 若是 Type(argArray) 不是 Object, 則拋出一個 TypeError 異常 .
4. 令 len 爲以 "length" 做爲參數調用 argArray 的 [[Get]] 內部方法的結果。
5. 令 n 爲 ToUint32(len).
6. 令 argList 爲一個空列表 .
7. 令 index 爲 0.
8. 只要 index < n 就重複
   1. 令 indexName 爲 ToString(index).
   2. 令 nextArg 爲以 indexName 做爲參數調用 argArray 的 [[Get]] 內部方法的結果。
   3. 將 nextArg 做爲最後一個元素插入到 argList 裏。
   4. 設定 index 爲 index + 1.
9. 提供 thisArg 做爲 this 值並以 argList 做爲參數列表，調用 func 的 [[Call]] 內部方法，返回結果。

apply 方法的 length 屬性是 2。

在外面傳入的 thisArg 值會修改併成爲 this 值。thisArg 是 undefined 或 null 時它會被替換成全局對象，全部其餘值會被應用 ToObject 並將結果做爲 this 值，這是第三版引入的更改。

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

當以 thisArg 和可選的 arg1, arg2 等等做爲參數在一個 func 對象上調用 call 方法，採用以下步驟：

1. 若是 IsCallable(func) 是 false, 則拋出一個 TypeError 異常。
2. 令 argList 爲一個空列表。
3. 若是調用這個方法的參數多餘一個，則從 arg1 開始以從左到右的順序將每一個參數插入爲 argList 的最後一個元素。
4. 提供 thisArg 做爲 this 值並以 argList 做爲參數列表，調用 func 的 [[Call]] 內部方法，返回結果。

call 方法的 length 屬性是 1。

在外面傳入的 thisArg 值會修改併成爲 this 值。thisArg 是 undefined 或 null 時它會被替換成全局對象，全部其餘值會被應用 ToObject 並將結果做爲 this 值，這是第三版引入的更改。

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

bind 方法須要一個或更多參數，thisArg 和（可選的）arg1, arg2, 等等，執行以下步驟返回一個新函數對象：

1. 令 Target 爲 this 值 .
2. 若是 IsCallable(Target) 是 false, 拋出一個 TypeError 異常 .
3. 令 A 爲一個（可能爲空的）新內部列表，它包含按順序的 thisArg 後面的全部參數（arg1, arg2 等等）。
4. 令 F 爲一個新原生 ECMAScript 對象。
5. 依照 8.12 指定，設定 F 的除了 [[Get]] 以外的全部內部方法。
6. 依照 15.3.5.4 指定，設定 F 的 [[Get]] 內部屬性。
7. 設定 F 的 [[TargetFunction]] 內部屬性爲 Target。
8. 設定 F 的 [[BoundThis]] 內部屬性爲 thisArg 的值。
9. 設定 F 的 [[BoundArgs]] 內部屬性爲 A。
10. 設定 F 的 [[Class]] 內部屬性爲 "Function"。
11. 設定 F 的 [[Prototype]] 內部屬性爲 15.3.3.1 指定的標準內置 Function 的 prototype 對象。
12. 依照 15.3.4.5.1 描述，設定 F 的 [[Call]] 內置屬性。
13. 依照 15.3.4.5.2 描述，設定 F 的 [[Construct]] 內置屬性。
14. 依照 15.3.4.5.3 描述，設定 F 的 [[HasInstance]] 內置屬性。
15. 若是 Target 的 [[Class]] 內部屬性是 "Function", 則
    1. 令 L 爲 Target 的 length 屬性減 A 的長度。
    2. 設定 F 的 length 自身屬性爲 0 和 L 中更大的值。
16. 不然設定 F 的 length 自身屬性爲 0.
17. 設定 F 的 length 自身屬性的特性爲 15.3.5.1 指定的值。
18. 設定 F 的 [[Extensible]] 內部屬性爲 true。
19. 令 thrower 爲 [[ThrowTypeError]] 函數對象 (13.2.3)。
20. 以 "caller", 屬性描述符 {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, 和 false 做爲參數調用 F 的 [[DefineOwnProperty]] 內部方法。
21. 以 "arguments", 屬性描述符 {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, 和 false 做爲參數調用 F 的 [[DefineOwnProperty]] 內部方法。
22. 返回 F.

bind 方法的 length 屬性是 1。

Function.prototype.bind 建立的函數對象不包含 prototype 屬性或 [[Code]], [[FormalParameters]], [[Scope]] 內部屬性。

[[Call]]

當調用一個用 bind 函數建立的函數對象 F 的 [[Call]] 內部方法，傳入一個 this 值和一個參數列表 ExtraArgs，採用以下步驟：

1. 令 boundArgs 爲 F 的 [[BoundArgs]] 內部屬性值。
2. 令 boundThis 爲 F 的 [[BoundThis]] 內部屬性值。
3. 令 target 爲 F 的 [[TargetFunction]] 內部屬性值。
4. 令 args 爲一個新列表，它包含與列表 boundArgs 相同順序相同值，後面跟着與 ExtraArgs 是相同順序相同值。
5. 提供 boundThis 做爲 this 值，提供 args 爲參數調用 target 的 [[Call]] 內部方法，返回結果。

[[Construct]]

當調用一個用 bind 函數建立的函數對象 F 的 [[Construct]] 內部方法，傳入一個參數列表 ExtraArgs，採用以下步驟：

1. 令 target 爲 F 的 [[TargetFunction]] 內部屬性值。
2. 若是 target 不包含 [[Construct]] 內部方法 , 拋出一個 TypeError 異常。
3. 令 boundArgs 爲 F 的 [[BoundArgs]] 內部屬性值。
4. 令 args 爲一個新列表，它包含與列表 boundArgs 相同順序相同值，後面跟着與 ExtraArgs 是相同順序相同值。
5. 提供 args 爲參數調用 target 的 [[Construct]] 內部方法，返回結果。

[[HasInstance]] (V)

當調用一個用 bind 函數建立的函數對象 F 的 [[Construct]] 內部方法，並以 V 做爲參數，採用以下步驟：

1. 令 target 爲 F 的 [[TargetFunction]] 內部屬性值。
2. 若是 target 不包含 [[HasInstance]] 內部方法 , 拋出一個 TypeError 異常。
3. 提供 V 爲參數調用 target 的 [[HasInstance]] 內部方法，返回結果。

Function 的實例的屬性

除了必要的內部屬性以外，每一個函數實例還有一個 [[Call]] 內部屬性而且在大多數狀況下使用不一樣版本的 [[Get]] 內部屬性。函數實例根據怎樣建立的（見 8.6.2 ,13.2, 15, 15.3.4.5）可能還有一個 [[HasInstance]] 內部屬性 , 一個 [[Scope]] 內部屬性 , 一個 [[Construct]] 內部屬性 , 一個 [[FormalParameters]] 內部屬性 , 一個 [[Code]] 內部屬性 , 一個 [[TargetFunction]] 內部屬性 , 一個 [[BoundThis]] 內部屬性 , 一個 [[BoundArgs]] 內部屬性。

[[Class]] 內部屬性的值是 "Function"。

對應於嚴格模式函數 (13.2) 的函數實例和用 Function.prototype.bind 方法 (15.3.4.5) 建立的函數實例有名爲「caller」和 「arguments」的屬性時，拋出一個 TypeError 異常。一個 ECMAScript 實現不得爲在嚴格模式函數代碼裏訪問這些屬性關聯任何依賴實現的特定行爲。

length

length 屬性值是個整數，它指出函數預期的「通常的」參數個數。然而，語言容許用其餘數量的參數來調用函數。當以與函數的 length 屬性指定的數量不一樣的參數個數調用函數時，它的行爲依賴於函數自身。這個屬性擁有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

prototype

prototype 屬性的值用於初始化一個新建立對象的的 [[Prototype]] 內部屬性，爲了這個新建立對象要先將函數對象做爲構造器調用。這個屬性擁有特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }。

用 Function.prototype.bind 建立的函數對象沒有 prototype 屬性。

[[HasInstance]] (V)

設 F 是個函數對象。

當以 V 做爲參數調用 F 的 [[HasInstance]] 內部方法，採用以下步驟：

1. 若是 V 不是個對象 , 返回 false。
2. 令 O 爲用屬性名 "prototype" 調用 F 的 [[Get]] 內部方法的結果。
3. 若是 Type(O) 不是 Object, 拋出一個 TypeError 異常。
4. 重複
   1. 令 V 爲 V 的 [[Prototype]] 內部屬性值。
   2. 若是 V 是 null, 返回 false.
   3. 若是 O 和 V 指向相同對象，返回 true。

用 Function.prototype.bind 建立的函數對象擁有的不一樣的 [[HasInstance]] 實現，在 15.3.4.5.3 中定義。

[[Get]] (P)

函數對象與其餘原生 EMACScript 對象 (8.12.3) 用不一樣的 [[Get]] 內部方法。

設 F 是一個函數對象，當以屬性名 P 調用 F 的 [[Get]] 內部方法 , 採用以下步驟：

1. 令 v 爲傳入 P 做爲屬性名參數調用 F 的默認 [[Get]] 內部方法 (8.12.3) 的結果。
2. 若是 P 是 "caller" 而且 v 是個嚴格模式函數對象 , 拋出一個 TypeError 異常。
3. 返回 v。

用 Function.prototype.bind 建立的函數對象使用默認的 [[Get]] 內部方法。

Array 對象

數組對象會給予一些種類的屬性名特殊待遇。對一個屬性名 P（字符串形式），當且僅當 ToString(ToUint32(P)) 等於 P 而且 ToUint32(P) 不等於 2³²−1 時，它是個 數組索引 。一個屬性名是數組索引的屬性還叫作 元素 。全部數組對象都有一個 length 屬性，其值始終是一個小於 2³² 的非負整數。length 屬性值在數值上比任何名爲數組索引的屬性的名稱還要大；每當建立或更改一個數組對象的屬性，要調整其餘的屬性以保持上面那個條件不變的須要。具體來講，每當添加一個名爲數組索引的屬性時，若是須要就更改 length 屬性爲在數值上比這個數組索引大 1 的值；每當更改 length 屬性，全部屬性名是數組索引而且其值不小於新 length 的屬性會被自動刪除。這個限制只應用於數組對象的自身屬性，而且從原型中繼承的 length 或數組索引不影響這個限制。

對一個對象 O，若是如下算法返回 true，那麼就叫這個對象爲 稀疏 的：

1. 令 len 爲以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果。
2. 對每一個範圍在 0≤i<ToUint32(len) 的整數 i
   1. 令 elem 爲以 ToString(i) 做爲參數調用 O 的 [[GetOwnProperty]] 內部方法的結果。
   2. 若是 elem 是 undefined, 返回 true.
3. 返回 false.

做爲函數調用 Array 構造器

當將 Array 做爲函數來調用，而不是做爲構造器，它會建立並初始化一個新數組對象。因此函數調用 Array(…) 與用相同參數的 new Array(…) 表達式建立的對象相同。

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

當調用 Array 函數，採用以下步驟：

1. 建立並返回一個新函數對象，它彷彿是用相同參數給標準內置構造器 Array 用一個 new 表達式建立的 (15.4.2)。

Array 構造器

當 Array 做爲 new 表達式的一部分被調用時，它是一個構造器：它初始化新建立的對象。

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

當且僅當以無參數或至少兩個參數調用 Array 構造器時，適用這裏的描述。

新構造對象的 [[Prototype]] 內部屬性要設定爲原始的數組原型對象，他是 Array.prototype(15.4.3.1) 的初始值。

新構造對象的 [[Class]] 內部屬性要設定爲 "Array"。

新構造對象的 [[Extensible]] 內部屬性要設定爲 true。

新構造對象的 length 屬性要設定爲參數的個數。

新構造對象的 0 屬性要設定爲 item0( 若是提供了 ); 新構造對象的 1 屬性要設定爲 item1( 若是提供了 ); 更多的參數可應用廣泛規律，新構造對象的 k 屬性要設定爲第 k 個參數，這裏的 k 是從 0 開始的。全部這些屬性都有特性 {[[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}。

new Array (len)

新構造對象的 [[Prototype]] 內部屬性要設定爲原始的數組原型對象，他是 Array.prototype(15.4.3.1) 的初始值。新構造對象的 [[Class]] 內部屬性要設定爲 "Array"。新構造對象的 [[Extensible]] 內部屬性要設定爲 true。

若是參數 len 是個數字值而且 ToUint32(len) 等於 len，則新構造對象的 length 屬性要設定爲 ToUint32(len)。若是參數 len 是個數字值而且 ToUint32(len) 不等於 len，則拋出一個 RangeError 異常。

若是參數 len 不是數字值，則新構造對象的 length 屬性要設定爲 0，而且新構造對象的 0 屬性要設定爲 len，設定它的特性爲 {[[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}。

Array 構造器的屬性

Array 構造器的 [[Prototype]] 內部屬性值是函數原型對象 (15.3.4)。

Array 構造器除了有一些內部屬性和 length 屬性（其值是 1）以外，還有以下屬性：

Array.prototype

Array.prototype 的初始值是數組原型對象 (15.4.4)。

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

Array.isArray ( arg )

isArray 函數須要一個參數 arg，若是參數是個對象而且 class 內部屬性是 "Array", 返回布爾值 true；不然它返回 false。採用以下步驟：

1. 若是 Type(arg) 不是 Object, 返回 false。
2. 若是 arg 的 [[Class]] 內部屬性值是 "Array", 則返回 true。
3. 返回 false.

數組原型對象的屬性

數組原型對象的 [[Prototype]] 內部屬性值是標準內置 Object 原型對象 (15.2.4)。

數組原型對象自身是個數組；它的 [[Class]] 是 "Array"，它擁有一個 length 屬性（初始值是 +0）和 15.4.5.1 描述的特殊的 [[DefineOwnProperty]] 內部方法。

在如下的對數組原型對象的屬性函數的描述中，短語「this 對象」指的是調用這個函數時的 this 值對象。容許 this 是 [[Class]] 內部屬性值不是 "Array" 的對象。

數組原型對象不包含它自身的 valueOf 屬性；然而，它從標準內置 Object 原型對象繼承 valueOf 屬性。

Array.prototype.constructor

Array.prototype.constructor 的初始值是標準內置 Array 構造器。

Array.prototype.toString ( )

當調用 toString 方法，採用以下步驟：

1. 令 array 爲用 this 值調用 ToObject 的結果。
2. 令 func 爲以 "join" 做爲參數調用 array 的 [[Get]] 內部方法的結果。
3. 若是 IsCallable(func) 是 false, 則令 func 爲標準內置方法 Object.prototype.toString (15.2.4.2)。
4. 提供 array 做爲 this 值並以空參數列表調用 func 的 [[Call]] 內部方法，返回結果。

toString 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 toString 函數是依賴於實現的。

Array.prototype.toLocaleString ( )

先用數組元素的 toLocaleString 方法，將他們轉換成字符串。而後將這些字符串串聯，用一個分隔符分割，這裏的分隔符字符串是與特定語言環境相關，由實現定義的方式獲得的。調用這個函數的結果除了與特定語言環境關聯以外，與 toString 的結果相似。

結果是按照一下方式計算的：

1. 令 array 爲以 this 值做爲參數調用 ToObject 的結果。
2. 令 arrayLen 爲以 "length" 做爲參數調用 array 的 [[Get]] 內部方法的結果。
3. 令 len 爲 ToUint32(arrayLen)。
4. 令 separator 爲宿主環境的當前語言環境對應的列表分隔符字符串（這是實現定義的方式獲得的）。
5. 若是 len 是零 , 返回空字符串。
6. 令 firstElement 爲以 "0" 做爲參數調用 array 的 [[Get]] 內部方法的結果。
7. 若是 firstElement 是 undefined 或 null, 則
   1. 令 R 爲空字符串。
8. 不然
   1. 令 elementObj 爲 ToObject(firstElement).
   2. 令 func 爲以 "toLocaleString" 做爲參數調用 elementObj 的 [[Get]] 內部方法的結果。
   3. 若是 IsCallable(func) 是 false, 拋出一個 TypeError 異常。
   4. 令 R 爲提供 elementObj 做爲 this 值並以空參數列表調用 func 的 [[Call]] 內部方法的結果。
9. 令 k 爲 1。
10. 只要 k < len 就重複
    1. 令 S 爲串聯 R 和 separator 產生的字符串。
    2. 令 nextElement 爲以 ToString(k) 做爲參數調用 array 的 [[Get]] 內部方法的結果。
    3. 若是 nextElement 是 undefined 或 null, 則
       1. 令 R 爲空字符串。
    4. 不然
       1. 令 elementObj 爲 ToObject(nextElement).
       2. 令 func 爲以 "toLocaleString" 做爲參數調用 elementObj 的 [[Get]] 內部方法的結果。
       3. 若是 IsCallable(func) 是 false, 拋出一個 TypeError 異常。
       4. 令 R 爲提供 elementObj 做爲 this 值並以空參數列表調用 func 的 [[Call]] 內部方法的結果。
    5. 令 R 爲串聯 S 和 R 產生的字符串。
    6. k 遞增 1。
11. 返回 R

此函數的第一個參數可能會在本標準的將來版本中用到；建議實現不要以任何其餘用途使用這個參數位置。

toLocaleString 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 toLocaleString 函數是依賴於實現的。

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

當以零或更多個參數 item1, item2, 等等，調用 concat 方法，返回一個數組，這個數組包含對象的數組元素和後面跟着的每一個參數按照順序組成的數組元素。

採用以下步驟：

1. 令 O 爲以 this 值做爲參數調用 ToObject 的結果。
2. 令 A 爲彷彿是用表達式 new Array() 建立的新數組，這裏的 Array 是標準內置構造器名。
3. 令 n 爲 0。
4. 令 items 爲一個內部列表，他的第一個元素是 O，其後的元素是傳給這個函數調用的參數（以從左到右的順序）。
5. 只要 items 不是空就重複
   1. 刪除 items 的第一個元素，並令 E 爲這個元素值。
   2. 若是 E 的 [[Class]] 內部屬性是 "Array", 則
      1. 令 k 爲 0。
      2. 令 len 爲以 "length" 爲參數調用 E 的 [[Get]] 內部方法的結果。
      3. 只要 k < len 就重複
         1. 令 P 爲 ToString(k).
         2. 令 exists 爲以 P 做爲參數調用 E 的 [[HasProperty]] 內部方法的結果。
         3. 若是 exists 是 true, 則
            1. 令 subElement 爲以 P 做爲參數調用 E 的 [[Get]] 內部方法的結果。
            2. 以 ToString(n), 屬性描述符 {[[Value]]: subElement, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]] 內部方法。
         4. n 遞增 1.
         5. k 遞增 1.
   3. 不然 , E 不是數組
      1. 以 ToString(n), 屬性描述符 {[[Value]]: E, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]]</nowiki> 內部方法。
      2. n 遞增 1.
6. 返回 A.

concat 方法的 length 屬性是 1。

concat 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 concat 函數是依賴於實現的。

Array.prototype.join (separator)

數組元素先被轉換爲字符串，再將這些字符串用 separator 分割鏈接在一塊兒。若是沒提供分隔符，將一個逗號用做分隔符。

join 方法須要一個參數 separator, 執行如下步驟 :

1. 令 O 爲以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenVal 爲以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenVal).
4. 若是 separator 是 undefined, 令 separator 爲單字符字符串 ",".
5. 令 sep 爲 ToString(separator).
6. 若是 len 是零 , 返回空字符串 .
7. 令 element0 爲以 "0" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
8. 若是 element0 是 undefined 或 null, 令 R 爲空字符串 ; 不然 , 令 R 爲 ToString(element0).
9. 令 k 爲 1.
10. 只要 k < len 就重複
    1. 令 S 爲串聯 R 和 sep 產生的字符串值 .
    2. 令 element 爲以 ToString(k) 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
    3. 若是 element 是 undefined 或 null, 令 next 爲空字符串 ; 不然 , 令 next 爲 ToString(element).
    4. 令 R 爲串聯 S 和 next 產生的字符串值 .
    5. k 遞增 1.
11. 返回 R.

join 方法的 length 屬性是 1。

join 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 join 函數是依賴於實現的。

Array.prototype.pop ( )

刪除並返回數組的最後一個元素。

1. 令 O 爲以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenVal 爲以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenVal).
4. 若是 len 是零 ,
   1. 以 "length", 0, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
   2. 返回 undefined.
5. 不然 , len > 0
   1. 令 indx 爲 ToString(len–1).
   2. 令 element 爲 以 indx 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
   3. 以 indx 和 true 做爲參數調用 O 的 [[Delete]] 內部方法 .
   4. 以 "length", indx, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
   5. 返回 element.

pop 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 pop 函數是依賴於實現的。

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

將參數以他們出現的順序追加到數組末尾。數組的新 length 屬性值會做爲調用的結果返回。

當以零或更多個參數 item1,item2, 等等，調用 push 方法，採用如下步驟：

1. 令 O 爲以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenVal 爲以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 n 爲 ToUint32(lenVal).
4. 令 items 爲一個內部列表，它的元素是調用這個函數時傳入的參數（從左到右的順序）.
5. 只要 items 不是空就重複
   1. 刪除 items 的第一個元素，並令 E 爲這個元素的值 .
   2. 以 ToString(n), E, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
   3. n 遞增 1.
6. 以 "length", n, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
7. 返回 n.

push 方法的 length 屬性是 1。

push 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 push 函數是依賴於實現的。

Array.prototype.reverse ( )

從新排列數組元素，以翻轉它們的順序。對象會被當作調用的結果返回。

1. 令 O 爲以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenVal 爲以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenVal).
4. 令 middle 爲 floor(len/2).
5. 令 lower 爲 0.
6. 只要 lower ≠ middle 就重複
   1. 令 upper 爲 len−lower −1.
   2. 令 upperP 爲 ToString(upper).
   3. 令 lowerP 爲 ToString(lower).
   4. 令 lowerValue 爲以 lowerP 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
   5. 令 upperValue 爲以 upperP 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
   6. 令 lowerExists 爲以 lowerP 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   7. 令 upperExists 爲以 upperP 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   8. 若是 lowerExists 是 true 而且 upperExists 是 true, 則
      1. 以 lowerP, upperValue, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
      2. 以 upperP, lowerValue, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
   9. 不然若是 lowerExists 是 false 而且 upperExists 是 true, 則
      1. 以 lowerP, upperValue, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
      2. 以 upperP 和 true 做爲參數調用 O 的 [[Delete]] 內部方法 .
   10. 不然若是 lowerExists 是 true 而且 upperExists 是 false, 則
       1. 以 lowerP 和 true 做爲參數調用 O 的 [[Delete]] 內部方法 .
       2. 以 upperP, lowerValue, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
   11. 不然 , lowerExists 和 upperExists 都是 false
       1. 不須要作任何事情 .
   12. lower 遞增 1.
7. 返回 O .

reverse 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 reverse 函數是依賴於實現的。

Array.prototype.shift ( )

刪除並返回數組的第一個元素。

1. 令 O 爲以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenVal 爲以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenVal).
4. 若是 len 是零 , 則
   1. 以 "length", 0, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
   2. 返回 undefined.
5. 令 first 爲以 "0" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
6. 令 k 爲 1.
7. 只要 k < len 就重複
   1. 令 from 爲 ToString(k).
   2. 令 to 爲 ToString(k–1).
   3. 令 fromPresent 爲以 from 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   4. 若是 fromPresent 是 true, 則
      1. 令 fromVal 爲以 from 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      2. 以 to, fromVal, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
   5. 不然 , fromPresent 是 false
      1. 以 to 和 ture 做爲參數調用 O 的 [[Delete]] 內部方法 .
   6. k 遞增 1.
8. 以 ToString(len–1) 和 true 做爲參數調用 O 的 [[Delete]] 內部方法 .
9. 以 "length", (len–1) , 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
10. 返回 first.

shift 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 shift 函數是依賴於實現的。

Array.prototype.slice (start, end)

slice 方法須要 start 和 end 兩個參數，返回一個數組，這個數組包含從第 start 個元素到 -- 但不包括 -- 第 end 個元素 ( 或若是 end 是 undefined 就到數組末尾 )。若是 start 爲負，它會被當作是 length+start，這裏的 length 是數組長度。若是 end 爲負，它會被當作是 length+end，這裏的 length 是數組長度。採用以下步驟：

1. 令 O 爲以 this 值做爲參數調用 ToObject 的結果 .
2. 令 A 爲彷彿用表達式 new Array() 建立的新數組，這裏的 Array 是標準內置構造器名 .
3. 令 lenVal 爲以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
4. 令 len 爲 ToUint32(lenVal).
5. 令 relativeStart 爲 ToInteger(start).
6. 若是 relativeStart 爲負 , 令 k 爲 max((len +relativeStart),0); 不然令 k 爲 min(relativeStart,len).
7. 若是 end 是 undefined, 令 relativeEnd 爲 len; 不然令 relativeEnd 爲 ToInteger(end).
8. 若是 relativeEnd 爲負 , 令 final 爲 max((len + relativeEnd),0); 不然令 final 爲 min(relativeEnd,len).
9. 令 n 爲 0.
10. 只要 k < final 就重複
    1. 令 Pk 爲 ToString(k).
    2. 令 kPresent 爲 Pk 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
    3. 若是 kPresent 是 true, 則
       1. 令 kValue 爲以 Pk 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
       2. 以 ToString(n), 屬性描述符 {[[Value]]: kValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]] 內部方法 .
    4. k 遞增 1.
    5. n 遞增 1.
11. 返回 A.

slice 方法的 length 屬性是 2。

slice 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 slice 函數是依賴於實現的。

Array.prototype.sort (comparefn)

給 this 數組的元素 排序。排序不必定是穩定的（相等的元素們不必定按照他們原來的順序排列）。若是 comparefn 不是 undefined，它就必須是個函數，這個函數接受兩個參數 x 和 y，若是 x < y 返回一個負值，若是 x = y 返回零，若是 x > y 返回一個正值。

令 obj 爲以 this 值做爲參數調用 ToObject 的結果。

以 "length" 做爲參數調用 obj 的 [[Get]] 內部方法，將結果做爲參數調用 Uint32，令 len 爲返回的結果。

若是 comparefn 不是 undefined 而且不是對 this 數組的元素 保持一致的比較函數（見下面），那麼這種狀況下 sort 的行爲是實現定義的。

令 proto 爲 obj 的 [[Prototype]] 內部屬性。若是 proto 不是 null 而且存在一個整數 j 知足下面列出的所有條件，那麼這種狀況下 sort 的行爲是實現定義的：

• obj 是 稀疏的 (15.4)
• 0 ≤ j < len
• 以 ToString(j) 做爲參數調用 proto 的 [[HasProperty]] 內部方法的結果是 true

若是 obj 是 稀疏的 而且如下任何條件爲真，那麼這種狀況下 sort 的行爲是實現定義的：

• obj 的 [[Extensible]] 內部屬性是 false.
• 任何名爲小於 len 的非負整數的數組索引屬性中，有 [[Configurable]] 特性是 false 的數據屬性。

任何名爲小於 len 的非負整數的數組索引屬性中，有訪問器屬性，或有 [[Writable]] 特性是 false 的數據屬性，那麼這種狀況下 sort 的行爲是實現定義的。

不然，採用以下步驟。

1. 對 obj 的 [[Get]] , [[Put]], [[Delete]] 內部方法和 SortCompare（下面描述）執行一個依賴於實現的調用序列，這裏對每一個 [[Get]], [[Put]], 或 [[Delete]] 調用的第一個參數是小於 len 的非負整數 ，SortCompare 調用的參數是前面調用 [[Get]] 內部方法的結果。調用 [[Put]] 和 [[Delete]] 內部方法時，throw 參數是 true。若是 obj 不是 稀疏的 ，則必須不調用 [[Delete]]。
2. 返回 obj。

返回的對象必須擁有下面兩個性質。

• 必須有這樣的數學排列π，它是由比 len 小的非負整數組成 , 對於每一個比 len 小的非負整數 j, 若是屬性 old[j] 存在 , 則 new[π(j)] 有與 old[j] 相同的值，若是屬性 old[j] 不存在，則 new[π(j)] 也不存在。
• 對於都比 len 小的全部非負整數 j 和 k，若是 SortCompare(j,k) < 0 ( 見下面的 SortCompare), 則π(j) < π(k).

這裏的符號 old[j] 用來指：假定在執行這個函數以前以 j 做爲參數調用 obj 的 [[Get]] 內部方法的結果，符號 new[j] 用來指：假定在執行這個函數後以 j 做爲參數調用 obj 的 [[Get]] 內部方法的結果。

若是對於集合 S 裏的任何值 a，b，c（能夠是相同值），都知足如下全部條件，那麼函數 comparefn 是在集合 S 上保持一致的比較函數（如下，符號 a <_CF b 表示 comparefn(a,b) < 0；符號 a =_CF b 表示 comparefn(a,b) = 0（不論正負）； 符號 a >_CF b 表示 comparefn(a,b) > 0）：

• 當用指定值 a 和 b 做爲兩個參數調用 comparefn(a,b)，老是返回相同值 v。此外 Type(v) 是 Number, 而且 v 不是 NaN。注意，這意味着對於給定的 a 和 b，a <_CF b, a =_CF b, and a >_CF b 中正好有一個是真。
• 調用 comparefn(a,b) 不改變 this 對象。
• a =_CF a ( 自反性 )
• 若是 a =_CF b, 則 b =_CF a ( 對稱性 )
• 若是 a =_CF b 而且 b =_CF c, 則 a =_CF c (=_CF 傳遞 )
• 若是 a <_CF b 而且 b <_CF c, 則 a <_CF c (<_CF 傳遞 )
• 若是 a >_CF b 而且 b >_CF c, 則 a >_CF c (>_CF 傳遞 )

這些條件是確保 comparefn 劃分集合 S 爲等價類而且是徹底排序等價類的充分必要條件。

當用兩個參數 j 和 k 調用抽象操做 SortCompare，採用以下步驟：

1. 令 jString 爲 ToString(j).
2. 令 kString 爲 ToString(k).
3. 令 hasj 爲 以 jString 做爲參數調用 obj 的 [[HasProperty]] 內部方法的結果。
4. 令 hask 爲 以 kString 做爲參數調用 obj 的 [[HasProperty]] 內部方法的結果。
5. 若是 hasj 和 hask 都是 false, 則返回 +0.
6. 若是 hasj 是 false, 則返回 1.
7. 若是 hask 是 false, 則返回 –1.
8. 令 x 爲 以 jString 做爲參數調用 obj 的 [[Get]] 內部方法的結果。
9. 令 y 爲 以 kString 做爲參數調用 obj 的 [[Get]] 內部方法的結果。
10. 若是 x 和 y 都是 undefined, 返回 +0.
11. 若是 x 是 undefined, 返回 1.
12. 若是 y 是 undefined, 返回 −1.
13. 若是 參數 comparefn 不是 undefined, 則
    1. 若是 IsCallable(comparefn) 是 false, 拋出一個 TypeError 異常 .
    2. 傳入 undefined 做爲 this 值，以 x 和 y 做爲參數調用 comparefn 的 [[Call]] 內部方法，返回結果。
14. 令 xString 爲 ToString(x).
15. 令 yString 爲 ToString(y).
16. 若是 xString < yString, 返回 −1.
17. 若是 xString > yString, 返回 1.
18. 返回 +0.

由於不存在的屬性值老是比 undefined 屬性值大，而且 undefined 屬性值老是比任何其餘值大，因此 undefined 屬性值老是排在結果的末尾，後面跟着不存在屬性值。

sort 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 sort 函數是依賴於實現的。

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

當以兩個或更多參數 start, deleteCount 和 ( 可選的 ) item1, item2, 等等，調用 splice 方法，從數組索引 start 開始的 deleteCount 個數組元素會被替換爲參數 item1, item2, 等等。返回一個包含參數元素（若是有）的數組。採用如下步驟：

1. 令 O 爲 以 this 值做爲參數調用 ToObject 的結果 .
2. 令 A 爲 彷彿用表達式 new Array() 建立的新數組，這裏的 Array 是標準內置構造器名。
3. 令 lenVal 爲 以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
4. 令 len 爲 ToUint32(lenVal).
5. 令 relativeStart 爲 ToInteger(start).
6. 若是 relativeStart 爲負 , 令 actualStart 爲 max((len + relativeStart),0); 不然令 actualStart 爲 min(relativeStart, len).
7. 令 actualDeleteCount 爲 min(max(ToInteger(deleteCount),0),len – actualStart).
8. 令 k 爲 0.
9. 只要 k < actualDeleteCount 就重複
   1. 令 from 爲 ToString(actualStart+k).
   2. 令 fromPresent 爲 以 from 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果。
   3. 若是 fromPresent 是 true, 則
      1. 令 fromValue 爲 以 from 做爲參數調用 O 的 [[Get]] 內部方法的結果。
      2. 以 ToString(k), 屬性描述符 {[[Value]]: fromValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]] 內部方法。
   4. k 遞增 1.
10. 令 items 爲一個內部列表，它的元素是實際參數列表中 item1 開始的參數（從左到右的順序）。若是沒傳入這些項目，則列表是空的。
11. 令 itemCount 爲 items 的元素個數 .
12. 若是 itemCount < actualDeleteCount, 則
    1. 令 k 爲 actualStart.
    2. 只要 k < (len – actualDeleteCount) 就重複
       1. 令 from 爲 ToString(k+actualDeleteCount).
       2. 令 to 爲 ToString(k+itemCount).
       3. 令 fromPresent 爲 以 from 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
       4. 若是 fromPresent 是 true, 則
          1. 令 fromValue 爲 以 from 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
          2. 以 to, fromValue, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
       5. 不然 , fromPresent 是 false
          1. 以 to 和 true 做爲參數調用 O 的 [[Delete]] 內部方法 .
       6. k 遞增 1.
    3. 令 k 爲 len.
    4. 只要 k > (len – actualDeleteCount +itemCount) 就重複
       1. 以 ToString(k–1) 和 true 做爲參數調用 O 的 [[Delete]] 內部方法 .
       2. k 遞減 1.
13. 不然若是 itemCount > actualDeleteCount, 則
    1. 令 k 爲 (len – actualDeleteCount).
    2. 只要 k > actualStart 就重複
       1. 令 from 爲 ToString(k + actualDeleteCount – 1).
       2. 令 to 爲 ToString(k + itemCount – 1)
       3. 令 fromPresent 爲 以 from 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
       4. 若是 fromPresent 是 true, 則
          1. 令 fromValue 爲 以 from 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
          2. 以 to, fromValue, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
       5. 不然 , fromPresent 是 false
          1. 以 to 和 true 做爲參數調用 O 的 [[Delete]] 內部方法 .
       6. k 遞減 1.
14. 令 k 爲 actualStart.
15. 只要 items 不是空 就重複
    1. 刪除 items 的第一個元素 , 並令 E 爲這個元素值 .
    2. 以 ToString(k), E, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
    3. k 遞增 1.
16. 以 "length", (len – actualDeleteCount + itemCount), 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
17. 返回 A.

splice 方法的 length 屬性是 2。

splice 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 splice 函數是依賴於實現的。

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

將參數們插入到數組的開始位置，它們在數組中的順序與它們出如今參數列表中的順序相同。

當以零或更多個參數 item1,item2, 等等，調用 unshift 方法，採用以下步驟：

1. 令 O 爲 以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenVal 爲 以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenVal).
4. 令 argCount 爲 實際參數的個數 .
5. 令 k 爲 len.
6. 只要 k > 0, 就重複
   1. 令 from 爲 ToString(k–1).
   2. 令 to 爲 ToString(k+argCount –1).
   3. 令 fromPresent 爲 以 from 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   4. 若是 fromPresent 是 true, 則
      1. 令 fromValue 爲 以 from 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      2. 以 to, fromValue, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
   5. 不然 , fromPresent 是 false
      1. 以 to 和 true 做爲參數調用 O 的 [[Delete]] 內部方法 .
   6. k 遞減 1.
7. 令 j 爲 0.
8. 令 items 爲一個內部列表，它的元素是調用這個函數時傳入的實際參數（從左到右的順序）。
9. 只要 items 不是空，就重複
   1. 刪除 items 的第一個元素，並令 E 爲這個元素值 .
   2. 以 ToString(j), E, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
   3. j 遞增 1.
10. 以 "length", len+argCount, 和 true 做爲參數調用 O 的 [[Put]] 內部方法 .
11. 返回 len+argCount.

unshift 方法的 length 屬性是 1。

unshift 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 unshift 函數是依賴於實現的。

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

indexOf 按照索引的升序比較 searchElement 和數組裏的元素們，它使用內部的嚴格相等比較算法 (11.9.6)，若是找到一個或更多這樣的位置，返回這些位置中第一個索引；不然返回 -1。

可選的第二個參數 fromIndex 默認是 0（即搜索整個數組）。若是它大於或等於數組長度，返回 -1，即不會搜索數組。若是它是負的，就把它看成從數組末尾到計算後的 fromIndex 的偏移量。若是計算後的索引小於 0，就搜索整個數組。

當用一個或兩個參數調用 indexOf 方法 , 採用如下步驟 :

1. 令 O 爲 以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenValue 爲 以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenValue).
4. 若是 len 是 0, 返回 -1.
5. 若是 傳入了參數 fromIndex, 則令 n 爲 ToInteger(fromIndex); 不然令 n 爲 0.
6. 若是 n ≥ len, 返回 -1.
7. 若是 n ≥ 0, 則
   1. 令 k 爲 n.
8. 不然 , n<0
   1. 令 k 爲 len - abs(n).
   2. 若是 k 小於 0, 則令 k 爲 0.
9. 只要 k<len，就重複
   1. 令 kPresent 爲 以 ToString(k) 爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   2. 若是 kPresent 是 true, 則
      1. 令 elementK 爲 以 ToString(k) 爲參數調用 O 的 [[Get]] 內部方法的結果 .
      2. 令 same 爲 對 searchElement 和 elementK 執行嚴格相等比較算法的結果 .
      3. 若是 same 是 true, 返回 k.
   3. k 遞增 1.
10. 返回 -1.

indexOf 方法的 length 屬性是 1。

indexOf 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 indexOf 函數是依賴於實現的。

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

lastIndexOf 按照索引的降序比較 searchElement 和數組裏的元素們，它使用內部的嚴格相等比較算法 (11.9.6)，若是找到一個或更多這樣的位置，返回這些位置中最後一個索引；不然返回 -1。

可選的第二個參數 fromIndex 默認是數組的長度減一（即搜索整個數組）。若是它大於或等於數組長度，將會搜索整個數組。若是它是負的，就把它看成從數組末尾到計算後的 fromIndex 的偏移量。若是計算後的索引小於 0，返回 -1。

當用一個或兩個參數調用 lastIndexOf 方法，採用以下步驟 :

1. 令 O 爲 以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenValue 爲 以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenValue).
4. 若是 len is 0, 返回 -1.
5. 若是 傳入了參數 fromIndex, 則令 n 爲 ToInteger(fromIndex); 不然令 n 爲 len.
6. 若是 n ≥ 0, 則令 k 爲 min(n, len – 1).
7. 不然 , n < 0
   1. 令 k 爲 len - abs(n).
8. 只要 k≥ 0 就重複
   1. 令 kPresent 爲 以 ToString(k) 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   2. 若是 kPresent 是 true, 則
      1. 令 elementK 爲 以 ToString(k) 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      2. 令 same 爲 對 searchElement 和 elementK 執行嚴格相等比較算法的結果 .
      3. 若是 same 是 true, 返回 k.
   3. k 遞減 1.
9. 返回 -1.

lastIndexOf 方法的 length 屬性是 1。

lastIndexOf 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 lastIndexOf 函數是依賴於實現的。

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

callbackfn 應該是個函數，它接受三個參數並返回一個可轉換爲布爾值 true 和 false 的值。every 按照索引的升序，對數組裏存在的每一個元素調用一次 callbackfn，直到他找到一個使 callbackfn 返回 false 的元素。若是找到這樣的元素，every 立刻返回 false，不然若是對全部元素 callbackfn 都返回 true，every 將返回 true。callbackfn 只被數組裏實際存在的元素調用；它不會被缺乏的元素調用。

若是提供了一個 thisArg 參數，它會被看成 this 值傳給每一個 callbackfn 調用。若是沒提供它，用 undefined 替代。

調用 callbackfn 時將傳入三個參數：元素的值，元素的索引，和遍歷的對象。

對 every 的調用不直接更改對象，可是對 callbackfn 的調用可能更改對象。

every 處理的元素範圍是在首次調用 callbackfn 以前設定的。在 every 調用開始後追加到數組裏的元素們不會被 callbackfn 訪問。若是更改以存在數組元素，every 訪問這些元素時的值會傳給 callbackfn；在 every 調用開始後刪除的和以前被訪問過的元素們是不訪問的。every 的行爲就像數學量詞「全部（for all）」。特別的，對一個空數組，它返回 true。

當以一個或兩個參數調用 every 方法，採用如下步驟：

1. 令 O 爲 以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenValue 爲 以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenValue).
4. 若是 IsCallable(callbackfn) 是 false, 拋出一個 TypeError 異常 .
5. 若是提供了 thisArg, 令 T 爲 thisArg; 不然令 T 爲 undefined.
6. 令 k 爲 0.
7. 只要 k < len ，就重複
   1. 令 Pk 爲 ToString(k).
   2. 令 kPresent 爲 以 Pk 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   3. 若是 kPresent 是 true, 則
      1. 令 kValue 爲 以 Pk 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      2. 令 testResult 爲 以 T 做爲 this 值以包含 kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .
      3. 若是 ToBoolean(testResult) 是 false, 返回 false.
   4. k 遞增 1.
8. 返回 true.

every 方法的 length 屬性是 1。

every 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 every 函數是依賴於實現的。

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

callbackfn 應該是個函數，它接受三個參數並返回一個可轉換爲布爾值 true 和 false 的值。some 按照索引的升序，對數組裏存在的每一個元素調用一次 callbackfn，直到他找到一個使 callbackfn 返回 true 的元素。若是找到這樣的元素，some 立刻返回 true，不然，some 返回 false。callbackfn 只被實際存在的數組元素調用；它不會被缺乏的數組元素調用。

若是提供了一個 thisArg 參數，它會被看成 this 值傳給每一個 callbackfn 調用。若是沒提供它，用 undefined 替代。

調用 callbackfn 時將傳入三個參數：元素的值，元素的索引，和遍歷的對象。

對 some 的調用不直接更改對象，可是對 callbackfn 的調用可能更改對象。

some 處理的元素範圍是在首次調用 callbackfn 以前設定的。在 some 調用開始後追加到數組裏的元素們不會被 callbackfn 訪問。若是更改以存在數組元素，some 訪問這些元素時的值會傳給 callbackfn；在 some 調用開始後刪除的和以前被訪問過的元素們是不訪問的。some 的行爲就像數學量詞「存在（exists）」。特別的，對一個空數組，它返回 false。

當以一個或兩個參數調用 some 方法，採用如下步驟：

1. 令 O 爲 以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenValue 爲 以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenValue).
4. 若是 IsCallable(callbackfn) 是 false, 拋出一個 TypeError 異常 .
5. 若是提供了 thisArg, 令 T 爲 thisArg; 不然令 T 爲 undefined.
6. 令 k 爲 0.
7. 只要 k < len ，就重複
   1. 令 Pk 爲 ToString(k).
   2. 令 kPresent 爲 以 Pk 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   3. 若是 kPresent 是 true, 則
      1. 令 kValue 爲 以 Pk 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      2. 令 testResult 爲 以 T 做爲 this 值以包含 kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .
      3. 若是 ToBoolean(testResult) 是 true, 返回 true.
   4. k 遞增 1.
8. 返回 false.

some 方法的 length 屬性是 1。

some 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 some 函數是依賴於實現的。

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

callbackfn 應該是個函數，它接受三個參數。forEach 按照索引的升序，對數組裏存在的每一個元素調用一次 callbackfn。callbackfn 只被實際存在的數組元素調用；它不會被缺乏的數組元素調用。

若是提供了一個 thisArg 參數，它會被看成 this 值傳給每一個 callbackfn 調用。若是沒提供它，用 undefined 替代。

調用 callbackfn 時將傳入三個參數：元素的值，元素的索引，和遍歷的對象。

對 forEach 的調用不直接更改對象，可是對 callbackfn 的調用可能更改對象。

forEach 處理的元素範圍是在首次調用 callbackfn 以前設定的。在 forEach 調用開始後追加到數組裏的元素們不會被 callbackfn 訪問。若是更改以存在數組元素，forEach 訪問這些元素時的值會傳給 callbackfn；在 forEach 調用開始後刪除的和以前被訪問過的元素們是不訪問的。

當以一個或兩個參數調用 forEach 方法，採用如下步驟：

1. 令 O 爲 以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenValue 爲 以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenValue).
4. 若是 IsCallable(callbackfn) 是 false, 拋出一個 TypeError 異常 .
5. 若是提供了 thisArg, 令 T 爲 thisArg; 不然令 T 爲 undefined.
6. 令 k 爲 0.
7. 只要 k < len ，就重複
   1. 令 Pk 爲 ToString(k).
   2. 令 kPresent 爲 以 Pk 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   3. 若是 kPresent 是 true, 則
      1. 令 kValue 爲 以 Pk 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      2. 以 T 做爲 this 值以包含 kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法 .
   4. k 遞增 1.
8. 返回 undefined.

forEach 方法的 length 屬性是 1。

forEach 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 forEach 函數是依賴於實現的。

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

callbackfn 應該是個函數，它接受三個參數。map 按照索引的升序，對數組裏存在的每一個元素調用一次 callbackfn，並用結果構造一個新數組。callbackfn 只被實際存在的數組元素調用；它不會被缺乏的數組元素調用。

若是提供了一個 thisArg 參數，它會被看成 this 值傳給每一個 callbackfn 調用。若是沒提供它，用 undefined 替代。

調用 callbackfn 時將傳入三個參數：元素的值，元素的索引，和遍歷的對象。

對 map 的調用不直接更改對象，可是對 callbackfn 的調用可能更改對象。

map 處理的元素範圍是在首次調用 callbackfn 以前設定的。在 map 調用開始後追加到數組裏的元素們不會被 callbackfn 訪問。若是更改以存在數組元素，map 訪問這些元素時的值會傳給 callbackfn；在 map 調用開始後刪除的和以前被訪問過的元素們是不訪問的。

當以一個或兩個參數調用 map 方法，採用如下步驟：

1. 令 O 爲 以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenValue 爲 以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenValue).
4. 若是 IsCallable(callbackfn) 是 false, 拋出一個 TypeError 異常 .
5. 若是提供了 thisArg, 令 T 爲 thisArg; 不然令 T 爲 undefined.
6. 令 A 爲 彷彿用 new Array( len) 建立的新數組，這裏的 Array 是標準內置構造器名，len 是 len 的值。
7. 令 k 爲 0.
8. 只要 k < len ，就重複
   1. 令 Pk 爲 ToString(k).
   2. 令 kPresent 爲 以 Pk 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   3. 若是 kPresent 是 true, 則
      1. 令 kValue 爲 以 Pk 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      2. 令 mappedValue 爲 以 T 做爲 this 值以包含 kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .
      3. 以 Pk, 屬性描述符 {[[Value]]: mappedValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]] 內部方法 .
   4. k 遞增 1.
9. 返回 A.

map 方法的 length 屬性是 1。

map 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 map 函數是依賴於實現的。

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

callbackfn 應該是個函數，它接受三個參數並返回一個可轉換爲布爾值 true 和 false 的值。filter 按照索引的升序，對數組裏存在的每一個元素調用一次 callbackfn，並用使 callbackfn 返回 true 的全部值構造一個新數組。callbackfn 只被實際存在的數組元素調用；它不會被缺乏的數組元素調用。

若是提供了一個 thisArg 參數，它會被看成 this 值傳給每一個 callbackfn 調用。若是沒提供它，用 undefined 替代。

調用 callbackfn 時將傳入三個參數：元素的值，元素的索引，和遍歷的對象。

對 filter 的調用不直接更改對象，可是對 callbackfn 的調用可能更改對象。

filter 處理的元素範圍是在首次調用 callbackfn 以前設定的。在 filter 調用開始後追加到數組裏的元素們不會被 callbackfn 訪問。若是更改以存在數組元素，filter 訪問這些元素時的值會傳給 callbackfn；在 filter 調用開始後刪除的和以前被訪問過的元素們是不訪問的。

當以一個或兩個參數調用 filter 方法，採用如下步驟：

1. 令 O 爲 以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenValue 爲 以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenValue).
4. 若是 IsCallable(callbackfn) 是 false, 拋出一個 TypeError 異常 .
5. 若是提供了 thisArg, 令 T 爲 thisArg; 不然令 T 爲 undefined.
6. 令 A 爲 彷彿用 new Array( len) 建立的新數組，這裏的 Array 是標準內置構造器名，len 是 len 的值。
7. 令 k 爲 0.
8. 令 to 爲 0.
9. 只要 k < len ，就重複
   1. 令 Pk 爲 ToString(k).
   2. 令 kPresent 爲 以 Pk 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   3. 若是 kPresent 是 true, 則
      1. 令 kValue 爲 以 Pk 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      2. 令 selected 爲 以 T 做爲 this 值以包含 kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .
      3. 若是 ToBoolean(selected) 是 true, 則
         1. 以 ToString(to), 屬性描述符 {[[Value]]: kValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]] 內部方法 .
         2. to 遞增 1.
   4. k 遞增 1.
10. 返回 A.

filter 方法的 length 屬性是 1。

filter 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 filter 函數是依賴於實現的。

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

callbackfn 應該是個函數，它須要四個參數。reduce 按照索引的升序，對數組裏存在的每一個元素 , 將 callbackfn 做爲回調函數調用一次。

調用 callbackfn 時將傳入四個參數：previousValue（initialValue 的值或上次調用 callbackfn 的返回值），currentValue（當前元素值），currentIndex，和遍歷的對象。第一次調用回調函數時，previousValue 和 currentValue 的取值能夠是下面兩種狀況之一。若是爲 reduce 調用提供了一個 initialValue，則 previousValue 將等於 initialValue 而且 currentValue 將等於數組的首個元素值。若是沒提供 initialValue，則 previousValue 將等於數組的首個元素值而且 currentValue 將等於數組的第二個元素值。若是數組裏沒有元素而且沒有提供 initialValue，則拋出一個 TypeError 異常。

對 reduce 的調用不直接更改對象，可是對 callbackfn 的調用可能更改對象。

reduce 處理的元素範圍是在首次調用 callbackfn 以前設定的。在 reduce 調用開始後追加到數組裏的元素們不會被 callbackfn 訪問。若是更改以存在數組元素，reduce 訪問這些元素時的值會傳給 callbackfn；在 reduce 調用開始後刪除的和以前被訪問過的元素們是不訪問的。

當以一個或兩個參數調用 reduce 方法，採用如下步驟：

1. 令 O 爲 以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenValue 爲 以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenValue ).
4. 若是 IsCallable(callbackfn) 是 false, 拋出一個 TypeError 異常 .
5. 若是 len 是 0 而且 initialValue 不是 present, 拋出一個 TypeError 異常 .
6. 令 k 爲 0.
7. 若是 initialValue 參數有傳入值 , 則
   1. 設定 accumulator 爲 initialValue.
8. 不然 , initialValue 參數沒有傳入值
   1. 令 kPresent 爲 false.
   2. 只要 kPresent 是 false 而且 k < len ，就重複
      1. 令 Pk 爲 ToString(k).
      2. 令 kPresent 爲 以 Pk 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
      3. 若是 kPresent 是 true, 則
         1. 令 accumulator 爲 以 Pk 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      4. k 遞增 1.
   3. 若是 kPresent 是 false, 拋出一個 TypeError 異常 .
9. 只要 k < len ，就重複
   1. 令 Pk 爲 ToString(k).
   2. 令 kPresent 爲 以 Pk 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   3. 若是 kPresent 是 true, 則
      1. 令 kValue 爲 以 Pk 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      2. 令 accumulator 爲 以 undefined 做爲 this 值並以包含 accumulator, kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .
   4. k 遞增 1.
10. 返回 accumulator.

reduce 方法的 length 屬性是 1。

reduce 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 reduce 函數是依賴於實現的。

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

callbackfn 應該是個函數，它須要四個參數。reduceRight 按照索引的升序，對數組裏存在的每一個元素 , 將 callbackfn 做爲回調函數調用一次。

調用 callbackfn 時將傳入四個參數：previousValue（initialValue 的值或上次調用 callbackfn 的返回值），currentValue（當前元素值），currentIndex，和遍歷的對象。第一次調用回調函數時，previousValue 和 currentValue 的取值能夠是下面兩種狀況之一。若是爲 reduceRight 調用提供了一個 initialValue，則 previousValue 將等於 initialValue 而且 currentValue 將等於數組的最後一個元素值。若是沒提供 initialValue，則 previousValue 將等於數組的最後一個元素值而且 currentValue 將等於數組的倒數第二個元素值。若是數組裏沒有元素而且沒有提供 initialValue，則拋出一個 TypeError 異常。

對 reduceRight 的調用不直接更改對象，可是對 callbackfn 的調用可能更改對象。

reduceRight 處理的元素範圍是在首次調用 callbackfn 以前設定的。在 reduceRight 調用開始後追加到數組裏的元素們不會被 callbackfn 訪問。若是更改以存在數組元素，reduceRight 訪問這些元素時的值會傳給 callbackfn；在 reduceRight 調用開始後刪除的和以前被訪問過的元素們是不訪問的。

當以一個或兩個參數調用 reduceRight 方法，採用如下步驟：

1. 令 O 爲 以 this 值做爲參數調用 ToObject 的結果 .
2. 令 lenValue 爲 以 "length" 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
3. 令 len 爲 ToUint32(lenValue ).
4. 若是 IsCallable(callbackfn) 是 false, 拋出一個 TypeError 異常 .
5. 若是 len 是 0 而且 initialValue 不是 present, 拋出一個 TypeError 異常 .
6. 令 k 爲 0.
7. 若是 initialValue 參數有傳入值 , 則
   1. 設定 accumulator 爲 initialValue.
8. 不然 , initialValue 參數沒有傳入值
   1. 令 kPresent 爲 false.
   2. 只要 kPresent 是 false 而且 k ≥ 0 ，就重複
      1. 令 Pk 爲 ToString(k).
      2. 令 kPresent 爲 以 Pk 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
      3. 若是 kPresent 是 true, 則
         1. 令 accumulator 爲 以 Pk 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      4. k 遞減 1.
   3. 若是 kPresent 是 false, 拋出一個 TypeError 異常 .
9. 只要 k ≥ 0 ，就重複
   1. 令 Pk 爲 ToString(k).
   2. 令 kPresent 爲 以 Pk 做爲參數調用 O 的 [[HasProperty]] 內部方法的結果 .
   3. 若是 kPresent 是 true, 則
      1. 令 kValue 爲 以 Pk 做爲參數調用 O 的 [[Get]] 內部方法的結果 .
      2. 令 accumulator 爲 以 undefined 做爲 this 值並以包含 accumulator, kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .
   4. k 遞減 1.
10. 返回 accumulator.

reduceRight 方法的 length 屬性是 1。

reduceRight 函數被有意設計成通用的；它的 this 值並不是必須是數組對象。所以，它能夠做爲方法轉移到其餘類型的對象中。一個宿主對象是否能夠正確應用這個 reduceRight 函數是依賴於實現的。

Array 實例的屬性

Array 實例從數組原型對象繼承屬性，Array 實例的 [[Class]] 內部屬性是 "Array"。Array 實例還有如下屬性。

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

數組對象使用一個，用在其餘原生 ECMAscript 對象的 [[DefineOwnProperty]] 內部方法 (8.12.9) 的變化版。

設 A 爲一個數組對象，Desc 爲一個屬性描述符，Throw 爲一個布爾標示。

在如下算法中，術語「拒絕」指代「若是 Throw 是 true，則拋出 TypeError 異常，不然返回 false。

當用屬性名 P，屬性描述 Desc，布爾值 Throw 調用 A 的 [[DefineOwnProperty]] 內部方法，採用如下步驟：

1. 令 oldLenDesc 爲 以 "length" 做爲參數調用 A 的 [[GetOwnProperty]] 內部方法的結果。 結果毫不會是 undefined 或一個訪問器描述符，由於在建立數組時的 length 是一個不可刪除或從新配置的數據屬性。
2. 令 oldLen 爲 oldLenDesc.[[Value]].
3. 若是 P 是 "length", 則
   1. 若是 Desc 的 [[Value]] 字段不存在 , 則
      1. 以 "length", Desc, 和 Throw 做爲參數在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9)，返回結果。
   2. 令 newLenDesc 爲 Desc 的一個拷貝 .
   3. 令 newLen 爲 ToUint32(Desc.[[Value]]).
   4. 若是 newLen 不等於 ToNumber( Desc.[[Value]]), 拋出一個 RangeError 異常 .
   5. 設定 newLenDesc.[[Value]] 爲 newLen.
   6. 若是 newLen ≥oldLen, 則
      1. 以 "length", newLenDesc, 和 Throw 做爲參數在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9)，返回結果。
   7. 若是 oldLenDesc.[[Writable]] 是 false，拒絕
   8. 若是 newLenDesc.[[Writable]] 不存在或值是 true, 令 newWritable 爲 true.
   9. 不然 ,
      1. 由於它將使得沒法刪除任何元素，因此須要延後設定 [[Writable]] 特性爲 false.
      2. 令 newWritable 爲 false.
      3. 設定 newLenDesc.[[Writable]] 爲 true.
   10. 令 succeeded 爲 以 "length", newLenDesc, 和 Throw 做爲參數在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9) 的結果
   11. 若是 succeeded 是 false, 返回 false..
   12. 只要 newLen < oldLen，就重複 ,
       1. 設定 oldLen 爲 oldLen – 1.
       2. 令 deleteSucceeded 爲 以 ToString(oldLen) 和 false 做爲參數調用 A 的 [[Delete]] 內部方法的結果 .
       3. 若是 deleteSucceeded 是 false, 則
          1. 設定 newLenDesc.[[Value]] 爲 oldLen+1.
          2. 若是 newWritable 是 false, 設定 newLenDesc.[[Writable]] 爲 false.
          3. 以 "length", newLenDesc, 和 false 爲參數在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9).
          4. 拒絕 .
   13. 若是 newWritable 是 false, 則
       1. 以 "length", 屬性描述符 {[[Writable]]: false}, 和 false 做爲參數在 A 上調用 [[DefineOwnProperty]] 內部方法 (8.12.9). 這個調用始終返回 true.
   14. 返回 true.
4. 不然若是 P 是一個數組索引 (15.4), 則
   1. 令 index 爲 ToUint32(P).
   2. 若是 index ≥ oldLen 而且 oldLenDesc.[[Writable]] 是 false，拒絕 .
   3. 令 succeeded 爲 以 P, Desc, 和 false 做爲參數在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9) 的結果 .
   4. 若是 succeeded 是 false，拒絕 .
   5. 若是 index ≥ oldLen
      1. 設定 oldLenDesc.[[Value]] 爲 index + 1.
      2. 以 "length", oldLenDesc, 和 false 做爲參數在在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9). 這個調用始終返回 true.
   6. 返回 true.
5. 以 P, Desc, 和 Throw 做爲參數在在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9)，返回結果 .

length

數組對象的 length 屬性是個數據屬性，其值老是在數值上大於任何屬性名是數組索引的可刪除屬性的屬性名。

length 屬性擁有的初始特性是 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.

試圖將一個數組對象的 length 屬性設定爲在數值上比 -- 數組中存在數組索引而且是不可參數屬性中的最大數字屬性名 -- 小或相等時，length 將設定爲比那個最大數字屬性名大一的數字子。見 15.4.5.1。

String 對象

做爲函數調用 String 構造器

當將 String 做爲函數調用，而不是做爲構造器，它執行一個類型轉換。

String ( [ value ] )

返回一個由 ToString(value) 計算出的字符串值（不是 String 對象）。若是沒有提供 value，返回空字符串 ""。

String 構造器

當 String 做爲一個 new 表達式的一部分被調用，它是個構造器：它初始化新建立的對象。

new String ( [ value ] )

新構造對象的 [[Prototype]] 內部屬性設定爲標準內置的字符串原型對象，它是 String.prototype 的初始值 (15.5.3.1)。

新構造對象的 [[Class]] 內部屬性設定爲 "String"。

新構造對象的 [[Extensible]] 內部屬性設定爲 true。

新構造對象的 [[PrimitiveValue]] 內部屬性設定爲 ToString(value)，或若是沒提供 value 則設定爲空字符串。

String 構造器的屬性

String 構造器的 [[Prototype]] 內部屬性的值是標準內置的函數原型對象 (15.3.4).

除了內部屬性和 length 屬性（值爲 1）以外，String 構造器還有如下屬性：

String.prototype

String.prototype 的初始值是標準內置的字符串原型對象 (15.5.4)。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

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

返回一個字符串值，包含的字符數與參數數目相同。每一個參數指定返回字符串中的一個字符，也就是說第一個參數第一個字符，以此類推（從左到右）。一個參數轉換爲一個字符，經過先應用 ToUint16 (9.7) 操做，再將返回的 16 位整數看做字符的代碼單元值。若是沒提供參數，返回空字符串。

fromCharCode 函數的 length 屬性是 1。

字符串原型對象的屬性

字符串原型對象自己是一個值爲空字符串的 String 對象（它的 [[Class]] 是 "String"）。

字符串原型對象的 [[Prototype]] 內部屬性值是標準內置的 Object 原型對象 (15.2.4)。

String.prototype.constructor

String.prototype.constructor 的初始值是內置 String 構造器。

String.prototype.toString ( )

返回 this 字符串值。（注，對於一個 String 對象，toString 方法和 valueOf 方法返回相同值。）

toString 函數是非通用的 ; 若是它的 this 值不是一個字符串或字符串對象，則拋出一個 TypeError 異常。所以它不能做爲方法轉移到其餘類型對象上。

String.prototype.valueOf ( )

返回 this 字符串值。

valueOf 函數是非通用的 ; 若是它的 this 值不是一個字符串或字符串對象，則拋出一個 TypeError 異常。所以它不能做爲方法轉移到其餘類型對象上。

String.prototype.charAt (pos)

將 this 對象轉換爲一個字符串，返回包含了這個字符串 pos 位置的字符的字符串。若是那個位置沒有字符，返回空字符串。返回結果是個字符串值，不是字符串對象。

若是 pos 是一個數字類型的整數值，則 x.charAt( pos) 與 x.substring( pos, pos+1) 的結果相等。

當用一個參數 pos 調用 charAt 方法，採用如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 令 position 爲 ToInteger(pos).
4. 令 size 爲 S 的字符數 .
5. 若是 position < 0 或 position ≥ size, 返回空字符串 .
6. 返回一個長度爲 1 的字符串 , 它包含 S 中 position 位置的一個字符 , 在這裏 S 中的第一個（最左邊）字符被看成是在位置 0，下一個字符被看成是在位置 1，等等 .

charAt 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.charCodeAt (pos)

將 this 對象轉換爲一個字符串，返回一個表明這個字符串 pos 位置字符的代碼單元值的數字（小於 2¹⁶ 的非負整數）。若是那個位置沒有字符，返回 NaN。

當用一個參數 pos 調用 charCodeAt 方法，採用如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 令 position 爲 ToInteger(pos).
4. 令 size 爲 S 的字符數 .
5. 若是 position < 0 或 position ≥ size, 返回 NaN.
6. 返回一個數字類型值，值是字符串 S 中 position 位置字符的代碼單元值。 在這裏 S 中的第一個（最左邊）字符被看成是在位置 0，下一個字符被看成是在位置 1，等等 .

charCodeAt 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

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

當用一個或更多參數 string1, string2, 等等 , 調用 concat 方法 , 它返回一個包含了 --this 對象（轉換爲一個字符串）中的字符們和後面跟着的每一個 string1, string2, 等等，（每一個參數都轉換爲字符串）裏的字符們 -- 的字符串。返回結果是一個字符串值，不是一個字符串對象。採用如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 令 args 爲一個內部列表，它是傳給這個函數的參數列表的拷貝 .
4. 令 R 爲 S.
5. 只要 args 不是空，就重複
   1. 刪除 args 的第一個元素，並令 next 爲這個元素 .
   2. 令 R 爲包含了 -- 以前的 R 值中的字符們和後面跟着的 ToString(next) 結果的字符們 -- 的字符串值。
6. 返回 R.

concat 方法的 length 屬性是 1.

concat 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.indexOf (searchString, position)

將 this 對象轉換爲一個字符串，若是 searchString 在這個字符串裏大於或等於 position 的位置中的一個或多個位置使它呈現爲字符串的子串，那麼返回這些位置中最小的索引；不然返回 -1。若是 position 是 undefined，就認爲它是 0，以搜索整個字符串。

indexOf 須要兩個參數 searchString 和 position，執行如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 令 searchStr 爲 ToString(searchString).
4. 令 pos 爲 ToInteger(position). ( 若是 position 是 undefined, 此步驟產生 0).
5. 令 len 爲 S 的字符數 .
6. 令 start 爲 min(max(pos, 0), len).
7. 令 searchLen 爲 SearchStr 的字符數 .
8. 返回 一個不小於 start 的可能的最小值整數 k，使得 k+searchLen 不大於 len，而且對全部小於 searchLen 的非負數整數 j，S 的 k+j 位置字符和 searchStr 的 j 位置字符相同；但若是沒有這樣的整數 k，則返回 -1。

indexOf 的 length 屬性是 1。

indexOf 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.lastIndexOf (searchString, position)

將 this 對象轉換爲一個字符串，若是 searchString 在這個字符串裏小於或等於 position 的位置中的一個或多個位置使它呈現爲字符串的子串，那麼返回這些位置中最大的索引；不然返回 -1。若是 position 是 undefined，就認爲它是字符串值的長度，以搜索整個字符串。

lastIndexOf 須要兩個參數 searchString 和 position，執行如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 令 searchStr 爲 ToString(searchString).
4. 令 numPos 爲 Tonumber(position). ( 若是 position 是 undefined, 此步驟產生 NaN).
5. 若是 numPos 是 NaN, 令 pos 爲 +∞; 不然 , 令 pos 爲 ToInteger(numPos).
6. 令 len 爲 S 的字符數 .
7. 令 start 爲 min(max(pos, 0), len).
8. 令 searchLen 爲 SearchStr 的字符數 .
9. 返回 一個不大於 start 的可能的最大值整數 k，使得 k+searchLen 不大於 len，而且對全部小於 searchLen 的非負數整數 j，S 的 k+j 位置字符和 searchStr 的 j 位置字符相同；但若是沒有這樣的整數 k，則返回 -1。

lastIndexOf 的 length 屬性是 1。

lastIndexOf 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.localeCompare (that)

當以一個參數 that 來調用 localeCompare 方法，它返回一個非 NaN 數字值，這個數字值反應了對 this 值（轉換爲字符串）和 that 值（轉換爲字符串）進行語言環境敏感的字符串比較的結果。兩個字符串 S 和 That 用實現定義的一種方式進行比較。比較結果是爲了按照系統默認語言環境指定的排列順序來排列字符串，根據按照排列順序 S 是在 That 前面，相同，仍是 S 在 That 後面，結果分別是負數，零，正數。

在執行比較以前執行如下步驟以預備好字符串：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 令 That 爲 ToString(that).

若是將 localeCompare 方法看作是將 this 和 that 做爲兩個參數的函數，那麼它是在全部字符串集合上的保持一致的比較函數（在 15.4.4.11 定義）。

實際返回值是實現定義的，容許實現者們在返回值裏編碼附加信息。可是函數須要定義一個在全部字符串上的總的順序，而且，當比較的字符串們被認爲是 Unicode 標準定義的標準等價，則返回 0。

若是宿主環境沒有在全部字符串上語言敏感的比較，此函數可執行按位比較。

localeCompare 方法自身不適合直接做爲 Array.prototype.sort 的參數，由於後者須要的是兩個參數的函數。

這個函數的目的是在宿主環境中任何依靠語言敏感的比較方式均可用於 ECMAScript 環境，並根據宿主環境當前語言環境設置的規則進行比較。強烈建議這個函數將 -- 根據 Unicode 標準的標準等價的 -- 字符串當作是相同的（也就是說，要比較的字符串彷彿是都先被轉換爲正常化形式 C 或正常化形式 D 了）。還建議這個函數不履行 Unicode 相容等價或分解。

本標準的將來版本可能會使用這個函數的第二個參數；建議實現不將這個參數位用做其餘用途。

localeCompare 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.match (regexp)

當以 regexp 做爲參數調用 match 方法，採用如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 若是 Type(regexp) 是 Object 而且 regexp 的 [[Class]] 內部屬性的值是 "RegExp", 則令 rx 爲 regexp;
4. 不然 , 令 rx 爲 彷彿是用表達式 new RegExp( regexp) 建立的新正則對象，這裏的 RegExp 是標準內置構造器名。
5. 令 global 爲 以 "global" 爲參數調用 rx 的 [[Get]] 內部方法的結果 .
6. 令 exec 爲 標準內置函數 RegExp.prototype.exec ( 見 15.10.6.2)
7. 若是 global 不是 true, 則
   1. 以 rx 做爲 this 值，用包含 S 的參數列表調用 exec 的 [[Call]] 內部方法，返回結果。
8. 不然 , global 是 true
   1. 以 "lastIndex" 和 0 做爲參數調用 rx 的 [[Put]] 內部方法。
   2. 令 A 爲 彷彿是用表達式 new Array() 建立的新數組，這裏的 Array 是標準內置構造器名 .
   3. 令 previousLastIndex 爲 0.
   4. 令 n 爲 0.
   5. 令 lastMatch 爲 true.
   6. 只要 lastMatch 是 true，就重複
      1. 令 result 爲 以 rx 做爲 this 值，用包含 S 的參數列表調用 exec 的 [[Call]] 內部方法的結果。
      2. 若是 result 是 null, 則設定 lastMatch 爲 false.
      3. 不然 , result 不是 null
         1. 令 thisIndex 爲 以 "lastIndex" 爲參數調用 rx 的 [[Get]] 內部方法的結果。
         2. 若是 thisIndex = previousLastIndex 則
            1. 以 "lastIndex" 和 thisIndex+1 爲參數調用 rx 的 [[Put]] 內部方法。
            2. 設定 previousLastIndex 爲 thisIndex+1.
         3. 不然 , 設定 previousLastIndex 爲 thisIndex.
         4. 令 matchStr 爲 以 0 爲參數調用 result 的 [[Get]] 內部方法的結果。
         5. 以 ToString(n), 屬性描述符 {[[Value]]: matchStr, [[Writable]]: true, [[Enumerable]]: true, [[configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]] 內部方法。
         6. n 遞增 1.
   7. 若是 n = 0, 則返回 null.
   8. 返回 A.

match 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.replace (searchValue, replaceValue)

首先根據如下步驟設定 string：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 string 爲 以 this 值做爲爲參數調用 ToString 的結果。

若是 searchValue 是一個正則表達式（[[Class]] 內部屬性是 "RegExp" 的對象），按照以下執行：若是 searchValue.global 是 false，則搜索 string，找出匹配正則表達式 searchValue 的第一個子字符串。若是 searchValue.global 是 true，則搜索 string，找出匹配正則表達式 searchValue 的全部子字符串。搜索的作法與 String.prototype.match 相同，包括對 searchValue.lastIndex 的更新。令 m 爲 searchValue 的左捕獲括號的個數（使用 15.10.2.1 指定的 NcapturingParens）。

若是 searchValue 不是正則表達式，令 searchString 爲 ToString(searchValue)，並搜索 string，找出第一個出現的 searchString 的子字符串。令 m 爲 0。

若是 replaceValue 是函數，則對每一個匹配的子字符串，以 m + 3 個參數調用這個函數。第一個參數是匹配的子字符串。若是 searchValue 是正則表達式，接下來 m 個參數是 MatchResult（見 15.10.2.1）裏的全部捕獲值。第 m + 2 個參數是發生的匹配在 string 裏的偏移量，第 m + 3 個參數是 string。結果是將輸入的原字符串裏的每一個匹配子字符串替換爲相應函數調用的返回值（必要的狀況下轉換爲字符串）獲得的字符串。

不然，令 newstring 表示 replaceValue 轉換爲字符串的結果。結果是將輸入的原字符串裏的每一個匹配子字符串替換爲 -- 將 newstring 裏的字符替換爲表 22 指定的替代文本獲得的字符串 -- 獲得的字符串。替換這些 $ 是由左到右進行的，而且一旦執行了這樣的替換，新替換的文本不受進一步替換。例如 ，"$1,$2".replace(/(\$(\d))/g, "$$1-$1$2") 返回 "$1-$11,$1-$22"。newstring 裏的一個 $ ，若是不符合如下任何格式，就保持原狀。

替代文本符號替換

字符編碼值	表示
字符	替代文本
$$	$
$&	匹配到的子字符串
$`( 譯註：'\u0060')	string 中匹配到的子字符串以前部分。
$'( 譯註：'\u0027')	string 中匹配到的子字符串以後部分。
$n	第 n 個捕獲結果，n 是範圍在 1 到 9 的單個數字，而且緊接着 $n 後面的不是十進制數字。若是 n≤m 且第 n 個捕獲結果是 undefined，就用空字符串代替。若是 n>m，結果是實現定義的。
$nn	第 nn 個捕獲結果，nn 是範圍在 01 到 99 的十進制兩位數。若是 nn≤m 且第 nn 個捕獲結果是 undefined，就用空字符串代替。若是 nn>m，結果是實現定義的。

replace 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.search (regexp)

當用參數 regexp 調用 search 方法，採用如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 string 爲 以 this 值做爲參數調用 ToString 的結果。
3. 若是 Type(regexp) 是 Object 且 regexp 的 [[Class]] 內部屬性的值是 "RegExp", 則令 rx 爲 regexp;
4. 不然 , 令 rx 爲彷彿是用表達式 new RegExp( regexp) 建立的新正則對象，這裏的 RegExp 是標準內置構造器名。
5. 從 string 開始位置搜索正則表達式模式 rx 的匹配。若是找到匹配，令 result 爲匹配在 string 裏的偏移量；若是沒有找到匹配，令 result 爲 -1。執行搜索時 regexp 的 lastIndex 和 global 屬性是被忽略的。regexp 的 lastIndex 屬性保持不變。
6. 返回 result.

search 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.slice (start, end)

slice 方法須要兩個參數 start 和 end，將 this 對象轉換爲一個字符串，返回這個字符串中從 start 位置的字符到（但不包含）end 位置的字符的一個子字符串（或若是 end 是 undefined，就直接到字符串尾部）。用 sourceLength 表示字符串長度，若是 start 是負數，就把它看作是 sourceLength+start；若是 end 是負數，就把它看作是 sourceLength+end。返回結果是一個字符串值，不是字符串對象。採用如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 令 len 爲 S 的字符數 .
4. 令 intStart 爲 ToInteger(start).
5. 若是 end 是 undefined, 令 intEnd 爲 len; 不然 令 intEnd 爲 ToInteger(end).
6. 若是 intStart 是 negative, 令 from 爲 max(len + intStart,0); 不然 令 from 爲 min(intStart,len).
7. 若是 intEnd 是 negative, 令 to 爲 max(len +intEnd,0); 不然 令 to 爲 min(intEnd, len).
8. 令 span 爲 max(to – from,0).
9. 返回 一個包含 --S 中從 form 位置的字符開始的 span 個連續字符 -- 的字符串。

slice 方法的 length 屬性是 2。

slice 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.split (separator, limit)

將 this 字符串轉換爲一個字符串，返回一個數組對象，裏面存儲了這個字符串的子字符串。子字符串是從左到右搜索 separator 的匹配來肯定的；這些匹配結果不成爲返回數組的任何子字符串元素，但被用來分割字符串。separator 的值能夠是一個任意長度的字符串，也能夠是一個正則對象（即，一個 [[Class]] 內部屬性爲 "RegExp" 的對象；見 15.10）。

separator 值能夠是一個空字符串，一個空正則表達式，或一個可匹配空字符串的正則表達式。這種狀況下，separator 不匹配輸入字符串開頭和末尾的空的子串，也不匹配分隔符的以前匹配結果末尾的空字串。（例如，若是 separator 是空字符串，要將字符串分割爲單個字符們；結果數組的長度等於字符串長度，且每一個字串都包含一個字符。）若是 separator 是正則表達式，在 this 字符串的給定位置中只考慮首次匹配結果，即便若是在這個位置上回溯可產生一個非空的子串。（例如，"ab".split(/a*?/) 的執行結果是數組 ["a","b"]，而 "ab".split(/a*/) 的執行結果是數組 ["","b"] 。）

若是 this 對象是（或轉換成）空字符串，返回的結果取決於 separator 是否可匹配空字符串。若是能夠，結果是不包含任何元素的數組。不然，結果是包含一個空字符串元素的數組。

若是 separator 是包含捕獲括號的正則表達式，則對 separator 的每次匹配，捕獲括號的結果 ( 包括 undefined) 都拼接爲輸出數組。例如，

"Aboldandcoded".split(/<(\/)?([^<>]+)>/)

執行結果是數組：

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

若是 separator 是 undefined，則返回結果是隻包含 this 值（轉換爲字符串）一個字符串元素的數組。若是 limit 不是 undefined，則輸出數組被切斷爲包含不大於 limit 個元素。

當調用 split 方法，採用如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 令 A 爲 彷彿使用表達式 new Array() 建立的新對象，這裏的 Array 是標準內置構造器名 .
4. 令 lengthA 爲 0.
5. 若是 limit 是 undefined, 令 lim = 2³²–1; 不然 令 lim = ToUint32(limit).
6. 令 s 爲 S 的字符數 .
7. 令 p = 0.
8. 若是 separator 是正則對象 ( 它的 [[Class]] 是 "RegExp"), 令 R = separator; 不然，令 R = ToString(separator).
9. 若是 lim = 0, 返回 A.
10. 若是 separator 是 undefined, 則
    1. 以 "0", 屬性描述符 {[[Value]]: S, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]] 內部方法。
    2. 返回 A.
11. 若是 s = 0, 則
    1. 調用 SplitMatch(S, 0, R) 並 令 z 爲 它的 MatchResult 結果 .
    2. 若是 z 不是 failure, 返回 A.
    3. 以 "0", 屬性描述符 {[[Value]]: S, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]] 內部方法。
    4. 返回 A.
12. 令 q = p.
13. 只要 q ≠ s，就重複
    1. 調用 SplitMatch(S, q, R) 並 令 z 爲 它的 MatchResult 結果 .
    2. 若是 z 是 failure, 則 令 q = q+1.
    3. 不然 , z 不是 failure
       1. z 一定是一個 State. 令 e 爲 z 的 endIndex 並 令 cap 爲 z 的 captures 數組 .
       2. 若是 e = p, 則 令 q = q+1.
       3. 不然 , e ≠ p
          1. 令 T 爲一個字符串，它的值等於包含 -- 在 S 中從 p（包括它）位置到 q（不包括）位置的字符 -- 的子字符串的值。
          2. 以 ToString(lengthA), 屬性描述符 {[[Value]]: T, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]] 內部方法 .
          3. lengthA 遞增 1.
          4. 若是 lengthA = lim, 返回 A.
          5. 令 p = e.
          6. 令 i = 0.
          7. 只要 i 不等於 cap 中的元素個數，就重複 .
             1. 令 i = i+1.
             2. 以 ToString(lengthA), 屬性描述符 {[[Value]]: cap[i], [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]] 內部方法。
             3. lengthA 遞增 1.
             4. 若是 lengthA = lim, 返回 A.
          8. 令 q = p.
14. 令 T 爲 爲一個字符串，它的值等於包含 -- 在 S 中從 p（包括它）位置到 q（不包括）位置的字符 -- 的子字符串的值。
15. 以 ToString(lengthA), 屬性描述符 {[[Value]]: T, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 做爲參數調用 A 的 [[DefineOwnProperty]] 內部方法。
16. 返回 A.

SplitMatch 抽象操做須要三個參數，字符串 S，整數 q，字符串或正則對象 R，按照如下順序執行並返回一個 MatchResult（見 15.10.2.1）：

1. 若是 R 是個正則對象 ( 它的 [[Class]] 是 "RegExp"), 則
   1. 以 S 和 q 做爲參數調用 R 的 [[Match]] 內部方法，並返回 MatchResult 的結果。
2. 不然，Type(R) 一定是 String. 令 r 爲 R 的字符數 .
3. 令 s 爲 S 的字符數 .
4. 若是 q+r > s 則返回 MatchResult failure.
5. 若是存在一個在 0（包括）到 r（不包括）之間的整數 i，使得 S 的 q+i 位置上的字符和 R 的 i 位置上的字符不一樣，則返回 failure。
6. 令 cap 爲 captures 的空數組 ( 見 15.10.2.1).
7. 返回 State 數據結構 (q+r, cap). ( 見 15.10.2.1)

split 方法的 length 屬性是 2.

分隔符是正則對象時，split 方法忽略 separator.global 的值。

split 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.substring (start, end)

substring 方法須要兩個參數 start 和 end，將 this 對象轉換爲一個字符串，返回包含 -- 在轉換結果字符串中從 start 位置字符一直到（但不包括）end 位置的字符（或若是 end 是 undefined，就到字符串末尾）-- 的一個子串。返回結果是字符串值，不是字符串對象。

若是任一參數是 NaN 或負數，它被零取代；若是任一參數大於字符串長度，它被字符串長度取代。

若是 start 大於 end，交換它們的值。

採用如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 令 len 爲 S 的字符數 .
4. 令 intStart 爲 ToInteger(start).
5. 若是 end 是 undefined, 令 intEnd 爲 len; 不然 令 intEnd 爲 ToInteger(end).
6. 令 finalStart 爲 min(max(intStart, 0), len).
7. 令 finalEnd 爲 min(max(intEnd, 0), len).
8. 令 from 爲 min(finalStart, finalEnd).
9. 令 to 爲 max(finalStart, finalEnd).
10. 返回 一個長度是 to - from 的字符串，它包含 S 中從索引值 form 到 to-1（按照索引升序）的全部字符。

substring 方法的 length 屬性是 2。

substring 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.toLowerCase ( )

採用如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 令 L 爲一個字符串，L 的每一個字符是 S 中相應字符的 Unicode 小寫等量，或者（若是沒有 Unicode 小寫等量存在）是實際的 S 中相應字符值。
4. 返回 L.

爲了此操做，字符串的 16 位代碼單元被看做是 Unicode 基本多文種平面（Basic Multilingual Plane）中的代碼點。代理代碼點直接從 S 轉移到 L，不作任何映射。

返回結果必須是根據 Unicode 字符數據庫裏的大小寫映射獲得的（對此數據庫明確規定，不只包括 UnicodeData.txt 文件，並且還包括 Unicode 2.1.8 和更高版本里附帶的 SpecialCasings.txt 文件）。

某些字符的大小寫映射可產生多個字符。這種狀況下結果字符串與原字符串的長度未必相等。由於 toUpperCase 和 toLowerCase 都有上下文敏感的行爲，因此這倆函數不是對稱的。也就是說，s.toUpperCase().toLowerCase() 不必定等於 s.toLowerCase()。

toLowerCase 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.toLocaleLowerCase ( )

此函數產生依照 -- 宿主環境的當前語言設置 -- 更正的結果，而不是獨立於語言環境的結果，除此以外它的運做方式與 toLowerCase 徹底同樣。只有在少數狀況下有一個區別（如，土耳其語），就是那個語言和正規 Unicode 大小寫映射有衝突時的規則。

此函數的第一個參數可能會用於本標準的將來版本 ; 建議實現不以任何用途使用這個參數位置。

toLocaleLowerCase 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.toUpperCase ( )

此函數的將字符映射到在 Unicode 字符數據庫中與其等值的大寫字符，除此以外此函數的行爲採用與 String.prototype.toLowerCase 徹底相同的方式。

toUpperCase 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.toLocaleUpperCase ( )

此函數產生依照 -- 宿主環境的當前語言設置 -- 更正的結果，而不是獨立於語言環境的結果，除此以外它的運做方式與 toUpperCase 徹底同樣。只有在少數狀況下有一個區別（如，土耳其語），就是那個語言和正規 Unicode 大小寫映射有衝突時的規則。

此函數的第一個參數可能會用於本標準的將來版本 ; 建議實現不以任何用途使用這個參數位置。

toLocaleUpperCase 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String.prototype.trim ( )

採用如下步驟：

1. 以 this 值做爲參數調用 CheckObjectCoercible。
2. 令 S 爲以 this 值做爲參數調用 ToString 的結果 .
3. 令 T 爲一個字符串值，它是 S 的一個拷貝，並刪除了開頭和結尾中空白的。空白的定義是 WhiteSpace 和 LineTerminato r 的並集。
4. 返回 T.

trim 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。所以，他能夠當作方法轉移到其餘類型對象。

String 實例的屬性

字符串實例從字符串原型對象繼承屬性，字符串實例的 [[Class]] 內部屬性值是 "String"。字符串實例還有 [[PrimitiveValue]] 內部屬性，length 屬性，和一組屬性名是數組索引的可遍歷屬性。

[[PrimitiveValue]] 內部屬性是表明這個字符串對象的字符串值。以數組索引命名的屬性對應字符串值裏的單字符。一個特殊的 [[GetOwnProperty]] 內部方法用來爲數組索引命名的屬性指定數字，值，和特性。

length

在表明這個字符串對象的字符串值裏的字符數。

一旦建立了一個字符串對象，這個屬性是不可變的。它有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

[[GetOwnProperty]] ( P )

數組對象使用一個，用在其餘原生 ECMAscript 對象的 [[GetOwnProperty]] 內部方法 (8.12.1) 的變化版。這個特殊內部方法用來給命名屬性添加訪問器，對應到字符串對象的單字符。

設 S 爲一個字符串對象，P 爲一個字符串。

當以屬性名 P 調用 S 的 [[GetOwnProperty]] 內部方法，採用如下步驟：

1. 令 desc 爲 以 P 爲參數調用 S 的默認 [[GetOwnProperty]] 內部方法 (8.12.1) 的結果。
2. 若是 desc 不是 undefined，返回 desc.
3. 若是 ToString(abs(ToInteger(P))) 與 P 的值不一樣 , 返回 undefined.
4. 令 str 爲 S 的 [[PrimitiveValue]] 內部屬性字符串值。
5. 令 index 爲 ToInteger(P).
6. 令 len 爲 str 裏的字符數 .
7. 若是 len ≤ index, 返回 undefined.
8. 令 resultStr 爲一個長度爲 1 的字符串 , 裏面包含 str 中 index 位置的一個字符 , 在這裏 str 中的第一個（最左邊）字符被認爲是在位置 0，下一個字符在位置 1，依此類推。
9. 返回一個屬性描述符 { [[Value]]: resultStr, [[Enumerable]]: true, [[Writable]]: false, [[Configurable]]: false }

布爾對象

做爲函數調用布爾構造器

當把 Boolean 做爲函數來調用，而不是做爲構造器，它執行一個類型轉換。

Boolean (value)

返回由 ToBoolean(value) 計算出的布爾值（非布爾對象）。

布爾構造器

當 Boolean 做爲 new 表達式的一部分來調用，那麼它是一個構造器：它初始化新建立的對象。

new Boolean (value)

新構造對象的 [[Prototype]] 內部屬性設定爲原始布爾原型對象，它是 Boolean.prototype (15.6.3.1) 的初始值。

新構造對象的 [[Class]] 內部屬性設定爲 "Boolean"。

新構造對象的 [[PrimitiveValue]] 內部屬性設定爲 ToBoolean(value)。

新構造對象的 [[Extensible]] 內部屬性設定爲 true。

布爾構造器的屬性

布爾構造器的 [[Prototype]] 內部屬性的值是函數原型對象 (15.3.4)。

除了內部屬性和 length 屬性（值爲 1）外，布爾構造器還有如下屬性：

Boolean.prototype

Boolean.prototype 的初始值是布爾原型對象 (15.6.4)。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

布爾原型對象的屬性

布爾原型對象自身是一個值爲 false 的布爾對象（它的 [[Class]] 是 "Boolean"）。

布爾原型對象的 [[Prototype]] 內部屬性值是標準內置的對象原型對象（15.2.4）。

Boolean.prototype.constructor

Boolean.prototype.constructor 的初始值是內置的 Boolean 構造器。

Boolean.prototype.toString ( )

採用如下步驟：

1. 令 B 爲 this 值 .
2. 若是 Type(B) 是 Boolean, 則令 b 爲 B.
3. 不然若是 Type(B) 是 Object 且 B 的 [[Class]] 內部屬性值是 "Boolean", 則令 b 爲 B 的 [[PrimitiveValue]] 內部屬性值。
4. 不然拋出一個 TypeError 異常 .
5. 若是 b 是 true, 則返回 "true"; 不然返回 "false".

Boolean.prototype.valueOf ( )

採用如下步驟：

1. 令 B 爲 this 值 .
2. 若是 Type(B) 是 Boolean, 則令 b 爲 B.
3. 不然若是 Type(B) 是 Object 且 B 的 [[Class]] 內部屬性值是 "Boolean", 則令 b 爲 B 的 [[PrimitiveValue]] 內部屬性值。
4. 不然拋出一個 TypeError 異常 .
5. 返回 b.

布爾實例的屬性

布爾實例從布爾原型對象繼承屬性，且布爾實例的 [[Class]] 內部屬性值是 "Boolean"。布爾實例還有一個 [[PrimitiveValue]] 內部屬性。

[[PrimitiveValue]] 內部屬性是表明這個布爾對象的布爾值。

Number 對象

做爲函數調用的 Number 構造器

當把 Number 看成一個函數來調用，而不是做爲構造器，它執行一個類型轉換。

Number ( [ value ] )

若是提供了 value，返回 ToNumber(value) 計算出的數字值（非 Number 對象），不然返回 +0。

Number 構造器

當把 Number 做爲 new 表達式的一部分來調用，它是構造器：它初始化新建立的對象。

new Number ( [ value ] )

新構造對象的 [[Prototype]] 內部屬性設定爲原始數字原型對象，它是 Number.prototype 的初始值（15.7.3.1）。

新構造對象的 [[Class]] 內部屬性設定爲 "Number"。

新構造對象的 [[PrimitiveValue]] 內部屬性在提供了 value 時設定爲 ToNumber(value)，不然設定爲 +0。

新構造對象的 [[Extensible]] 內部屬性設定爲 true。

Number 構造器的屬性

Number 構造器的 [[Prototype]] 內部屬性值是函數原型對象 (15.3.4)。

除了內部屬性和 length 屬性（值爲 1）以外，Number 構造器還有如下屬性：

Number.prototype

Number.prototype 的初始值是數字原型對象。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Number.MAX_VALUE

Number.MAX_VALUE 的值是數字類型的最大正有限值，約爲 1.7976931348623157 × 10³⁰⁸。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Number.MIN_VALUE

Number.MIN_VALUE 的值是數字類型的最小正有限值，約爲 5 × 10^-324。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Number.NaN

Number.NaN 的值是 NaN。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Number.NEGATIVE_INFINITY

Number.NEGATIVE_INFINITY 的值是−∞。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Number.POSITIVE_INFINITY

Number.POSITIVE_INFINITY 的值是 +∞。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

數字原型對象的屬性

數字原型對象其自身是 Number 對象（其 [[Class]] 是 "Number"），其值爲 +0。

數字原型對象的 [[Prototype]] 內部屬性值是標準內置 Object 原型對象 (15.2.4)。

除非另外明確聲明，如下定義的數字原型對象的方法是非通用的，傳遞給它們的 this 值必須是數字值或 [[Class]] 內部屬性值是 "Number" 的對象。

在如下對做爲數字原型對象屬性的函數的描述中，短語「this Number 對象」是指函數調用中的 this 值，或若是 Type(this 值 ) 是 Number，「this Number 對象」指彷彿是用表達式 new Number(this value) 建立的對象，這裏 Number 是標準內置構造器名。此外，短語「this 數字值」是指表明 this Number 對象的數字值，也就是 this Number 對象的 [[PrimitiveValue]] 內部屬性值；或若是 this 是數字類型，「this 數字值」指 this 值。若是 this 值不是 [[Class]] 內部屬性爲 "Number" 的對象，也不是數字類型的值，則拋出一個 TypeError 異常。

Number.prototype.constructor

Number.prototype.constructor 的初始值是內置 Number 構造器。

Number.prototype.toString ( [ radix ] )

可選參數 radix 應當是 2 到 36 閉區間上的整數。若是 radix 不存在或是 undefined，用數字 10 做爲 radix 的值。若是 ToInteger(radix) 是數字 10，則將 this Number 對象做爲一個參數傳給 ToString 抽象操做；返回結果字符串值。

若是 ToInteger(radix) 不是在 2 到 36 閉區間上的整數，則拋出一個 RangeError 異常。若是 ToInteger(radix) 是 2 到 36 的整數，擔不是 10，則結果是 this 數字值使用指定基數表示法的字符串。字母 a-z 用來指值爲 10 到 35 的數字。基數不爲 10 時的精確算法是依賴於實現的，然而算法應當是 9.8.1 指定算法的推廣形式。

toString 函數不是通用的；若是 this 值不是數字或 Number 對象，拋出一個 TypeError 異常。所以它不能看成方法轉移到其餘類型對象上。

Number.prototype.toLocaleString()

根據宿主環境的當前語言環境慣例來格式化 this 數字值，生成表明這個值的字符串。此函數是依賴於實現的，容許但不鼓勵它的返回值與 toString 相同。

此函數的第一個參數可能會用於本標準的將來版本 ; 建議實現不以任何用途使用這個參數位置。

Number.prototype.valueOf ( )

返回 this 數字值。

valueOf 函數不是通用的；若是 this 值不是數字或 Number 對象，拋出一個 TypeError 異常。所以它不能看成方法轉移到其餘類型對象上。

Number.prototype.toFixed (fractionDigits)

返回一個包含了 -- 表明 this 數字值的留有小數點後 fractionDigits 個數字的十進制固定小數點記法 -- 的字符串。若是 fractionDigits 是 undefined，就認爲是 0。具體來講，執行如下步驟：

1. 令 f 爲 ToInteger(fractionDigits). ( 若是 fractionDigits 是 undefined, 此步驟產生 0 值 ).
2. 若是 f < 0 或 f > 20, 拋出一個 RangeError 異常 .
3. 令 x 爲 this 數字值 .
4. 若是 x 是 NaN, 返回字符串 "NaN".
5. 令 s 爲空字符串 .
6. 若是 x < 0, 則
   1. 令 s 爲 "-".
   2. 令 x = –x.
7. 若是 x ≥ 10²¹, 則
   1. 令 m = ToString(x).
8. 不然 , x < 10²¹
   1. 令 n 爲一個整數，讓 n ÷ 10^f – x 準確的數學值儘量接近零。若是有兩個這樣 n 值，選擇較大的 n。
   2. 若是 n = 0, 令 m 爲字符串 "0". 不然 , 令 m 爲由 n 的十進制表示裏的數組成的字符串（爲了沒有前導零）。
   3. 若是 f ≠ 0, 則
      1. 令 k 爲 m 裏的字符數目 .
      2. 若是 k ≤ f, 則
         1. 令 z 爲 f+1–k 個 ‘0’ 組成的字符串 .
         2. 令 m 爲 串聯字符串 z 的 m 的結果 .
         3. 令 k = f + 1.
      3. 令 a 爲 m 的前 k–f 個字符，令 b 爲其他 f 個字符。
      4. 令 m 爲 串聯三個字符串 a, ".", 和 b 的結果。
9. 返回串聯字符串 s 和 m 的結果。

toFixed 方法的 length 屬性是 1。

若是以多個參數調用 toFixed 方法，則行爲是不肯定的（見 15 章）。

實現是被容許在 fractionDigits 小於 0 或大於 20 時擴展 toFixed 的行爲。在這種狀況下，對這樣的 fractionDigits 值 toFixed 將未必拋出 RangeError。

對於某些值，toFixed 的輸出可比 toString 的更精確，由於 toString 只打印區分相鄰數字值的足夠的有效數字。例如 ,

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

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

Number.prototype.toExponential (fractionDigits)

返回一個表明 this 數字值的科學計數法的字符串，它的有效數字的小數點前有一個數字，有效數字的小數點後有 fractionDigits 個數字。若是 fractionDigits 是 undefined，包括指定惟一數字值須要的儘量多的有效數字（就像 ToString，但在這裏老是以科學計數法輸出）。具體來講執行如下步驟：

1. 令 x 爲 this 數字值 .
2. 令 f 爲 ToInteger(fractionDigits).
3. 若是 x 是 NaN, 返回字符串 "NaN".
4. 令 s 爲空字符串 .
5. 若是 x < 0, 則
   1. 令 s 爲 "-".
   2. 令 x = –x.
6. 若是 x = +∞, 則
   1. 返回串聯字符串 s 和 "Infinity" 的結果 .
7. 若是 fractionDigits 不是 undefined 且 (f < 0 或 f > 20), 拋出一個 RangeError 異常 .
8. 若是 x = 0, 則
   1. 令 f = 0.
   2. 令 m 爲包含 f+1 個‘0’的字符串。
   3. 令 e = 0.
9. 不然 , x ≠ 0
   1. 若是 fractionDigits 不是 undefined, 則
      1. 令 e 和 n 爲整數，使得知足 10^f ≤ n < 10^f+1 且 n × 10^e–f – x 的準確數學值儘量接近零。若是 e 和 n 有兩個這樣的組合，選擇使 n × 10^e–f 更大的組合。
   2. 不然 , fractionDigits 是 undefined
      1. 令 e, n, 和 f 爲整數，使得知足 f ≥ 0, 10^f≤ n < 10^f+1, n × 10^e–f 的數字值是 x, 且 f 的值儘量小。注：n 的十進制表示有 f+1 個數字，n 不能被 10 整除，而且 n 的最少有效位數不必定惟一由這些條件肯定。
   3. 令 m 爲由 n 的十進制表示裏的數 組成的字符串（沒有前導零）。
10. 若是 f ≠ 0, 則
    1. 令 a 爲 m 中的第一個字符 , 令 b 爲 m 中的其他字符 .
    2. 令 m 爲串聯三個字符串 a, ".", 的 b 的結果 .
11. 若是 e = 0, 則
    1. 令 c = "+".
    2. 令 d = "0".
12. 不然
    1. 若是 e > 0, 則 令 c = "+".
    2. 不然 , e ≤ 0
       1. 令 c = "-".
       2. 令 e = –e.
    3. 令 d 爲有 e 的十進制表示裏的數 組成的字符串（沒有前導零）。
13. 令 m 爲串聯四個字符串 m, "e", c, 和 d 的結果 .
14. 返回串聯字符串 s 和 m 的結果 .

toExponential 方法的 length 屬性是 1。

若是用多於一個參數調用 toExponential 方法，則行爲是未定義的 ( 見 15 章 )。

一個實現能夠擴展 fractionDigits 的值小於 0 或大於 20 時 toExponential 的行爲。這種狀況下對這樣的 fractionDigits 值，toExponential 不必定拋出 RangeError 異常 .

對於須要提供比上述規則更準確轉換的實現，建議用如下算法做爲指引替代步驟 9.b.i ：

1. 令 e, n, 和 f 爲整數，使得知足 f ≥ 0, 10^f≤ n < 10^f+1, n × 10^e–f 的數字值是 x, 且 f 的值儘量小。若是這樣的 n 值可能多個，選擇使 n × 10^e–f 的值儘量接近 x 的 n 值。若是有兩個這樣的 n 值，選擇偶數。

Number.prototype.toPrecision (precision)

返回一個字符串，它表明 this 數字值的科學計數法（有效數字的小數點前有一個數字，有效數字的小數點後有 precision-1 個數字）或十進制固定計數法（precision 個有效數字）。若是 precision 是 undefined，用 ToString (9.8.1) 調用代替。具體來講執行如下步驟：

1. 令 x 爲 this 數字值 .
2. 若是 precision 是 undefined, 返回 ToString(x).
3. 令 p 爲 ToInteger(precision).
4. 若是 x 是 NaN, 返回字符串 "NaN".
5. 令 s 爲空字符串 .
6. 若是 x < 0, 則
   1. 令 s 爲 "-".
   2. 令 x = –x.
7. 若是 x = +∞, 則
   1. 返回串聯字符串 s 和 "Infinity" 的結果 .
8. 若是 p < 1 或 p > 21, 拋出一個 RangeError 異常 .
9. 若是 x = 0, 則
   1. 令 m 爲 p 個 '0' 組成的字符串 .
   2. 令 e = 0.
10. 不然 x ≠ 0,
    1. 令 e 和 n 爲整數，使得知足 10^p–1 ≤ n < 10^p 且 n × 10^e–p+1 – x 的準確數學值儘量接近零。若是 e 和 n 有兩個這樣的組合，選擇使 n × 10^e–p+1 更大的組合。
    2. 令 m 爲由 n 的十進制表示裏的數 組成的字符串（沒有前導零）。
    3. 若是 e < –6 或 e ≥ p, 則
       1. 令 a 爲 n 的第一個字符 , 令 b 爲 m 的其他 p–1 個字符 .
       2. 令 m 爲串聯三個字符串 a, ".", 和 b 的結果 .
       3. 若是 e = 0, 則
          1. 令 c = "+" ，令 d = "0".
       4. 不然 e ≠ 0,
          1. 若是 e > 0, 則
             1. 令 c = "+".
          2. 不然 e < 0,
             1. 令 c = "-".
             2. 令 e = –e.
          3. 令 d 爲由 e 的十進制表示裏的數 組成的字符串（沒有前導零）。
       5. 令 m 爲串聯五個字符串 s, m, "e", c, 和 d 的結果 .
11. 若是 e = p–1, 則返回串聯字符串 s 和 m 的結果 .
12. 若是 e ≥ 0, 則
    1. 令 m 爲 m 的前 e+1 個字符 , 字符‘.’, m 的其他 p– (e+1) 個字符 串聯的結果 .
13. 不然 e < 0,
    1. 令 m 爲 字符串 "0.", –(e+1) 個字符‘0’, 字符串 m 串聯的結果 .
14. 返回字符串 s 和 m 串聯的結果 .

toPrecision 方法的 length 屬性是 1。

若是用多於一個參數調用 toPrecision 方法，則行爲是未定義的 ( 見 15 章 )。

一個實現能夠擴展 precision 的值小於 1 或大於 21 時 toPrecision 的行爲。這種狀況下對這樣的 precision 值，toPrecision 不必定拋出 RangeError 異常 .

數字實例的屬性

數字實例從數字原型對象繼承屬性，數字實例的 [[Class]] 內部屬性是 "Number"。數字實例還有一個 [[PrimitiveValue]] 內部屬性。

[[PrimitiveValue]] 內部屬性是表明 this Number 對象的數字值。

Math 對象

Math 對象是擁有一些命名屬性的單一對象，其中一些屬性值是函數。

Math 對象的 [[Prototype]] 內部屬性值是標準內置 Object 原型對象 (15.2.4)。Math 對象的 [[Class]] 內部屬性值是 "Math"。

Math 對象沒有 [[Construct]] 內部屬性 ; Math 對象不能做爲構造器被 new 運算符調用。

Math 對象沒有 [[Call]] 內部屬性；Math 對象不能做爲函數被調用。

本規範中，短語「x 的數字值」的技術含義定義在 8.5。

Math 對象的值屬性

E

天然對數的底數 e 的數字值，約爲 2.7182818284590452354。

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

LN10

10 的天然對數的數字值，約爲 2.302585092994046。

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

LN2

2 的天然對數的數字值，約爲 0.6931471805599453。

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

LOG2E

天然對數的底數 e 的以 2 爲底數的對數的數字值；約爲 1.4426950408889634。

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

Math.LOG2E 的值約爲 Math.LN2 值的倒數。

LOG10E

天然對數的底數 e 的以 10 爲底數的對數的數字值；約爲 0.4342944819032518。

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

Math.LOG10E 的值約爲 Math.LN10 值的倒數。

PI

圓的周長與直徑之比π的數字值，約爲 3.1415926535897932。

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

SQRT1_2

½ 的平方根的數字值，約爲 0.7071067811865476。

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

Math.SQRT1_2 的值約爲 Math.SQRT2 值的倒數。

SQRT2

2 的平方根的數字值，約爲 1.4142135623730951。

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

Math 對象的函數屬性

對如下每一個 Math 對象函數的每一個參數（若是有多個，以左到右的順序）應用 ToNumber 抽象操做，而後對結果數字值執行計算。

下面對函數的描述中，符號 NaN, −0, +0, −∞, +∞ 指 8.5 描述的數字值。

這裏沒有精確規定函數 acos, asin, atan, atan2, cos, exp, log, pow, sin, sqrt 的行爲，除了須要特別說明對邊界狀況某些參數值的結果以外。對其餘參數值，這些函數旨在計算計算常見數學函數的結果，但選擇的近似算法中的某些範圍是被容許的。The general intent is that an implementer should be able to use the same mathematical library for ECMAScript on a given hardware platform that is available to C programmers on that platform.

Although the choice of algorithms is left to the implementation, it is recommended (but not specified by this standard) that implementations use the approximation algorithms for IEEE 754 arithmetic contained in fdlibm, the freely distributable mathematical library from Sun Microsystems (http://www.netlib.org/fdlibm).

abs (x)

返回 x 的絕對值。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 是 −0, 返回結果是 +0.
• 若 x 是 −∞, 返回結果是 +∞.

acos (x)

返回 x 的反餘弦的依賴實現的近似值。結果以弧度形式表示，範圍是 +0 到 +π。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 大於 1, 返回結果是 NaN.
• 若 x 小於 −1, 返回結果是 NaN.
• 若 x 正好是 1, 返回結果是 +0.

asin (x)

返回 x 的反正弦的依賴實現的近似值。結果以弧度形式表示，範圍是−π/2 到 +π/2。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 大於 1, 返回結果是 NaN.
• 若 x 小於 –1, 返回結果是 NaN.
• 若 x 是 +0, 返回結果是 +0.
• 若 x 是 −0, 返回結果是 −0.

atan (x)

返回 x 的反正切的依賴實現的近似值。結果以弧度形式表示，範圍是−π/2 到 +π/2。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 是 +0, 返回結果是 +0.
• 若 x 是 −0, 返回結果是 −0.
• 若 x 是 +∞, 返回結果是 一個依賴於實現的近似值 +π/2.
• 若 x 是 −∞, 返回結果是 一個依賴於實現的近似值 −π/2.

atan2 (y, x)

返回 -- 參數 y 和 x 的商 y/x-- 的反正切的依賴實現的近似值，y 和 x 的符號用於肯定返回值的象限。注：命名爲 y 的參數爲第一個，命名爲 x 的參數爲第二個，這是有意，是反正切函數倆參數的慣例。結果以弧度形式表示，範圍是−π到 +π。

• 若 x 和 y 至少一個是 NaN, 返回結果是 NaN.
• 若 y>0 且 x 是 +0, 返回結果是 一個依賴於實現的近似值 +π/2.
• 若 y>0 且 x 是 −0, 返回結果是 一個依賴於實現的近似值 +π/2.
• 若 y 是 +0 且 x>0, 返回結果是 +0.
• 若 y 是 +0 且 x 是 +0, 返回結果是 +0.
• 若 y 是 +0 且 x 是 −0, 返回結果是 一個依賴於實現的近似值 +π.
• 若 y 是 +0 且 x<0, 返回結果是 一個依賴於實現的近似值 +π.
• 若 y 是 −0 且 x>0, 返回結果是 −0.
• 若 y 是 −0 且 x 是 +0, 返回結果是 −0.
• 若 y 是 −0 且 x 是 −0, 返回結果是 一個依賴於實現的近似值 −π.
• 若 y 是 −0 且 x<0, 返回結果是 一個依賴於實現的近似值 −π.
• 若 y<0 且 x 是 +0, 返回結果是 一個依賴於實現的近似值 −π/2.
• 若 y<0 且 x 是 −0, 返回結果是 一個依賴於實現的近似值 −π/2.
• 若 y>0 且 y 是 有限的 且 x 是 +∞, 返回結果是 +0.
• 若 y>0 且 y 是 有限的 且 x 是 −∞, 返回結果是 一個依賴於實現的近似值 +π.
• 若 y<0 且 y 是 有限的 且 x 是 +∞, 返回結果是 −0.
• 若 y<0 且 y 是 有限的 且 x 是 −∞, 返回結果是 一個依賴於實現的近似值 −π.
• 若 y 是 +∞ 且 x 是 有限的 , 返回結果是 返回結果是 一個依賴於實現的近似值 +π/2.
• 若 y 是 −∞ 且 x 是 有限的 , 返回結果是 返回結果是 一個依賴於實現的近似值 −π/2.
• 若 y 是 +∞ 且 x 是 +∞, 返回結果是 一個依賴於實現的近似值 +π/4.
• 若 y 是 +∞ 且 x 是 −∞, 返回結果是 一個依賴於實現的近似值 +3π/4.
• 若 y 是 −∞ 且 x 是 +∞, 返回結果是 一個依賴於實現的近似值 −π/4.
• 若 y 是 −∞ 且 x 是 −∞, 返回結果是 一個依賴於實現的近似值 −3π/4.

ceil (x)

返回不小於 x 的且爲數學整數的最小 ( 接近−∞) 數字值。若是 x 已經是整數，則返回 x。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 是 +0, 返回結果是 +0.
• 若 x 是 −0, 返回結果是 −0.
• 若 x 是 +∞, 返回結果是 +∞.
• 若 x 是 −∞, 返回結果是 −∞.
• 若 x 小於 0 但大於 -1, 返回結果是 −0.

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

cos (x)

返回 x 的餘弦的依賴實現的近似值。參數被當作是弧度值。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 是 +0, 返回結果是 1.
• 若 x 是 −0, 返回結果是 1.
• 若 x 是 +∞, 返回結果是 NaN.
• 若 x 是 −∞, 返回結果是 NaN.

exp (x)

返回 x 的指數的依賴實現的近似值（e 爲 x 次方，e 爲天然對數的底）。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 是 +0, 返回結果是 1.
• 若 x 是 −0, 返回結果是 1.
• 若 x 是 +∞, 返回結果是 +∞.
• 若 x 是 −∞, 返回結果是 +0.

floor (x)

返回不大於 x 的且爲數學整數的最大 ( 接近 +∞) 數字值。若是 x 已經是整數，則返回 x。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 是 +0, 返回結果是 +0.
• 若 x 是 −0, 返回結果是 −0.
• 若 x 是 +∞, 返回結果是 +∞.
• 若 x 是 −∞, 返回結果是 −∞.
• 若 x 大於 0 但小於 1, 返回結果是 +0.

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

log (x)

返回 x 的天然對數的依賴於實現的近似值 .

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 小於 0, 返回結果是 NaN.
• 若 x 是 +0 或 −0, 返回結果是 −∞.
• 若 x 是 1, 返回結果是 +0.
• 若 x 是 +∞, 返回結果是 +∞.

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

給定零或多個參數，對每一個參數調用 ToNumber 並返回調用結果裏的最大值。

• 若 沒有給定參數 , 返回結果是 −∞.
• 若 任何值是 NaN, 返回結果是 NaN.
• 按照 11.8.5 指定方式進行值比較，肯定最大值，與 11.8.5 指定方式的一個不一樣點是在這裏 +0 被看做大於 -0.

max 方法的 length 屬性是 2。

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

給定零或多個參數，對每一個參數調用 ToNumber 並返回調用結果裏的最小值。

• 若 沒有給定參數 , 返回結果是 +∞.
• 若 任何值是 NaN, 返回結果是 NaN.
• 按照 11.8.5 指定方式進行值比較，肯定最小值，與 11.8.5 指定方式的一個不一樣點是在這裏 +0 被看做大於 -0.

min 方法的 length 屬性是 2。

pow (x, y)

返回 x 的 y 次方的依賴於實現的近似值 .

• 若 y 是 NaN, 返回結果是 NaN.
• 若 y 是 +0, 返回結果是 1, 即便 x 是 NaN.
• 若 y 是 −0, 返回結果是 1, 即便 x 是 NaN.
• 若 x 是 NaN 且 y 是 非零 , 返回結果是 NaN.
• 若 abs(x)>1 且 y 是 +∞, 返回結果是 +∞.
• 若 abs(x)>1 且 y 是 −∞, 返回結果是 +0.
• 若 abs(x)==1 且 y 是 +∞, 返回結果是 NaN.
• 若 abs(x)==1 且 y 是 −∞, 返回結果是 NaN.
• 若 abs(x)<1 且 y 是 +∞, 返回結果是 +0.
• 若 abs(x)<1 且 y 是 −∞, 返回結果是 +∞.
• 若 x 是 +∞ 且 y>0, 返回結果是 +∞.
• 若 x 是 +∞ 且 y<0, 返回結果是 +0.
• 若 x 是 −∞ 且 y>0 且 y 是 一個奇數 , 返回結果是 −∞.
• 若 x 是 −∞ 且 y>0 且 y 不是 一個奇數 , 返回結果是 +∞.
• 若 x 是 −∞ 且 y<0 且 y 是 一個奇數 , 返回結果是 −0.
• 若 x 是 −∞ 且 y<0 且 y 不是 一個奇數 , 返回結果是 +0.
• 若 x 是 +0 且 y>0, 返回結果是 +0.
• 若 x 是 +0 且 y<0, 返回結果是 +∞.
• 若 x 是 −0 且 y>0 且 y 是 一個奇數 , 返回結果是 −0.
• 若 x 是 −0 且 y>0 且 y 不是 一個奇數 , 返回結果是 +0.
• 若 x 是 −0 且 y<0 且 y 是 一個奇數 , 返回結果是 −∞.
• 若 x 是 −0 且 y<0 且 y 不是 一個奇數 , 返回結果是 +∞.
• 若 x<0 且 x 是 有限的 且 y 是 有限的 and y 不是整數 , 返回結果是 NaN.

random ( )

返回一個大於或等於 0 但小於 1 的符號爲正的數字值，選擇隨機或在該範圍內近似均勻分佈的僞隨機，用一個依賴與實現的算法或策略。此函數不須要參數。

round (x)

返回最接近 x 且爲數學整數的數字值。若是兩個整數同等接近 x，則結果是接近 +∞的數字值 。若是 x 已經是整數，則返回 x。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 是 +0, 返回結果是 +0.
• 若 x 是 −0, 返回結果是 −0.
• 若 x 是 +∞, 返回結果是 +∞.
• 若 x 是 −∞, 返回結果是 −∞.
• 若 x 大於 0 但小於 0.5, 返回結果是 +0.
• 若 x 小於 0 但大於或等於 -0.5, 返回結果是 −0.

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

當 x 爲 −0 或 x 小於 0 當大於大於等於 -0.5 時，Math.round(x) 返回 −0, 但 Math.floor(x+0.5) 返回 +0，除了這種狀況以外 Math.round(x) 的返回值與 Math.floor(x+0.5) 的返回值相同。

sin (x)

返回 x 的正弦的依賴實現的近似值。參數被當作是弧度值。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 是 +0, 返回結果是 +0.
• 若 x 是 −0, 返回結果是 −0.
• 若 x 是 +∞ 或 −∞, 返回結果是 NaN.

sqrt (x)

返回 x 的平方根的依賴實現的近似值。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 小於 0, 返回結果是 NaN.
• 若 x 是 +0, 返回結果是 +0.
• 若 x 是 −0, 返回結果是 −0.
• 若 x 是 +∞, 返回結果是 +∞.

tan (x)

返回 x 的正切的依賴實現的近似值。參數被當作是弧度值。

• 若 x 是 NaN, 返回結果是 NaN.
• 若 x 是 +0, 返回結果是 +0.
• 若 x 是 −0, 返回結果是 −0.
• 若 x 是 +∞ 或 −∞, 返回結果是 NaN.

Date 對象

Date 對象的概述和抽象操做的定義

下面的抽象操做函數用來操做時間值（15.9.1.1 定義）。注：任何狀況下，若是這些函數之一的任意參數是 NaN，則結果將是 NaN。

時間值和時間範圍

一個 Date 對象包含一個表示特定時間瞬間的毫秒的數字值。這樣的數字值叫作 時間值 。一個時間值也能夠是 NaN，說明這個 Date 對象不表示特定時間瞬間。

ECMAScript 中測量的時間是從協調世界時 1970 年 1 月 1 日開始的毫秒數。在時間值中閏秒是被忽略的，假設天天正好有 86,400,000 毫秒。ECMAScript 數字值可表示的全部從–9,007,199,254,740,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 表示。

天數和天內時間

一個給定時間值 t 所屬的天數是

Day(t) = floor(t / msPerDay)

其中天天的毫秒數是

msPerDay = 86400000

餘數叫作天內時間

TimeWithinDay(t) = t modulo msPerDay

年數

ECMAScript 使用一個推算公曆系統，來將一個天數映射到一個年數，並肯定在那年的月份的日期。在這個系統中，閏年是且僅是（可被 4 整除）且（（不可被 100 整除）或（可被 400 整除））的年份。所以，y 年的天的數目定義爲

DaysInYear(y) = 365 { 若是 (y 取模 4) ≠ 0 } = 366 { 若是 (y 取模 4) = 0 且 (y 取模 100) ≠ 0 } = 365 { 若是 (y 取模 100) = 0 且 (y 取模 400) ≠ 0 } = 366 { 若是 (y 取模 400) = 0 }

全部非閏年有 365 天，其中每個月的天的數目是常規的。閏年的二月裏有個多出來的一天。 y 年第一天的天數是 :

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

y 年的起始時間值是：

TimeFromYear(y) = msPerDay × DayFromYear(y)

一個時間值決定的年數是：

YearFromTime(t) = 知足條件 TimeFromYear(y) ≤ t 的最大整數 y （接近正無窮）

若時間值在閏年內，閏年函數返回 1，不然返回 0：

InLeapYear(t) = 0 { 若是 DaysInYear(YearFromTime(t)) = 365 } = 1 { 若是 DaysInYear(YearFromTime(t)) = 366 }

月數

月份是由閉區間 0 到 11 內的一個整數肯定。一個時間值 t 到一個月數的映射 MonthFromTime(t) 的定義爲：

MonthFromTime(t) = 0 if 0 ≤ DayWithinYear(t) < 31 = 1 if 31 ≤ DayWithinYear (t) < 59+InLeapYear(t) = 2 if 59+InLeapYear(t) ≤ DayWithinYear (t) < 90+InLeapYear(t) = 3 if 90+InLeapYear(t) ≤ DayWithinYear (t) < 120+InLeapYear(t) = 4 if 120+InLeapYear(t) ≤ DayWithinYear (t) < 151+InLeapYear(t) = 5 if 151+InLeapYear(t) ≤ DayWithinYear (t) < 181+InLeapYear(t) = 6 if 181+InLeapYear(t) ≤ DayWithinYear (t) < 212+InLeapYear(t) = 7 if 212+InLeapYear(t) ≤ DayWithinYear (t) < 243+InLeapYear(t) = 8 if 243+InLeapYear(t) ≤ DayWithinYear (t) < 273+InLeapYear(t) = 9 if 273+InLeapYear(t) ≤ DayWithinYear (t) < 304+InLeapYear(t) = 10 if 304+InLeapYear(t) ≤ DayWithinYear (t) < 334+InLeapYear(t) = 11 if 334+InLeapYear(t) ≤ DayWithinYear (t) < 365+InLeapYear(t)

其中

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

月數值 0 指一月；1 指二月；2 指三月；3 指四月；4 指五月；5 指六月；6 指七月；7 指八月；8 指九月；9 指十月；10 指十一月；11 指十二月。注：MonthFromTime(0) = 0，對應 1970 年 1 月 1 日，星期四。

日期數

一個日期數用閉區間 1 到 31 內的一個整數標識。從一個時間值 t 到一個日期數的映射 DateFromTime(t) 的定義爲：

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

星期數

特定時間值 t 對應的星期數的定義爲：

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

星期數的值 0 指星期日；1 指星期一；2 指星期二；3 指星期三；4 指星期四；5 指星期五；6 指星期六。注：WeekDay(0) = 4, 對應 1970 年 1 月 01 日 星期四。

本地時區校準

指望一個 ECMAScript 的實現肯定本地時區校準。本地時區校準是一個毫秒爲單位的值 LocalTZA，它加上 UTC 表明本地標準時間。LocalTZA 不體現夏令時。LocalTZA 值不隨時間改變，但只取決於地理位置。

夏令時校準

指望一個 ECMAScript 的實現肯定夏令時算法。肯定夏令時校準的算法 DaylightSavingTA(t)，以毫秒爲單位，必須只依賴下面四個項目：

(1) 自本年開始以來的時間

t – TimeFromYear(YearFromTime(t))

(2) t 是否在閏年內

InLeapYear(t)

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

WeekDay(TimeFromYear(YearFromTime(t))

(4) 地理位置。

The implementation of ECMAScript should not try to determine whether the exact time was subject to daylight saving time, but just whether daylight saving time would have been in effect if the current daylight saving time algorithm had been used at the time. This avoids complications such as taking into account the years that the locale observed daylight saving time year round.

If the host environment provides functionality for determining daylight saving time, the implementation of ECMAScript is free to map the year in question to an equivalent year (same leap-year-ness and same starting week day for the year) for which the host environment provides daylight saving time information. The only restriction is that all equivalent years should produce the same result.

本地時間

從協調世界時到本地時間的轉換，定義爲

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

從本地時間到協調世界時的轉換，定義爲

UTC(t) = t – LocalTZA – DaylightSavingTA(t – LocalTZA)

UTC(LocalTime(t)) 不必定老是等於 t。

小時 , 分鐘 , 秒 , 毫秒

如下函數用於分解時間值：

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

其中

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

MakeTime (hour, min, sec, ms)

MakeTime 抽象操做用它的四個參數算出一個毫秒數，參數必須是 ECMAScript 數字值。此抽象操做運行以下：

1. 若是 hour 不是有限的或 min 不是有限的或 sec 不是有限的或 ms 不是有限的 , 返回 NaN。
2. 令 h 爲 ToInteger(hour).
3. 令 m 爲 ToInteger(min).
4. 令 s 爲 ToInteger(sec).
5. 令 milli 爲 ToInteger(ms).
6. 令 t 爲 h * msPerHour + m * msPerMinute + s * msPerSecond + milli, 執行的四則運算根據 IEEE 754 規則（這就像使用 ECMAScript 運算符 * 和 + 同樣）。
7. 返回 t。

MakeDay (year, month, date)

MakeDay 抽象操做用它的三個參數算出一個天數，參數必須是 ECMAScript 數字值。此抽象操做運行以下：

1. 若是 year 不是有限的或 month 不是有限的或 date 不是有限的 , 返回 NaN.
2. 令 y 爲 ToInteger(year).
3. 令 m 爲 ToInteger(month).
4. 令 dt 爲 ToInteger(date).
5. 令 ym 爲 y + floor(m /12).
6. 令 mn 爲 m modulo 12.
7. 找一個知足 YearFromTime(t) == ym 且 MonthFromTime(t) == mn 且 DateFromTime(t) == 1 的 t 值 ; 但若是這些條件是不可能的（由於有些參數超出了範圍）, 返回 NaN.
8. 返回 Day(t) + dt − 1.

MakeDate (day, time)

MakeDate 抽象操做用它的兩個參數算出一個毫秒數，參數必須是 ECMAScript 數字值。此抽象操做運行以下：

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

TimeClip (time)

TimeClip 抽象操做用它的參數算出一個毫秒數，參數必須是 ECMAScript 數字值。此抽象操做運行以下：

1. 若是 time 不是有限的 , 返回 NaN.
2. 若是 abs(time) > 8.64 x 1015, 返回 NaN.
3. 返回 ToInteger(time) 和 ToInteger(time) + (+0) 之一，這依賴於實現 ( 加正一是爲了將 −0 轉換成 +0)。

第 3 步的重點是說容許實現自行選擇時間值的內部表示形式，如 64 位有符號整數或 64 位浮點數。根據不一樣的實現，這個內部表示可能區分也可能沒法區分 −0 和 +0。

日期時間字符串格式

ECMAScript 定義了一個基於簡化的 ISO 8601 擴展格式的日期時間的字符串互換格式，格式爲：YYYY-MM-DDTHH:mm:ss.sssZ

其中個字段爲：

YYYY
是公曆中年的十進制數字。

-
在字符串中直接以「-」 ( 破折號 ) 出現兩次。

MM
是一年中的月份，從 01 ( 一月 ) 到 12 ( 十二月 )。

DD
是月份中的日期，從 01 到 30。

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

全部數字必須是 10 進制的。若是缺乏 MM 或 DD 字段，用「01」做爲它們的值。若是缺乏 mm 或 ss 字段，用「00」做爲它們的值，對於缺乏的 sss 用「000」做爲它的值。對於缺乏的時區偏移量用「Z」。

一個格式字符串裏有非法值（越界以及語法錯誤），意味着這個格式字符串不是有效的本節描述格式的實例。

因爲天天的開始和結束都在午夜，倆符號 00:00 和 24:00 可區分這樣的能夠是同一時間的兩個午夜。這意味着兩個符號 1995-02-04T24:00 和 1995-02-05T00:00 精準的指向同一時刻。

不存在用來規範像 CET, EST 這樣的民間時區縮寫的國際標準。有時相同的縮寫甚至使用不一樣的時區。出於這個緣由，ISO 8601 和這裏的格式指定數字來表示時區。

擴展的年

ECMAScript 須要能表示 6 位數年份（擴展的年份）的能力；協調世界時 1970 年 1 月 1 日先後分別約 285,616 年。對於表示 0 年以前或 9999 年以後的年份，ISO 8601 容許對年的表示法進行擴展，但只能在發送和接受信息的雙方有事先共同約定的狀況下才能擴展。在已經簡化的 ECMAScript 的格式中這樣擴展的年份表示法有 2 個額外的數字和始終存在的前綴符號 + 或 - 。0 年被認爲是正的，所以用 + 符號做爲前綴。

擴展年的示例

-283457-03-21T15:00:59.008Z 283458 B.C. -000001-01-01T00:00:00Z 2 B.C. +000000-01-01T00:00:00Z 1 B.C. +000001-01-01T00:00:00Z 1 A.D. +001970-01-01T00:00:00Z 1970 A.D. +002009-12-15T00:00:00Z 2009 A.D. +287396-10-12T08:59:00.992Z 287396 A.D.

做爲函數調用 Date 構造器

當把 Date 做爲函數來調用，而不做爲構造器，它返回一個表示當前時間（協調世界時）的字符串。

函數調用 Date(…) 的結果和用相同參數調用表達式 new Date(…) 建立的對象是不一樣的。

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

全部參數都是可選的；接受提供的任何參數，但被徹底忽略。返回一個彷彿是用表達式 (new Date()).toString() 建立的字符串，這裏的 Date 是標準內置構造器，toString 是標準內置方法 Date.prototype.toString。

Date 構造器

當把 Date 做爲 new 表達式的一部分來調用，它是個構造器：它初始化新建立的對象。

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

當用二到七個參數調用 Date 構造器，它用 year, month, 還有 ( 可選的 ) date, hours, minutes, seconds, ms 來計算時間。

新構造對象的 [[Prototype]] 內部屬性設定爲原始的時間原型對象，它是 Date.prototype(15.9.4.1) 的初始值。

新構造對象的 [[Class]] 內部屬性設定爲 "Date"。

新構造對象的 [[Extensible]] 內部屬性設定爲 ture。

新構造對象的 [[PrimitiveValue]] 內部屬性按照如下步驟設定：

1. 令 y 爲 ToNumber(year).
2. 令 m 爲 ToNumber(month).
3. 若是提供了 date ，則令 dt 爲 ToNumber(date); 不然令 dt 爲 1.
4. 若是提供了 hours ，則令 h 爲 ToNumber(hours); 不然令 h 爲 0.
5. 若是提供了 minutes ，則令 min 爲 ToNumber(minutes); 不然令 min 爲 0.
6. 若是提供了 seconds ，則令 s 爲 ToNumber(seconds); 不然令 s 爲 0.
7. 若是提供了 ms ，則令 milli 爲 ToNumber(ms); 不然令 milli 爲 0.
8. 若是 y 不是 NaN 且 0 ≤ ToInteger(y) ≤ 99, 則令 yr 爲 1900+ToInteger(y); 不然令 yr 爲 y.
9. 令 finalDate 爲 MakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli)).
10. 設定新構造對象的 [[PrimitiveValue]] 內部屬性爲 TimeClip(UTC(finalDate)).

new Date (value)

新構造對象的 [[Prototype]] 內部屬性設定爲原始的時間原型對象，它是 Date.prototype(15.9.4.1) 的初始值。

新構造對象的 [[Class]] 內部屬性設定爲 "Date"。

新構造對象的 [[Extensible]] 內部屬性設定爲 ture。

新構造對象的 [[PrimitiveValue]] 內部屬性按照如下步驟設定：

1. 令 v 爲 ToPrimitive(value).
2. 若是 Type(v) 是 String, 則
   1. 用與 parse 方法 (15.9.4.2) 徹底相同的方式將 v 解析爲一個日期時間；令 V 爲這個日期時間的時間值。
3. 不然 , 令 V 爲 ToNumber(v).
4. 設定新構造對象的 [[PrimitiveValue]] 內部屬性爲 TimeClip(V)，並返回這個值。

new Date ( )

新構造對象的 [[Prototype]] 內部屬性設定爲原始的時間原型對象，它是 Date.prototype(15.9.4.1) 的初始值。

新構造對象的 [[Class]] 內部屬性設定爲 "Date"。

新構造對象的 [[Extensible]] 內部屬性設定爲 ture。

新構造對象的 [[PrimitiveValue]] 內部屬性設定爲表示當前時間的時間值（協調世界時）。

Date 構造器的屬性

Date 構造器的 [[Prototype]] 內部屬性的值是函數原型對象 (15.3.4)。

除了內部屬性和 length 屬性 ( 值爲 7) 以外，Date 構造器還有如下屬性：

Date.prototype

Date.prototype 的初始值是內置的 Date 原型對象 (15.9.5)。

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

Date.parse (string)

parse 函數對它的參數應用 ToString 操做並將結果字符串解釋爲一個日期和時間；返回一個數字值，是對應這個日期時間的 UTC 時間值。字符串可解釋爲本地時間，UTC 時間，或某個其餘時區的時間，這取決於字符串裏的內容。此函數首先嚐試根據日期時間字符串格式（15.9.1.15）裏的規則來解析字符串的格式。若是字符串不符合這個格式此函數可回退，用任意實現定義的試探方式或日期格式。沒法識別的字符串或日期時間包含非法元素值，將致使 Date.parse 返回 NaN。

在全部屬性都指向它們的初始值的狀況下，若是 x 是一個在特定 ECMAScript 的實現裏的毫秒數爲零的任意 Date 對象，則在這個實現中如下全部表達式應產生相同數字值：

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

然而，表達式

Date.parse( x.toLocaleString())

是不須要產生與前面三個表達參數相同的數字值。一般，在給定的字符串不符合日期時間字符串格式（15.9.1.15）時，Date.parse 的產生值是依賴於實現，而且在同一實現中 toString 或 toUTCString 方法不能產生不符合日期時間字符串格式的字符串。

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

當用少於兩個的參數調用 UTC 函數時，它的行爲是依賴於實現的。當用二到七個參數調用 UTC 函數，它從 year, month 和 ( 可選的 ) date, hours, minutes, seconds, ms 計算出日期時間。採用如下步驟：

1. 令 y 爲 ToNumber(year).
2. 令 m 爲 ToNumber(month).
3. 若是提供了 date ，則令 dt 爲 ToNumber(date); 不然令 dt 爲 1.
4. 若是提供了 hours ，則令 h 爲 ToNumber(hours); 不然令 h 爲 0.
5. 若是提供了 minutes ，則令 min 爲 ToNumber(minutes); 不然令 min 爲 0.
6. 若是提供了 seconds ，則令 s 爲 ToNumber(seconds); 不然令 s 爲 0.
7. 若是提供了 ms ，則令 milli 爲 ToNumber(ms); 不然令 milli 爲 0.
8. 若是 y 不是 NaN 且 0 ≤ ToInteger(y) ≤ 99, 則令 yr 爲 1900+ToInteger(y); 不然令 yr 爲 y.
9. 返回 TimeClip(MakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli))).

UTC 函數的 length 屬性是 7。

UTC 函數與 Date 構造器的不一樣點有：它返回一個時間值，而不是建立 Date 對象，還有它將參數解釋爲 UTC，而不是本地時間。

Date.now ( )

now 函數返回一個數字值，它表示調用 now 時的 UTC 日期時間的時間值。

Date 原型對象的屬性

Date 原型對象自身是一個 Date 對象（其 [[Class]] 是 "Date"），其 [[PrimitiveValue]] 是 NaN。

Date 原型對象的 [[Prototype]] 內部屬性的值是標準內置 Object 原型對象 (15.2.4)。

在如下對 Date 原型對象的函數屬性的描述中，短語「this Date 對象」指調用函數時的 this 值對象。除非另外說明，這些函數不是通用的；若是 this 值不是 [[Class]] 內部屬性爲 "Date" 的對象，則拋出一個 TypeError 異常。短語「this 時間值」指表明 this Date 對象的時間值的數字值，它是 this Date 對象的 [[PrimitiveValue]] 內部屬性的值。

Date.prototype.constructor

Date.prototype.constructor 的初始值是內置 Date 構造器。

Date.prototype.toString ( )

此函數返回一個字符串值。字符串中內容是依賴於實現的，但目的是用一種方便，人類可讀的形式表示當前時區的時間。

對毫秒數爲零的任意 Date 值 d，Date.parse(d.toString()) 和 d.valueOf() 的結果相同。見 15.9.4.2

Date.prototype.toDateString ( )

此函數返回一個字符串值。字符串中內容是依賴於實現的，但目的是用一種方便，人類可讀的形式表示當前時區時間的「日期」部分。

Date.prototype.toTimeString ( )

此函數返回一個字符串值。字符串中內容是依賴於實現的，但目的是用一種方便，人類可讀的形式表示當前時區時間的「時間」部分。

Date.prototype.toLocaleString ( )

此函數返回一個字符串值。字符串中內容是依賴於實現的，但目的是用一種 -- 對應宿主環境的當前語言環境設定的 -- 方便，人類可讀的形式表示當前時區的時間。

這個函數的第一個參數可能會在此標準的將來版本中使用到；所以建議實現不要以任何目的使用這個位置參數。

Date.prototype.toLocaleDateString ( )

此函數返回一個字符串值。字符串中內容是依賴於實現的，但目的是用一種 -- 對應宿主環境的當前語言環境設定的 -- 方便，人類可讀的形式表示當前時區時間的「日期」部分。

這個函數的第一個參數可能會在此標準的將來版本中使用到；所以建議實現不要以任何目的使用這個位置參數。

Date.prototype.toLocaleTimeString ( )

此函數返回一個字符串值。字符串中內容是依賴於實現的，但目的是用一種 -- 對應宿主環境的當前語言環境設定的 -- 方便，人類可讀的形式表示當前時區時間的「時間」部分。

這個函數的第一個參數可能會在此標準的將來版本中使用到；所以建議實現不要以任何目的使用這個位置參數。

Date.prototype.valueOf ( )

valueOf 函數返回一個數字值，它是 this 時間值。

Date.prototype.getTime ( )

1. 返回 this 時間值。

Date.prototype.getFullYear ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 YearFromTime(LocalTime(t)).

Date.prototype.getUTCFullYear ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 YearFromTime(t).

Date.prototype.getMonth ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 MonthFromTime(LocalTime(t)).

Date.prototype.getUTCMonth ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 MonthFromTime(t).

Date.prototype.getDate ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 DateFromTime(LocalTime(t)).

Date.prototype.getUTCDate ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 DateFromTime(t).

Date.prototype.getDay ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 WeekDay(LocalTime(t)).

Date.prototype.getUTCDay ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 WeekDay(t).

Date.prototype.getHours ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 HourFromTime(LocalTime(t)).

Date.prototype.getUTCHours ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 HourFromTime(t).

Date.prototype.getMinutes ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 MinFromTime(LocalTime(t)).

Date.prototype.getUTCMinutes ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 MinFromTime(t).

Date.prototype.getSeconds ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 SecFromTime(LocalTime(t)).

Date.prototype.getUTCSeconds ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 SecFromTime(t).

Date.prototype.getMilliseconds ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 msFromTime(LocalTime(t)).

Date.prototype.getUTCMilliseconds ( )

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 msFromTime(t).

Date.prototype.getTimezoneOffset ( )

返回本地時間和 UTC 時間之間相差的分鐘數。

1. 令 t 爲 this 時間值 .
2. 若是 t 是 NaN, 返回 NaN.
3. 返回 (t − LocalTime(t)) / msPerMinute.

Date.prototype.setTime (time)

1. 令 v 爲 TimeClip(ToNumber(time)).
2. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 v.
3. 返回 v.

Date.prototype.setMilliseconds (ms)

1. 令 t 爲 LocalTime(this 時間值 ) 的結果 .
2. 令 time 爲 MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), ToNumber(ms)).
3. 令 u 爲 TimeClip(UTC(MakeDate(Day(t), time))).
4. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 u.
5. 返回 u.

Date.prototype.setUTCMilliseconds (ms)

1. 令 t 爲 this 時間值 .
2. 令 time 爲 MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), ToNumber(ms)).
3. 令 v 爲 TimeClip(MakeDate(Day(t), time)).
4. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 v.
5. 返回 v.

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

沒指定 ms 參數時的行爲是，彷彿 ms 被指定爲調用 getMilliseconds() 的結果同樣。

1. 令 t 爲 LocalTime(this 時間值 ) 的結果 .
2. 令 s 爲 ToNumber(sec).
3. 若是沒指定 ms , 則令 milli 爲 msFromTime(t); 不然，令 milli 爲 ToNumber(ms).
4. 令 date 爲 MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), s, milli)).
5. 令 u 爲 TimeClip(UTC(date)).
6. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 u.
7. 返回 u.

setSeconds 方法的 length 屬性是 2。

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

沒指定 ms 參數時的行爲是，彷彿 ms 被指定爲調用 getUTCMilliseconds() 的結果同樣。

1. 令 t 爲 this 時間值 .
2. 令 s 爲 ToNumber(sec).
3. 若是沒指定 ms , 則令 milli 爲 msFromTime(t); 不然，令 milli 爲 ToNumber(ms).
4. 令 date 爲 MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), s, milli)).
5. 令 v 爲 TimeClip(date).
6. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 v.
7. 返回 v.

setUTCSeconds 方法的 length 屬性是 2。

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

沒指定 sec 參數時的行爲是，彷彿 ms 被指定爲調用 getSeconds() 的結果同樣。

沒指定 ms 參數時的行爲是，彷彿 ms 被指定爲調用 getMilliseconds() 的結果同樣。

1. 令 t 爲 LocalTime(this 時間值 ) 的結果 .
2. 令 m 爲 ToNumber(min).
3. 若是沒指定 sec , 則令 s 爲 SecFromTime(t); 不然 , 令 s 爲 ToNumber(sec).
4. 若是沒指定 ms , 則令 milli 爲 msFromTime(t); 不然 , 令 milli 爲 ToNumber(ms).
5. 令 date 爲 MakeDate(Day(t), MakeTime(HourFromTime(t), m, s, milli)).
6. 令 u 爲 TimeClip(UTC(date)).
7. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 u.
8. 返回 u.

setMinutes 方法的 length 屬性是 3。

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

沒指定 sec 參數時的行爲是，彷彿 ms 被指定爲調用 getUTCSeconds() 的結果同樣。

沒指定 ms 參數時的行爲是，彷彿 ms 被指定爲調用 getUTCMilliseconds() 的結果同樣。

1. 令 t 爲 this 時間值 .
2. 令 m 爲 ToNumber(min).
3. 若是沒指定 sec , 則令 s 爲 SecFromTime(t); 不然 , 令 s 爲 ToNumber(sec).
4. 若是沒指定 ms , 則令 milli 爲 msFromTime(t); 不然 , 令 milli 爲 ToNumber(ms).
5. 令 date 爲 MakeDate(Day(t), MakeTime(HourFromTime(t), m, s, milli)).
6. 令 v 爲 TimeClip(date).
7. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 v.
8. 返回 v.

setUTCMinutes 方法的 length 屬性是 3。

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

沒指定 min 參數時的行爲是，彷彿 min 被指定爲調用 getMinutes() 的結果同樣。

沒指定 sec 參數時的行爲是，彷彿 ms 被指定爲調用 getSeconds() 的結果同樣。

沒指定 ms 參數時的行爲是，彷彿 ms 被指定爲調用 getMilliseconds() 的結果同樣。

1. 令 t 爲 LocalTime(this 時間值 ) 的結果 .
2. 令 h 爲 ToNumber(hour).
3. 若是沒指定 min , 則令 m 爲 MinFromTime(t); 不然 , 令 m 爲 ToNumber(min).
4. 若是沒指定 sec , 則令 s 爲 SecFromTime(t); 不然 , 令 s 爲 ToNumber(sec).
5. 若是沒指定 ms , 則令 milli 爲 msFromTime(t); 不然 , 令 milli 爲 ToNumber(ms).
6. 令 date 爲 MakeDate(Day(t), MakeTime(h, m, s, milli)).
7. 令 u 爲 TimeClip(UTC(date)).
8. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 u.
9. 返回 u.

setHours 方法的 length 屬性是 4。

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

沒指定 min 參數時的行爲是，彷彿 min 被指定爲調用 getUTCMinutes() 的結果同樣。

沒指定 sec 參數時的行爲是，彷彿 ms 被指定爲調用 getUTCSeconds() 的結果同樣。

沒指定 ms 參數時的行爲是，彷彿 ms 被指定爲調用 getUTCMilliseconds() 的結果同樣。

1. 令 t 爲 this 時間值 .
2. 令 h 爲 ToNumber(hour).
3. 若是沒指定 min , 則令 m 爲 MinFromTime(t); 不然 , 令 m 爲 ToNumber(min).
4. 若是沒指定 sec , 則令 s 爲 SecFromTime(t); 不然 , 令 s 爲 ToNumber(sec).
5. 若是沒指定 ms , 則令 milli 爲 msFromTime(t); 不然 , 令 milli 爲 ToNumber(ms).
6. 令 date 爲 MakeDate(Day(t), MakeTime(h, m, s, milli)).
7. 令 v 爲 TimeClip(date).
8. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 v.
9. 返回 v.

setUTCHours 方法的 length 屬性是 4。

Date.prototype.setDate (date)

1. 令 t 爲 LocalTime(this 時間值 ) 的結果 .
2. 令 dt 爲 ToNumber(date).
3. 令 newDate 爲 MakeDate(MakeDay(YearFromTime(t), MonthFromTime(t), dt), TimeWithinDay(t)).
4. 令 u 爲 TimeClip(UTC(newDate)).
5. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 u.
6. 返回 u.

Date.prototype.setUTCDate (date)

1. 令 t 爲 this 時間值 .
2. 令 dt 爲 ToNumber(date).
3. 令 newDate 爲 MakeDate(MakeDay(YearFromTime(t), MonthFromTime(t), dt), TimeWithinDay(t)).
4. 令 v 爲 TimeClip(newDate).
5. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 v.
6. 返回 v.

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

沒指定 date 參數時的行爲是，彷彿 ms 被指定爲調用 getDate() 的結果同樣。

1. 令 t 爲 LocalTime(this 時間值 ) 的結果 .
2. 令 m 爲 ToNumber(month).
3. 若是沒指定 date , 則令 dt 爲 DateFromTime(t); 不然 , 令 dt 爲 ToNumber(date).
4. 令 newDate 爲 MakeDate(MakeDay(YearFromTime(t), m, dt), TimeWithinDay(t)).
5. 令 u 爲 TimeClip(UTC(newDate)).
6. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 u.
7. 返回 u.

setMonth 方法的 length 屬性是 2。

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

沒指定 date 參數時的行爲是，彷彿 ms 被指定爲調用 getUTCDate() 的結果同樣。

1. 令 t 爲 this 時間值 .
2. 令 m 爲 ToNumber(month).
3. 若是沒指定 date , 則令 dt 爲 DateFromTime(t); 不然 , 令 dt 爲 ToNumber(date).
4. 令 newDate 爲 MakeDate(MakeDay(YearFromTime(t), m, dt), TimeWithinDay(t)).
5. 令 v 爲 TimeClip(newDate).
6. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 v.
7. 返回 v.

setUTCMonth 方法的 length 屬性是 2。

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

沒指定 month 參數時的行爲是，彷彿 ms 被指定爲調用 getMonth() 的結果同樣。

沒指定 date 參數時的行爲是，彷彿 ms 被指定爲調用 getDate() 的結果同樣。

1. 令 t 爲 LocalTime(this 時間值 ) 的結果 ; 但若是 this 時間值是 NaN, 則令 t 爲 +0.
2. 令 y 爲 ToNumber(year).
3. 若是沒指定 month , 則令 m 爲 MonthFromTime(t); 不然 , 令 m 爲 ToNumber(month).
4. 若是沒指定 date , 則令 dt 爲 DateFromTime(t); 不然 , 令 dt 爲 ToNumber(date).
5. 令 newDate 爲 MakeDate(MakeDay(y, m, dt), TimeWithinDay(t)).
6. 令 u 爲 TimeClip(UTC(newDate)).
7. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 u.
8. 返回 u.

setFullYear 方法的 length 屬性是 3。

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

沒指定 month 參數時的行爲是，彷彿 ms 被指定爲調用 getUTCMonth() 的結果同樣。

沒指定 date 參數時的行爲是，彷彿 ms 被指定爲調用 getUTCDate() 的結果同樣。

1. 令 t 爲 this 時間值 ; 但若是 this 時間值是 NaN, 則令 t 爲 +0.
2. 令 y 爲 ToNumber(year).
3. 若是沒指定 month , 則令 m 爲 MonthFromTime(t); 不然 , 令 m 爲 ToNumber(month).
4. 若是沒指定 date , 則令 dt 爲 DateFromTime(t); 不然 , 令 dt 爲 ToNumber(date).
5. 令 newDate 爲 MakeDate(MakeDay(y, m, dt), TimeWithinDay(t)).
6. 令 v 爲 TimeClip(newDate).
7. 設定 this Date 對象的 [[PrimitiveValue]] 內部屬性爲 v.
8. 返回 v.

setUTCFullYear 方法的 length 屬性是 3。

Date.prototype.toUTCString ( )

此函數返回一個字符串值。字符串中內容是依賴於實現的，但目的是用一種方便，人類可讀的形式表示 UTC 時間。

此函數的目的是爲日期時間產生一個比 15.9.1.15 指定的格式更易讀的字符串表示。不必選擇明確的或易於機器解析的格式。若是一個實現沒有一個首選的人類可讀格式，建議使用 15.9.1.15 定義的格式，但用空格而不是「T」分割日期和時間元素。

Date.prototype.toISOString ( )

此函數返回一個表明 --this Date 對象表示的時間的實例 -- 的字符串。字符串的格式是 15.9.1.15 定義的日期時間字符串格式。字符串中包含全部的字段。字符串表示的時區老是 UTC，用後綴 Z 標記。若是 this 對象的時間值不是有限的數字值，拋出一個 RangeError 異常。

Date.prototype.toJSON ( key )

此函數爲 JSON.stringify (15.12.3) 提供 Date 對象的一個字符串表示。

當用參數 key 調用 toJSON 方法，採用如下步驟：

1. 令 O 爲 以 this 值爲參數調用 toObject 的結果。
2. 令 tv 爲 ToPrimitive(O, hint Number).
3. 若是 tv 是一個數字值且不是有限的 , 返回 null.
4. 令 toISO 爲以 "toISOString" 爲參數調用 O 的 [[Get]] 內部方法的結果。
5. 若是 IsCallable(toISO) 是 false, 拋出一個 TypeError 異常 .
6. O 做爲以 this 值並用空參數列表調用 toISO 的 [[Call]] 內部方法，返回結果。

參數是被忽略的。

toJSON 函數是故意設計成通用的；它不須要其 this 值必須是一個 Date 對象。所以，它能夠做爲方法轉移到其餘類型的對象上。但轉移到的對象必須有 toISOString 方法。對象可自由使用參數 key 來過濾字符串化的方式。

Date 實例的屬性

Date 實例從 Date 原型對象繼承屬性，Date 實例的 [[Class]] 內部屬性值是 "Date"。Date 實例還有一個 [[PrimitiveValue]] 內部屬性。

[[PrimitiveValue]] 內部屬性是表明 this Date 對象的時間值。

RegExp ( 正則表達式 ) 對象

一個 RegExp 對象包含一個正則表達式和關聯的標誌。

正則表達式的格式和功能是以 Perl 5 程序語言的正則表達式設施爲藍本的。

模式

RegExp 構造器對輸入模式字符串應用如下文法。若是文法沒法將字符串解釋爲 Pattern 的一個展開形式，則發生錯誤。

語法：

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

模式語義

使用下面描述的過程來將一個正則表達式模式轉換爲一個內部程序。實現使用比下面列出的算法跟高效的算法是被鼓勵的，只要結果是相同的。內部程序用做 RegExp 對象的 [[Match]] 內部屬性的值。

表示法

後面的描述用到如下變量：

• input，是正則表達式模式要匹配的字符串。符號 input[n] 表示 input 的第 n 個字符，這裏的 n 能夠是 0( 包括 ) 和 InputLength( 不包括 ) 之間的。
• InputLength，是 input 字符串裏的字符數目。
• NcapturingParens，是在模式中左捕獲括號的總數 ( 即，Atom :: ( Disjunction ) 產生式被展開的總次數 )。一個左捕獲括號是匹配產生式 Atom :: ( Disjunction ) 中的 終結符 ( 的任意 ( 模式字符。
• IgnoreCase，是 RegExp 對象的 ignoreCase 屬性的設定值。
• Multiline，是 RegExp 對象的 multiline 屬性的設定值。

此外，後面的描述用到如下內部數據結構：

• CharSet，是字符的一個數學上的集合。
• State，是一個有序對 (endIndex, captures) ，這裏 endIndex 是一個整數，captures 是有 NcapturingParens 個值的內部數組。 States 用來表示正則表達式匹配算法裏的局部匹配狀態。endIndex 是到目前爲止模式匹配的最後一個輸入字符的索引值加上一，而 captures 持有捕獲括號的捕獲結果。captures 的第 n 個元素是一個表明第 n 個捕獲括號對捕獲值的字符串，或若是第 n 個捕獲括號對未能達到目的，captures 的第 n 個元素是 undefined。因爲回溯，不少 States 可能在匹配過程當中的任什麼時候候被使用。
• MatchResult，值爲 State 或表示匹配失敗特殊 token--failure。
• Continuation 程序，是一個內部閉包（即，一些參數已經綁定了值的內部程序），它用一個 State 參數返回一個 MatchResult 結果。 若是一個內部閉包引用的變量是綁定在建立這個閉包的函數裏 , 則閉包使用在建立閉包時的這些變量值。Continuation 嘗試從其 State 參數給定的中間狀態開始用模式的其他部分（由閉包的已綁定參數指定）匹配輸入字符串。若是匹配成功，Continuation 返回最終的 State；若是匹配失敗，Continuation 返回 failure。
• Matcher 程序，是一個須要兩個參數 -- 一個 State 和一個 Continuation -- 的內部閉包，它返回一個 MatchResult 結果。 Matcher 嘗試從其 State 參數給定的中間狀態開始用模式的一箇中間子模式（由閉包的已綁定參數指定）匹配輸入字符串。Continuation 參數是去匹配模式中剩餘部分的閉包。用模式的子模式匹配以後得到一個新 State，以後 Matcher 用新 State 去調用 Continuation 來測試模式的剩餘部分是否能匹配成功。若是匹配成功，matcher 返回 Continuation 返回的 State；若是匹配失敗，Matcher 嘗試用不一樣的可選位置重複調用 Continuation，直到 Continuation 匹配成功或用盡全部的可選位置。
• AssertionTester 程序，是須要一個 State 參數並返回一個布爾結果的內部閉包。 AssertionTester 測試輸入字符串的當前位置是否知足一個特定條件 ( 由閉包的已綁定參數指定 ) ，若是匹配了條件，返回 true；若是不匹配，返回 false。
• EscapeValue，是一個字符或一個整數。EscapeValue 用來表示 DecimalEscape 轉移序列的解釋結果：一個字符 ch 在轉義序列裏時，它被解釋爲字符 ch；而一個整數 n 在轉義序列裏時，它被解釋爲對第 n 個捕獲括號組的反響引用。

模式（Pattern）

產生式 Pattern :: Disjunction 按照如下方式解釋執行 :

1. 解釋執行 Disjunction ，得到一個 Matcher m.
2. 返回一個須要兩個參數的內部閉包，一個字符串 str 和一個整數 index, 執行方式以下 :
   1. 令 Input 爲給定的字符串 str。15.10.2 中的算法都將用到此變量。
   2. 令 InputLength 爲 Input 的長度。15.10.2 中的算法都將用到此變量。
   3. 令 c 爲 一個 Continuation ，它始終對它的任何 State 參數都返回成功匹配的 MatchResult。
   4. 令 cap 爲一個有 NcapturingParens 個 undefined 值的內部數組，索引是從 1 到 NcapturingParens。
   5. 令 x 爲 State (index, cap).
   6. 調用 m(x, c)，並返回結果 .

一個模式解釋執行（「編譯」）爲一個內部程序值。RegExp.prototype.exec 可將這個內部程序應用於一個字符串和字符串的一個偏移位，來肯定從這個偏移位開始 , 模式是否可以匹配，若是能匹配，將返回捕獲括號的值。15.10.2 中的算法被設計爲只在編譯一個模式時可拋出一個 SyntaxError 異常；反過來講，一旦模式編譯成功，應用編譯生成的內部程序在字符串中尋找匹配結果時不可拋出異常（除非是宿主定義的可在任什麼時候候出現的異常，如內存不足）。

析取（Disjunction）

產生式 Disjunction :: Alternative 的解釋執行，是解釋執行 Alternative 來得到 Matcher 並返回這個 Matcher。

產生式 Disjunction :: Alternative | Disjunction 按照如下方式解釋執行：

1. 解釋執行 Alternative 來得到一個 Matcher m1.
2. 解釋執行 Disjunction 來得到一個 Matcher m2.
3. 返回一個須要兩個參數的內部閉包 Matcher ，參數分別是一個 State x 和一個 Continuation c，此內部閉包的執行方式以下：
   1. 調用 m1(x, c) 並令 r 爲其結果。
   2. 若是 r 不是 failure, 返回 r.
   3. 調用 m2(x, c) 並返回其結果。

正則表達式運算符 | 用來分隔兩個選擇項。模式首先嚐試去匹配左側的 Alternative( 緊跟着是正則表達式的後續匹配結果 )；若是失敗，嘗試匹配右側的 Disjunction（緊跟着是正則表達式的後續匹配結果）。若是左側的 Alternative，右側的 Disjunction，還有後續匹配結果，全都有可選的匹配位置，則後續匹配結果的全部可選位置是在左側的 Alternative 移動到下一個可選位置以前肯定的。若是左側 Alternative 的可選位置被用盡了，右側 Disjunction 試圖替代左側 Alternative。一個模式中任何被 | 跳過的捕獲括號參數 undefined 值還代替字符串。所以，如：

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

返回結果是 "a"，而不是 "ab"。此外

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

返回的數組是

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

而不是

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

選擇項（Alternative）

產生式 Alternative :: [empty] 解釋執行返回一個 Matcher，它須要兩個參數，一個 State x 和 一個 Continuation c，並返回調用 c(x) 的結果。

產生式 Alternative :: Alternative Term 按照以下方式解釋執行：

1. 解釋執行 Alternative 來得到一個 Matcher m1.
2. 解釋執行 Term 來得到一個 Matcher m2.
3. 返回一個內部閉包 Matcher，它須要兩個參數，一個 State x 和一個 Continuation c, 執行方式以下 :
   1. 建立一個 Continuation d ，它須要一個 State 參數 y ，返回調用 m2(y, c) 的結果 .
   2. 調用 m1(x, d) 並返回結果 .

連續的 Term 試着同時去匹配連續輸入字符串的連續部分。若是左側的 Alternative，右側的 Term，還有後續匹配結果，全都有可選的匹配位置，則後續匹配結果的全部可選位置是在右側的 Term 移動到下一個可選位置以前肯定的，而且則右側的 Term 的全部可選位置是在左側的 Alternative 移動到下一個可選位置以前肯定的。

匹配項（Term）

產生式 Term :: Assertion 解釋執行，返回一個須要兩個參數 State x 和 Continuation c 的內部閉包 Matcher，它的執行方式以下：

1. 解釋執行 Assertion 來得到一個 AssertionTester t.
2. 調用 t(x) 並令 r 爲調用結果布爾值 .
3. 若是 r 是 false, 返回 failure.
4. 調用 c(x) 並返回結果 .

產生式 Term :: Atom 的解釋執行方式是，解釋執行 Atom 來得到一個 Matcher 並返回這個 Matcher。

產生式 Term :: Atom Quantifier 的解釋執行方式以下 :

1. 解釋執行 Atom 來得到一個 Matcher m.
2. 解釋執行 Quantifier 來得到三個結果值：一個整數 min, 一個整數 ( 或 ∞) max, 和一個布爾值 greedy.
3. 若是 max 是有限的 且小於 min, 則拋出一個 SyntaxError 異常 .
4. 令 parenIndex 爲整個正則表達式中在此產生式 Term 展開形式左側出現的左匹配括號的數目。這是此產生式 Term 前面展開的 Atom :: ( Disjunction ) 產生式總數與此 Term 裏面的 Atom :: ( Disjunction ) 產生式總數之和。
5. 令 parenCount 爲在展開的 Atom 產生式裏的左捕獲括號數目。這是 Atom 產生式裏面 Atom :: ( Disjunction ) 產生式的總數。
6. 返回一個須要兩個參數 State x 和 Continuation c 的內部閉包 Matcher，執行方式以下 :
   1. 調用 RepeatMatcher(m, min, max, greedy, x, c, parenIndex, parenCount) ，並返回結果 .

抽象操做 RepeatMatcher 須要八個參數，一個 Matcher m, 一個整數 min, 一個整數 ( 或 ∞) max, 一個布爾值 greedy, 一個 State x, 一個 Continuation c, 一個整數 parenIndex, 一個整數 parenCount, 執行方式以下 :

1. 若是 max 是零 , 則調用 c(x) ，並返回結果 .
2. 建立須要一個 State 參數 y 的內部 Continuation 閉包 d ，執行方式以下 :
   1. 若是 min 是零 且 y 的 endIndex 等於 x 的 endIndex, 則返回 failure.
   2. 若是 min 是零，則令 min2 爲零 ; 不然令 min2 爲 min–1.
   3. 若是 max 是 ∞, 則令 max2 爲 ∞; 不然令 max2 爲 max–1.
   4. 調用 RepeatMatcher(m, min2, max2, greedy, y, c, parenIndex, parenCount) ，並返回結果 .
3. 令 cap 爲 x 的捕獲內部數組的一個拷貝。
4. 對全部知足條件 parenIndex < k 且 k ≤ parenIndex+parenCount 的整數 k，設定 cap[k] 爲 undefined。
5. 令 e 爲 x 的 endIndex.
6. 令 xr 爲 State 值 (e, cap).
7. 若是 min 不是零 , 則調用 m(xr, d)，並返回結果 .
8. 若是 greedy 是 false, 則
   1. 令 z 爲調用 c(x) 的結果 .
   2. 若是 z 不是 failure, 返回 z.
   3. 調用 m(xr, d)，並返回結果 .
9. 令 z 爲調用 m(xr, d) 的結果 .
10. 若是 z 不是 failure, 返回 z.
11. 調用 c(x) ，並返回結果 .

一個Atom後跟Quantifier是用Quantifier指定重複的次數。Quantifier能夠是非貪婪的，這種狀況下Atom模式在可以匹配序列的狀況下儘量重複少的次數， 或者它能夠使貪婪的，這種狀況下Atom模式在可以匹配序列的狀況下儘量重複多的次數，Atom模式重複的是他本身而不是它匹配的字符串，因此不一樣次的重複中Atom能夠匹配不一樣的子串。

假如Atom和後續的正則表達式都有選擇餘地，Atom首先儘可能多匹配（或者儘可能少，假如是非貪婪模式）在最後一次Atom的重複中移動到下一個選擇前，全部的後續中的選項<都應該被嘗試。 在倒數第二次（第n–1次）Atom的重複中移動到下一個選擇前，全部Atom的選項在最後一次（第n次）重複中應該被嘗試。這樣能夠得出更多或者更少的重複次數可行。 這些狀況在開始匹配下一個選項的第(n-1)次重複時已經被窮舉，以此類推。

比較

/a[a-z]{2,4}/.exec("abcdefghi")

它返回"abcde"而

/a[a-z]{2,4}?/.exec("abcdefghi")

它返回"abc".

再考慮

/(aa|aabaac|ba|b|c)*/.exec("aabaac")

按照上面要求的選擇數，它返回

["aaba", "ba"]

而非如下：

["aabaac", "aabaac"] ["aabaac", "c"]

上面要求的選擇數能夠用來編寫一個計算兩個數最大公約數的正則表達式(用單一字符重複數表示). 如下實例用來計算10和15的最大公約數:

"aaaaaaaaaa,aaaaaaaaaaaaaaa".replace(/^(a+)\1*,\1+$/,"$1")

它返回最大公約數的單一字符重複數表示"aaaaa".

RepeatMatcher的步驟4 每重複一次就清除Atom的捕獲。咱們能夠看到它在正則表達式中的行爲：

/(z)((a+)?(b+)?(c))*/.exec("zaacbbbcac")

它返回數組

["zaacbbbcac", "z", "ac", "a", undefined, "c"]

而非

["zaacbbbcac", "z", "ac", "a", "bbb", "c"]

由於最外面的*每次迭代都會清除全部括起來的Atom中所含的捕獲字符串，在這個例子中就是包含編號爲2,3,4,5的捕獲字符串。

RepeatMatcher的d閉包狀態步驟1，一旦重複的最小次數達到，任何Atom匹配空String的擴展再也不會匹配到重複中。這能夠避免正則引擎在匹配相似下面的模式時掉進無限循環：

/(a*)*/.exec("b")

或者稍微複雜一點：

/(a*)b\1+/.exec("baaaac")

它返回數組：

["b", ""]

Assertion

產生式Assertion :: ^ 解釋執行返回一個 AssertionTester ， 它須要1個參數 State x，並按以下算法執行：

1. 使 e 爲 x的 endIndex
2. 若 e = 0， 返回 true
3. 若 Multiline 爲 false，返回false
4. 若 Input[e - 1] 的字符爲 LineTerminator，返回 true
5. 返回false

產生式Assertion :: $ 解釋執行返回一個 AssertionTester ， 它須要1個參數 State x，並按以下算法執行：

1. 使 e 爲 x的 endIndex
2. 若 e = InputLength， 返回 true
3. 若 Multiline 爲 false，返回false
4. 若 Input[e - 1] 的字符爲 LineTerminator，返回 true
5. 返回false

產生式Assertion :: \ b 解釋執行返回一個 AssertionTester ， 它須要1個參數 State x，並按以下算法執行：

1. 使 e 爲 x的 endIndex
2. 調用IsWordChar(e–1)，返回Boolean值賦給a
3. 調用IsWordChar(e)，返回Boolean值賦給b
4. 若 a 爲true，b爲false，返回true
5. 若 b 爲false，b爲true，返回true
6. 若 Input[e - 1] 的字符爲 LineTerminator，返回 true
7. 返回false

產生式Assertion :: \ B 解釋執行返回一個 AssertionTester ， 它須要1個參數 State x，並按以下算法執行：

1. 使 e 爲 x的 endIndex
2. 調用IsWordChar(e–1)，返回Boolean值賦給a
3. 調用IsWordChar(e)，返回Boolean值賦給b
4. 若 a 爲true，b爲false，返回false
5. 若 b 爲false，b爲true，返回false
6. 若 Input[e - 1] 的字符爲 LineTerminator，返回 true
7. 返回true

產生式Assertion :: (? = Disjunction) 按以下算法執行：

1. 執行Disjunction ，獲得 Matcher m
2. 返回一個須要兩個參數的內部閉包 Matcher ，參數分別是一個 State x 和一個 Continuation c，此內部閉包的執行方式以下：：
   1. 使 d 爲一個Continuation，它始終對它的任何 State 參數都返回成功匹配的 MatchResult
   2. 調用m(x, d)，令r爲其結果
   3. 若r爲failure，返回 failure
   4. 使y 爲 r的State
   5. 使cap 爲 r的captures
   6. 使xe爲 r的endIndex
   7. 使z爲 State (xe, cap)
   8. 調用c(z)，返回結果

產生式Assertion :: (? ! Disjunction) 按以下算法執行：

1. 執行Disjunction ，獲得 Matcher m
2. 返回一個須要兩個參數的內部閉包 Matcher ，參數分別是一個 State x 和一個 Continuation c，此內部閉包的執行方式以下：：
   1. 使 d 爲一個Continuation，它始終對它的任何 State 參數都返回成功匹配的 MatchResult
   2. 調用m(x, d)，令r爲其結果
   3. 若r爲failure，返回 failure
   4. 調用c(z)，返回結果

抽象操做 IsWordChar ，擁有一個integer類型的參數e，按以下方式執行：

1. 若 e == -1 或 e == InputLength，返回 false
2. 令 c 爲 Input[e]
3. 若 c 爲 如下63個字符，返回 true

a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9 _

1. 返回 false

Quantifier

產生式 Quantifier :: QuantifierPrefix 按以下方式執行：

1. 執行 QuantifierPrefix 獲得 2個數 min 和 max（或 ∞）
2. 返回 min，max，true

產生式 Quantifier :: QuantifierPrefix ? 按以下方式執行：

1. 執行 QuantifierPrefix 獲得 2個數 min 和 max（或 ∞）
2. 返回 min，max，true

產生式 Quantifier :: * 返回 0 和 ∞

產生式 Quantifier :: + 返回 1 和 ∞

產生式 Quantifier :: ? 返回 0 和 1

產生式 Quantifier :: { DecimalDigits } 按以下方式執行：

1. 令 i 爲 DecimalDigits 的 MV
2. 返回2個結果 i，i

產生式 Quantifier :: { DecimalDigits, } 按以下方式執行：

1. 令 i 爲 DecimalDigits 的 MV
2. 返回2個結果 i，∞

產生式 Quantifier :: { DecimalDigits, DecimalDigits} 按以下方式執行：

1. 令 i 爲 DecimalDigits 的 MV
2. 令 j 爲 DecimalDigits 的 MV
3. 返回2個結果 i，j

Atom

產生式 Atom :: PatternCharacter 執行方式以下：

1. 令 ch 爲 PatternCharacter表示的字符
2. 令 A 爲單元素 CharSet，包含ch
3. 調用 CharacterSetMatcher(A, false)，返回Matcher

產生式 Atom :: . 執行方式以下：

1. 令 A爲 除去 LineTerminator外的全部字符
2. 調用 CharacterSetMatcher(A, false)，返回Matcher

產生式 Atom :: \ AtomEscape 經過執行 AtomEscape 返回 Matcher。

產生式 Atom :: CharacterClass 執行方式以下：

1. 執行 CharacterClass 獲得 CharSet A 和 Boolean invert
2. 調用 CharacterSetMatcher(A, false)，返回Matcher

產生式 Atom :: ( Disjunction ) 執行方式以下：

1. 執行 Disjunction 獲得 Matcher
2. 令 parenIndex 爲 在整個正則表達式中從產生式展開初始化左括號時，當前展開左捕獲括號的索引。parenIndex 爲在產生式的 Atom 被展開以前，Atom :: ( Disjunction )產生式被展開的次數，加上Atom :: ( Disjunction ) 閉合 這個Atom的次數
3. 返回一個內部閉包 Matcher，擁有2個參數：一個 State x 和 Continuation c，執行方式以下：
   1. 建立內容閉包 Continuation d，參數爲State y，並按以下方式執行：
      1. 令cap爲y的capture數組的一個拷貝
      2. 令xe爲x的endIndex
      3. 令ye爲y的endIndex
      4. 令s爲Input從索引xe（包括）至 ye（不包括）範圍的新建立的字符串
      5. 令s爲cap[parenIndex+1]
      6. 令z爲 State (ye, cap)
      7. 調用c(z)，返回其結果
   2. 執行m(x, d)，返回其結果

產生式 Atom :: ( ? : Disjunction ) 經過執行Disjunction 獲得並返回一個Matcher。

抽象操做 CharacterSetMatcher ，擁有2個參數：一個 CharSet A 和 Boolean invert標誌，按以下方式執行：

1. 返回一個內部閉包 Matcher，擁有2個參數：一個 State x 和 Continuation c，執行方式以下：
   1. 令e爲x的endIndex
   2. 若e == InputLength，返回failure
   3. 令ch爲字符Input[e]
   4. 令cc爲Canonicalize(ch)的結果
   5. 若invert爲false，若是A中不存在a使得Canonicalize(a) == cc，返回failure
   6. 若invert爲true，若是A中存在a使得Canonicalize(a) == cc， 返回failure
   7. 令cap爲x的內部captures數組
   8. 令y爲 State (e+1, cap)
   9. 調用c(y)，返回結果

抽象操做 Canonicalize，擁有一個字符參數 ch，按以下方式執行：

1. 若IgnoreCase爲false，返回ch
2. 令u爲ch轉換爲大寫後的結果，彷彿經過調用標準內置方法String.prototype.toUpperCase
3. 若u不含單個字符，返回ch
4. 令cu爲u的字符
5. 若ch的code unit value>= 128 且 cu的code unit value<= 128，返回ch
6. 返回cu

( Disjunction ) 的括號 用來組合 Disjunction 模式，並保存匹配結果。該結果能夠經過後向引用（一個非零數，前置\），在一個替換字符串中的引用，或者做爲正則表達式內部匹配過程的部分結果。使用(?: Disjunction )來避免括號的捕獲行爲。

(? = Disjunction )指定一個零寬正向預查。爲了保證匹配成功，其 Disjunction 必須首先可以匹配成功，但在匹配後續字符前，其當前位置會不變。若是 Disjunction 能在當前位置以多種方式匹配，那麼只會取第一次匹配的結果。不像其餘正則表達式運算符，(?= 內部不會回溯（這個特殊的行爲是從Perl繼承過來的）。在 Disjunction 含有捕獲括號，模式的後續字符包括後向引用時匹配結果會有影響。

例如，

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

會匹配第一個b後的空白字符串，獲得：

["", "aaa"]

爲了說明預查不會回溯，

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

獲得：

["aba", "a"]

而不是：

["aaaba", "a"]

(?! Disjunction ) 指定一個零寬正向否認預查。爲了保證匹配成功，其 Disjunction 必須首先可以匹配失敗，但在匹配後續字符前，其當前位置會不變。Disjunction 能含有捕獲括號，可是對這些捕獲分組的後向引用只在Disjunction中有效。在當前模式的其餘位置後向引用捕獲分組都會返回undefined。由於否認預查必須知足預查失敗來保證模式成功匹配。例如，

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

搜索a，其後有n個a，一個b，n個a（\2指定）和一個c。第二個\2位於負向預查模式的外部，所以它匹配undefined，且老是成功的。整個表達式返回一個數組：

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

在發生比較前，一次不區分大小寫的匹配中全部的字符都會隱式轉換爲大寫。然而，若是某些單個字符在轉換爲大寫時擴展爲多個字符，那麼該字符會保持原樣。當某些非ASCII字符在轉換爲大寫時變成ASCII字符，該字符也會保持原樣。這樣會阻止Unicode字符（例如\u0131和\u017F）匹配正則表達式 （例如僅匹配ASCII字符的正則表達式/[a z]/i）。並且，若是轉換容許，/[^\W]/i會匹配除去i或s外的每個a，b，......，h。

AtomEscape

產生式 AtomEscape :: DecimalEscape 執行方式以下：

1. 執行DecimalEscape獲得 EscapeValue E
2. 若是E爲一個字符，
   1. 令ch爲E的字符
   2. 令A爲包含ch字符的單元素字符集CharSet
   3. 調用 CharacterSetMatcher(A, false) 返回Matcher結果
3. E必須是一個數。令n爲該數。
4. 若是n=0或n>NCapturingParens，拋出 SyntaxError 異常
5. 返回一個內部閉包 Matcher，擁有2個參數：一個 State x 和 Continuation c，執行方式以下：
   1. 令cap爲x的captures內部數組
   2. 令s爲cap[n]
   3. 若是s爲undefined，調用c（x），返回結果
   4. 令e爲x的endIndex
   5. 令len爲s的length
   6. 令f爲e+len
   7. 若是f>InputLength，返回failure
   8. 若是存在位於0（包括）到len（不包括）的整數i使得 Canonicalize(s[i])等於 Canonicalize(Input [e+i])，那麼返回failure
   9. 令y爲State(f, cap)
   10. 調用c(y)，返回結果

產生式 AtomEscape :: CharacterEscape 執行方式以下：

1. 執行CharacterEscape 獲得一個ch字符
2. 令A爲包含ch字符的單元素字符集CharSet
3. 調用 CharacterSetMatcher(A, false) 返回Matcher結果

產生式 AtomEscape :: CharacterClassEscape 執行方式以下：

1. 執行CharacterClassEscape 獲得一個CharSet A
2. 調用 CharacterSetMatcher(A, false) 返回Matcher結果

格式\後爲非零數n的轉義序列匹配捕獲分組的第n次匹配結果。若是正則表達式少於n個捕獲括號，會報錯。若是正則表達式大於等於n個捕獲括號，因爲沒有捕獲到任何東西，致使第n個捕獲分組結果爲undefined，那麼後向引用老是成功的。

CharacterEscape

產生式 CharacterEscape :: ControlEscape 執行返回一個根據表23定義的字符：

ControlEscape字符轉義值

ControlEscape	字符編碼值	名稱	符號
t	\u0009	水平製表符	<HT>
n	\u000A	進行（新行）	<LF>
v	\u000B	豎直製表符	<VT>
f	\u000C	進紙	<FF>
r	\u000D	回車	<CR>

產生式 CharacterEscape :: ch ControlLetter 執行過程以下：

1. 令ch爲經過ControlLetter表示的字符
2. 令i爲ch的code unit value
3. 令j爲i/32的餘數
4. 返回j

產生式 CharacterEscape :: HexEscapeSequence 執行HexEscapeSequence的CV，返回其字符結果。

產生式 CharacterEscape :: UnicodeEscapeSequence 執行UnicodeEscapeSequence的CV，返回其字符結果。

產生式 CharacterEscape :: IdentityEscape執行返回由IdentityEscape表示的字符。

DecimalEscape

產生式 DecimalEscape :: DecimalIntegerLiteral [lookahead ∉ DecimalDigit] 按以下方式執行：

1. 令i爲DecimalIntegerLiteral的CV值
2. 若是i爲0，返回包含一個<NUL>字符（Unicode值爲0000）的EscapeValue
3. 返回包含整數i的EscapeValue

「the MV of DecimalIntegerLiteral」在7.8.3節定義。

若是\後面是一個數字，且首位爲0，那麼，該轉義序列被認爲是一個後向引用。若是n比在整個正則表達式左捕獲括號個數大，那麼會出錯。\0 表示 <NUL>字符，其後不能再有數字。

CharacterClassEscape

產生式 CharacterClassEscape :: d執行返回包含0到9之間的十元素字符集。

產生式 CharacterClassEscape :: D執行返回不包括 CharacterClassEscape :: d的字符集。

產生式 CharacterClassEscape :: s執行返回包含 WhiteSpace 或 LineTerminator 產生式右部分字符的字符集。

產生式 CharacterClassEscape :: S執行返回不包括 CharacterClassEscape :: s的字符集。

產生式 CharacterClassEscape :: w執行返回包含以下63個字符的字符集：

a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9 _

產生式 CharacterClassEscape :: W執行返回不包括CharacterClassEscape :: w的字符集。

CharacterClass

產生式 CharacterClass :: [ [lookahead ∉ {^}] ClassRanges ] 經過執行ClassRanges得到並返回這個CharSet和Boolean false。

產生式 CharacterClass :: [ ^ ClassRanges ] 經過執行ClassRanges得到並返回這個CharSet和Boolean true。

ClassRanges

產生式 ClassRanges :: [empty]執行返回一個空的CharSet。

產生式 ClassRanges :: NonemptyClassRanges 經過執行 NonemptyClassRanges 得到並返回這個CharSet。

NonemptyClassRanges

產生式 NonemptyClassRanges :: ClassAtom 經過執行ClassAtom得到一個CharSet並返回這個CharSet。

產生式 NonemptyClassRanges :: ClassAtom NonemptyClassRangesNoDash 按以下方式執行：

1. 執行 ClassAtom 獲得一個CharSet A
2. 執行 NonemptyClassRangesNoDash 獲得一個CharSet B
3. 返回A與B的並集

產生式 NonemptyClassRanges :: ClassAtom - ClassAtom ClassRanges 按以下方式執行：

1. 執行第一個ClassAtom 獲得一個CharSet A
2. 執行第二個ClassAtom 獲得一個CharSet B
3. 執行ClassRanges 獲得一個CharSet C
4. 調用 CharacterRange(A, B)，令D爲其結果CharSet
5. 返回D與C的並集

抽象操做 CharacterRange，擁有2個CharSet參數A和B，執行方式以下：

1. 若是A或B爲空，拋出SyntaxError異常
2. 令a爲CharSet A的一個字符
3. 令b爲CharSet B的一個字符
4. 令i爲a的code unit value
5. 令j爲b的code unit value
6. 若是i>j，拋出SyntaxError異常
7. 返回位於在i到j（包括邊界）之間的全部字符的字符集

NonemptyClassRangesNoDash

產生式NonemptyClassRangesNoDash :: ClassAtom 執行過程是執行ClassAtom產生一個CharSet而且返回這個CharSet。

產生式NonemptyClassRangesNoDash :: ClassAtomNoDash NonemptyClassRangesNoDash 按如下方式執行：

1. 執行ClassAtomNoDash產生CharSet A
2. 執行NonemptyClassRangesNoDash產生CharSet B
3. 返回CharSet A和B的並集

產生式NonemptyClassRangesNoDash :: ClassAtomNoDash - ClassAtom ClassRanges 按如下方式執行：

1. 執行ClassAtomNoDash產生CharSet A
2. 執行ClassAtom產生CharSet B
3. 執行ClassRanges產生CharSet C
4. 調用CharacterRange(A, B)並設CharSet D爲結果。
5. 返回CharSet D和C的並集

ClassRanges能夠拆分紅單獨的ClassAtom且/或兩個用減號分隔的ClassAtom。在後面的狀況下ClassAtom包含第一個到第二個ClassAtom間的全部字符。 若是兩個ClassAtom之一不是表示一個單獨字符（例如其中一個是\w）或者第一個ClassAtom的字符編碼值比第二個ClassAtom的字符編碼值大則發生錯誤。

即便匹配忽略大小寫，區間兩端的大小寫在區分哪些字符屬於區間時仍然有效。這意味着，例如模式/[E-F]/僅僅匹配E, F, e, 和 f。/[E-f]/i則匹配全部大寫和小寫的ASCII字母以及[， \， ]， ^， _， 和 `

-字符可能被當作字面意思或者表示一個區間，它做爲ClassRange的開頭或者結尾、在區間指定開頭或者結尾，或者緊跟一個區間指定的時候被當作字面意思。

ClassAtom

產生式 ClassAtom :: - 執行返回包含單個字符 - 的字符集。

產生式 ClassAtom :: ClassAtomNoDash 經過執行 ClassAtomNoDash 得到並返回這個 CharSet。

ClassAtomNoDash

產生式 ClassAtomNoDash :: SourceCharacter 不包括\，]，- 執行返回包含由 SourceCharacter 表示的字符的單元素字符集。

產生式 ClassAtomNoDash :: \ ClassEscape 經過執行ClassEscape 獲得並返回這個CharSet。

ClassEscape

產生式 ClassEscape :: DecimalEscape 按以下方式執行：

1. 執行 DecimalEscape 獲得 EscapeValue E
2. 若是E不是一個字符，拋出 SyntaxError異常
3. 令ch爲E的字符
4. 返回包含字符ch的單元素CharSet

產生式 ClassEscape :: b 執行返回包含一個<BS>字符（Unicode值0008）的字符集。

產生式 ClassEscape :: CharacterEscape 經過執行 CharacterEscape 得到一個字符Charset並返回包含該字符的單元素字符集CharSet。

產生式 ClassEscape :: CharacterClassEscape 經過執行 CharacterClassEscape 得到並返回這個CharSet。

ClassAtom 能夠使用除\b，\B，後向引用外的轉義序列。在CharacterClass中，\b表示退格符。然而，\B和後向引用會報錯。一樣，在一個ClassAtom中使用後向引用會報錯。

The RegExp Constructor Called as a Function

RegExp(pattern, flags)

若是pattern是一個對象R，其內部屬性[[Class]]爲 RegExp且flags 爲undefined，返回R。不然，調用內置RegExp構造器，經過表達式 new RegExp（pattern，flags）返回由該構造器構造的對象。

The RegExp Constructor

當RegExp做爲 new 表達式一部分調用時，它是一個構造器，用來初始化一個新建立的對象。

new RegExp(pattern, flags)

若是 pattern 是一個對象R，其內部 [[CLASS]] 屬性爲RegExp，且 flags 爲 undefined，那麼，令 P 爲 pattern 和令 F 爲 flags 用來構造 R。若是pattern是一個對象R，其內部[[CLASS]]屬性爲RegExp，且flags爲undefined，那麼，拋出TypeError異常。不然，若是pattern爲undefined且ToString（pattern），令P爲空的字符串；若是flags爲undefined且ToString（flags）令F爲空字符串。

若是字符P不知足Pattern語義，那麼拋出SyntaxError異常。不然，令新構造的對象擁有內部[[Match]]屬性，該屬性經過執行（編譯）字符P做爲在15.10.2節描述的Pattern。

若是F含有除「g」,「i」，「m」外的任意字符，或者F中包括出現屢次的字符，那麼，拋出SyntaxError異常。

若是SyntaxError異常未拋出，那麼：

令S爲一個字符串，其等價於P表示的Pattern，S中的字符按以下描述進行轉義。這樣，S可能或者不會與P或者pattern相同；然而，由執行S做爲一個Pattern的內部處理程序必須和經過構造對象的內部[[Match]]屬性的內部處理程序徹底相同。

若是pattern裏存在字符/或者\，那麼這些字符應該被轉義，以確保由「/」，S，「/」構成的的字符串的S值有效，並且F能被解析（在適當的詞法上下文中）爲一個與構造的正則表達式行爲徹底相同的 RegularExpressionLiteral 。例如，若是P是「/」，那麼S應該爲「\/」或「\u002F」，而不是「/」，由於F後的 /// 會被解析爲一個 SingleLineComment，而不是一個 RegularExpressionLiteral。 若是P爲空字符串，那麼該規範定義爲令S爲「(?:)」。

這個新構造對象的以下屬性爲數據屬性，其特性在15.10.7中定義。各屬性的[[Value]]值按以下方式設置：

其source屬性置爲S。

其global屬性置爲一個Boolean值。當F含有字符g時，爲true，不然，爲false。

其ignoreCase屬性置爲一個Boolean值。當F含有字符i時，爲true，不然，爲false。

其multiline屬性置爲一個Boolean值。當F含有字符m時，爲true，不然，爲false。

其lastIndex屬性置爲0。

其內部[[Prototype]]屬性置爲15.10.6中定義的內置RegExp原型對象。

其內部[[Class]]屬性置爲「RegExp」。

若是pattern爲 StringLiteral，通常的轉義字符替換髮生在被RegExp處理前。若是pattern必須含有RegExp識別的轉義字符，那麼當構成 StringLiteral的內容時，爲了防止被移除\被移除，在 StringLiteral中的任何\必須被轉義

Properties of the RegExp Constructor

RegExp構造器的[[Prototype]]值爲內置Function的原型（15.3.4）。

除了內部的一些屬性和length屬性（其值爲2），RegExp構造器還有以下屬性：

RegExp.prototype

RegExp.prototype的初始值爲RegExp的原型（15.10.6）。

該屬性有這些特性： { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Properties of the RegExp Prototype Object

RegExp的原型的內部[[Prototype]]屬性爲Object的原型（15.2.4）。RegExp的原型爲其自己的一個普通的正則表達式對象；它的[[Class]]爲「RegExp」。RegExp的原型對象的數據式屬性的初始值被設置爲彷彿由內置RegExp構造器深生成的表達式new RegExp()建立的對象。

RegExp的原型自己沒有valueOf屬性；然而，該valueOf屬性是繼承至Object的原型。

在做爲RegExp原型對象的屬性的以下函數描述中，「this RegExp object」是指函數激活時this對象；若是this值不是一個對象，或者一個其內部[[Class]]屬性值不是「RegExp」的對象，那麼一個TypeError會拋出。

RegExp.prototype.constructor

RegExp.prototype.constructor 的初始值爲內置 RegExp 構造器。

RegExp.prototype.exec(string)

Performs a regular expression match of string against the regular expression and returns an Array object containing the results of the match, or null if string did not match.

The String ToString(string) is searched for an occurrence of the regular expression pattern as follows:

1. 令R爲這一RegExp對象.
2. 令S爲ToString(string)的值.
3. 令length爲S的長度.
4. 令lastIndex爲以參數"lastIndex"調用R的內部方法[[Get]]的結果
5. 令i爲ToInteger(lastIndex)的值.
6. 令global爲以參數"global"調用R的內部方法[[Get]]的結果
7. 若global爲false, 則令 i = 0.
8. 令matchSucceeded爲false.
9. 到matchSucceeded爲false前重複如下
   1. 若i < 0 或者 i > length, 則
      1. 以參數"lastIndex", 0, and true調用R的內部方法[[Put]]
      2. Return null.
   2. 以參數S 和 i調用R的內部方法[[Match]]
   3. 若 [[Match]] 返回失敗, 則
      1. 令 i = i+1.
   4. 不然
      1. 令r爲調用[[Match]]的結果State.
      2. 設matchSucceeded爲true.
10. 令e爲r的endIndex值.
11. 若global爲true,
12. 以參數"lastIndex", e, 和true調用R的內部方法[[Put]]
13. 令n爲r的捕獲數組的長度. (這跟15.10.2.1's NCapturingParens是同一個值)
14. 令A爲如同以表達式new Array建立的新數組，其中Array是這個名字的內置構造器.
15. 令matchIndex爲匹配到的子串在整個字符串S中的位置。
16. 以參數"index", 屬性描述{[[Value]]: matchIndex, [[Writable]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和true調用A的內部方法[[DefineOwnProperty]]
17. 以參數"input", 屬性描述{[[Value]]: S, [[Writable]: true, #[[Enumerable]]: true, [[Configurable]]: true}, 和true調用A的內部方法[[DefineOwnProperty]]
18. 以參數"length", 屬性描述{[[Value]]: n + 1}, 和true調用A的內部方法[[DefineOwnProperty]]
19. 令matchedSubstr爲匹配到的子串(i.e. the portion of S between offset i inclusive and offset e exclusive).
20. 以參數"0", 屬性描述{[[Value]]: matchedSubstr, [[Writable]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和true調用A的內部方法[[DefineOwnProperty]]
21. 對每一知足I > 0且I ≤ n的整數i
    1. 令captureI爲第i個捕獲數組中的元素.
    2. 以參數ToString(i), 屬性描述{[[Value]]: captureI, [[Writable]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和true調用A的內部方法[[DefineOwnProperty]]
22. 返回 A.

RegExp.prototype.test(string)

採用以下步驟：

1. 令match爲在這個RegExp對象上使用string做爲參數執行 RegExp.prototype.exec (15.10.6.2) 的結果。
2. 若是match不爲null，返回true；不然返回false。

RegExp.prototype.toString()

返回一個String，由「/」，RegExp對象的source屬性值，「/」與「g」（若是global屬性爲true），「i」（若是ignoreCase爲true），「m」（若是multiline爲true）經過鏈接組成。

若是返回的字符串包含一個RegularExpressionLiteral，那麼該RegularExpressionLiteral用一樣的方式解釋執行。

Properties of RegExp Instances

RegExp實例繼承至RegExp原型對象，其[[CLASS]]內部屬性值爲「RegExp」。RegExp實例也擁有一個[[Match]]內部屬性和一個length屬性。

內部屬性[[Match]]的值是正則表達式對象的Pattern的依賴實現的表示形式。

RegExp實例還有以下屬性。

source

source屬性爲構成正則表達式Pattern的字符串。該屬性擁有這些特性{ [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

global

global屬性是一Boolean值，表示正則表達式flags是否有「g」。該屬性擁有這些特性{ [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

ignoreCase

ignoreCase屬性是一Boolean值，表示正則表達式flags是否有「i」。該屬性擁有這些特性{ [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

multiline

multiline屬性是一Boolean值，表示正則表達式flags是否有「m」。該屬性擁有這些特性{ [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

lastIndex

lastIndex屬性指定從何處開始下次匹配的一個字符串類型的位置索引。當須要時該值會轉換爲一個整型數。該屬性擁有這些特性{ [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }。

不一樣於其餘RegExp實例內置屬性，lastIndex是可寫的。

Error Objects

Error對象的實例在運行時遇到錯誤的狀況下會被當作異常拋出。Error對象也能夠做爲用戶自定義異常類的基對象。

The Error Constructor Called as a Function

當Error被做爲函數而不是構造器調用時，它建立並初始化一個新的Error對象。這樣函數調用Error(…)與一樣參數的對象建立表達式new Error(…)是等效的。

Error (message)

新構造的對象內部屬性Prototype會被設爲本來的Error原型對象，也就是Error.prototype的初始值。(15.11.3.1)

新構造的對象內部屬性Class會被設爲"Error"。

新構造的對象內部屬性Extensible會被設爲true。

若是形參message不是undefined，新構造的對象自己屬性message則被設爲ToString(message)。

The Error Constructor

當Error做爲new表達式的一部分被調用時，它是一個構造器：它初始化新建立的對象。

new Error (message)

新構造的對象內部屬性Prototype會被設爲本來的Error原型對象，也就是Error.prototype的初始值。(15.11.3.1)

新構造的對象內部屬性Class會被設爲"Error"。

新構造的對象內部屬性Extensible會被設爲true。

若是形參message不是undefined，新構造的對象自己屬性message則被設爲ToString(message)。

Properties of the Error Constructor

Error構造器的內部屬性Prototype值爲Function原型對象(15.3.4)。

除內部屬性和length屬性（其值爲1）之外，Error構造器還有如下屬性：

Error.prototype

Error.prototype的初始值爲Error原型對象(15.11.4)。

此屬性有如下特性： { Writable: false, Enumerable: false, Configurable: false }。

Properties of the Error Prototype Object

Error原型對象自己是一個Error對象（其Class爲"Error"）。

Error原型對象的內部屬性Prototype爲標準內置的Object原型對象(15.2.4)。

Error.prototype.constructor

Error.prototype.constructor初始值爲內置的Error構造器。

Error.prototype.name

rror.prototype.name初始值爲"Error"。

Error.prototype.message

Error.prototype.message初始值爲空字符串。

Error.prototype.toString ( )

執行如下步驟

1. 令o爲this值
2. 若是Type(O)不是對象，拋出一個TypeError異常。
3. 令name爲以"name"爲參數調用O的Get內置方法的結果。
4. 若是name爲undefined, 令name爲"Error";不然令name爲ToString(name)。
5. 令msg爲以"message"爲參數調用O的Get內置方法的結果。
6. 若是msg爲undefined,令msg爲空字符串;不然令msg爲ToString(msg)。
7. 若是name與msg都是空字符串，返回"Error"。
8. 若是name爲空字符串，返回msg。
9. 若是msg爲空字符串，返回name。
10. 返回拼接name,":",一個空格字符，以及msg的結果。

Error實例的屬性

Error實例從Error原型對象繼承屬性，且它們的內部屬性class值爲"Error"。Error實例沒有特殊屬性。

Native Error Types Used in This Standard

如下原生Error對象之一會在運行時錯誤發生時被拋出。全部這些對象共享一樣的結構，如15.11.7所述。

EvalError

本規範如今已經再也不使用這個異常，這個對象保留用於跟規範以前版本的兼容性。

RangeError

表示一個數值超出了容許的範圍，見15.4.2.2, 15.4.5.1, 15.7.4.2, 15.7.4.5, 15.7.4.6, 以及15.7.4.7, 15.9.5.43.

ReferenceError

表示一個不正確的引用值被檢測到。見8.7.1, 8.7.2, 10.2.1, 10.2.1.1.4, 10.2.1.2.4, 以及 11.13.1

SyntaxError

表示一個解析錯誤發生。見11.1.5, 11.3.1, 11.3.2, 11.4.1, 11.4.4, 11.4.5, 11.13.1, 11.13.2, 12.2.1, 12.10.1, 12.14.1, 13.1, 15.1.2.1, 15.3.2.1, 15.10.2.2, 15.10.2.5, 15.10.2.9, 15.10.2.15, 15.10.2.19, 15.10.4.1, 以及15.12.2

TypeError

表示一個操做數的真實類型與指望類型不符。見8.6.2, 8.7.2, 8.10.5, 8.12.5, 8.12.7, 8.12.8, 8.12.9, 9.9, 9.10, 10.2.1, 10.2.1.1.3, 10.6, 11.2.2, 11.2.3, 11.4.1, 11.8.6, 11.8.7, 11.3.1, 13.2, 13.2.3, 15, 15.2.3.2, 15.2.3.3, 15.2.3.4, 15.2.3.5, 15.2.3.6, 15.2.3.7, 15.2.3.8, 15.2.3.9, 15.2.3.10, 15.2.3.11, 15.2.3.12, 15.2.3.13, 15.2.3.14, 15.2.4.3, 15.3.4.2, 15.3.4.3, 15.3.4.4, 15.3.4.5, 15.3.4.5.2, 15.3.4.5.3, 15.3.5, 15.3.5.3, 15.3.5.4, 15.4.4.3, 15.4.4.11, 15.4.4.16, 15.4.4.17, 15.4.4.18, 15.4.4.19, 15.4.4.20, 15.4.4.21, 15.4.4.22, 15.4.5.1, 15.5.4.2, 15.5.4.3, 15.6.4.2, 15.6.4.3, 15.7.4, 15.7.4.2, 15.7.4.4, 15.7.4.8 [?], 15.9.5, 15.9.5.44, 15.10.4.1, 15.10.6, 15.11.4.4 以及 15.12.3

URIError

表示全局URI處理函數被以不符合其定義的方式使用。見 15.1.3。

NativeError對象結構

當ECMAScript實現探測到一個運行時錯誤時，它拋出一個15.11.6所定義的NativeError對象的實例。每一個這些對象都有以下所述結構，不一樣僅僅是在name屬性中以構造器名稱替換掉NativeError，以及原型對象由實現自定義的message屬性。

對於每一個錯誤對象，定義中到NativeError的引用應當用15.11.6中具體的對象名替換。

NativeError Constructors Called as Functions

當NativeError被做爲函數而不是構造器調用時，它建立並初始化一個新的NativeError對象。這樣函數調用NativeError(…)與一樣參數的對象建立表達式new NativeError(…)是等效的。

NativeError (message)

新構造的對象內部屬性Prototype會被設爲這一錯誤構造器附帶的原型對象。新構造的對象內部屬性Class會被設爲"Error"。新構造的對象內部屬性Extensible會被設爲true。

若是形參message不是undefined，新構造的對象自己屬性message則被設爲ToString(message)。

The NativeError Constructors

當NativeError做爲new表達式的一部分被調用時，它是一個構造器：它初始化新建立的對象。

New NativeError (message)

新構造的對象內部屬性Prototype會被設爲這一錯誤構造器附帶的原型對象。新構造的對象內部屬性Class會被設爲"Error"。新構造的對象內部屬性Extensible會被設爲true。

若是形參message不是undefined，新構造的對象自己屬性message則被設爲ToString(message)。

Properties of the NativeError Constructors

NativeError構造器的內部屬性Prototype值爲Function原型對象(15.3.4)。

除內部屬性和length屬性（其值爲1）之外，Error構造器還有如下屬性：

NativeError.prototype

NativeError.prototype的初始值爲一個Error(15.11.4)。

此屬性有如下特性： { Writable: false, Enumerable: false, Configurable: false }。

Properties of the NativeError Prototype Objects

每一個NativeError的prototype的初始值爲一個Error（其Class爲"Error"）。

NativeError原型對象的內部屬性Prototype爲標準內置的Error對象(15.2.4)。

NativeError.prototype.constructor

對於特定的NativeError，Error.prototype.constructor初始值爲NativeError構造器自己。

NativeError.prototype.name

對於特定的NativeError，Error.prototype.name初始值爲構造器的名字。

NativeError.prototype.message

對於特定的NativeError，NativeError.prototype.message初始值爲空字符串。

NativeError構造器的原型他們自身並不提供toString函數，可是錯誤的實例能夠從Error原型對象繼承到它。

NativeError實例的屬性

NativeError實例從NativeError原型對象繼承屬性，且它們的內部屬性class值爲"Error"。Error實例沒有特殊屬性。

JSON 對象

JSON 對象是一個單一的對象，它包含兩個函數，parse 和 stringify，是用於解析和構造 JSON 文本的。JSON 數據的交換格式在 RFC4627 裏進行了描述。 <http://www.ietf.org/rfc/rfc4627.txt>。本規範裏面的 JSON 交換格式會使用 RFC4627 裏所描述的，如下兩點除外：

• ECMAScript JSON 文法中的頂級 JSONText 產生式是由 JSONValue 構成，而不是 RFC4627 中限制成的 JSONObject 或者 JSONArray。
• 確認 JSON.parse 和 JSON.stringify 的實現，它們必須準確的支持本規範描述的交換格式，而不容許對格式進行刪除或擴展。這一點要區別於 RFC4627，它容許 JSON 解析器接受 non-JSON 的格式和擴展。

JSON 對象內部屬性 [[Prototype]] 的值是標準內建的 Object 原型對象（15.2.4）。內部屬性 [[Class]] 的值是「JSON」。內部屬性 [[Extensible]] 的值設置爲 true。

JSON 對象沒有內部屬性 [[Construct]]；不能把 JSON 對象看成構造器來使用 new 操做符。

JSON 對象沒有內部屬性 [[Call]]; 不能把 JSON 對象看成函數來調用。

JSON 語法

JSON.stringify 會產生一個符合 JSON 語法的字符串。JSON.parse 接受的是一個符合 JSON 語法的字符串。

JSON 詞法

相似於 ECMAScript 源文本，JSON 是由一系列符合 SourceCharacter 規則的字符構成的。JSON 詞法定義的 tokens 使得 JSON 文本相似於 ECMAScript 詞法定義的 tokens 獲得的 ECMAScript 源文本。JSON 詞法僅能識別由 JSONWhiteSpace 產生式獲得的空白字符。在語法上，全部非終止符均不是由「JSON」字符開始，而是由 ECMAScript 詞法產生式定義的。

語法

JSONWhiteSpace :: <tab> <cr> <lf> <sp> JSONString :: " JSONStringCharactersopt "JSONStringCharacters :: JSONStringCharacter JSONStringCharactersoptJSONStringCharacter :: SourceCharacter 但非 雙引號 " 或反斜槓 \ 或 U+0000 抑或是 U+001F \ JSONEscapeSequenceJSONEscapeSequence :: JSONEscapeCharacter UnicodeEscapeSequence JSONEscapeCharacter :: 如下之一 " / \ b f n r tJSONNumber :: -optDecimalIntegerLiteral JSONFractionopt ExponentPartoptJSONFraction :: . DecimalDigitsJSONNullLiteral :: NullLiteralJSONBooleanLiteral :: BooleanLiteral

JSON 語法

根據 JSON 詞法定義的 tokens，JSON 語法定義了一個合法的 JSON 文本。語法的目標符號是 JSONText。

語法

JSONText : JSONValueJSONValue : JSONNullLiteral JSONBooleanLiteral JSONObject JSONArray JSONString JSONNumberJSONObject : { } { JSONMemberList }JSONMember : JSONString : JSONValueJSONMemberList : JSONMember JSONMemberList , JSONMemberJSONArray : [ ] [ JSONElementList ]JSONElementList : JSONValue JSONElementList , JSONValue

parse ( text [ , reviver ] )

parse函數解析一段JSON文本（JSON格式字符串），生成一個ECMAScript值。JSON格式是ECMAScript直接量 的受限模式。JSON對象能夠被理解爲ECMAScript對象。JSON數組能夠被理解爲ECMAScript數組。JSON字符串、數字、布爾值以及null能夠被認爲是ECMAScript字符串、數字、布爾值以及null。JSON使用受限更多的空白字符集合，而且容許Unicode碼點U+2028和U+2029直接出如今JSONString直接量當中而無需使用轉義序列。解析流程與11.1.4和11.1.5同樣，可是由JSON語法限定。

可選參數reviver是一個接受兩個參數的函數（key和value）。它能夠過濾和轉換結果。它在每一個key/value對產生時被調用，它的返回值能夠用於替代本來的值。若是它原樣返回接收到的，那麼結構不會被改變。若是它返回undefined，那麼屬性會被從結果中刪除。

1. 令JText爲ToString(text)
2. 以15.12.1所述語法解析JText。若是JText不能以JSON grammar解析成JSONText，則拋出SyntaxError異常。
3. 令unfiltered爲按ECMAScript程序（可是用JSONString替換StringLiteral）解析和執行JText的結果。注因JText符合JSON語法，這個結果要麼是原始值類型要麼是ArrayLiteral或者ObjectLiteral所定義的對象。
4. 若IsCallable(reviver)爲true則
   1. 令root爲由表達式new Object()建立的新對象，其中Object是以Object爲名的標準內置的構造器。
   2. 以空字符串和屬性描述{Value: unfiltered, Writable: true, Enumerable: true, Configurable: true}以及false爲參數調用root的DefineOwnProperty內置方法。
   3. 返回傳入root和空字符串爲參數調用抽象操做Walk的結果，抽象操做Walk以下文所定義。
5. 不然，返回unfiltered。

抽象操做Walk是一個遞歸的抽象操做，它接受兩個參數：一個持有對象和表示一個該對象的屬性名的String。Walk使用最開始被傳入parse函數的reviver的值。

1. 令val爲以參數name調用hold的get內部方法的結果。
2. 若val爲對象，則
   1. 若val的Class內部屬性爲"Array"
      1. 設I爲0
      2. 令len爲以參數"length"調用val的get內部方法的結果
      3. 當I<len時重複
         1. 令newElement爲調用抽象操做Walk的結果，傳入val和ToString(I)爲參數。
         2. 若newElement爲undefined，則
            1. 以ToString(I)和false作參數，調用val的內部方法Delete
            2. 不然，以ToString(I)，屬性描述{Value: newElement, Writable: true, Enumerable: true, Configurable: true}以及false作參數調用調用val的內部方法DefineOwnProperty
         3. 對I加1
   2. 不然
      1. 令keys爲包含val全部的具備Enumerable特性的屬性名String值的內部類型List。字符串的順序應當與內置函數Object.keys一致。
      2. 對於keys中的每一個字符串P作一下
         1. 令newElement爲調用抽象操做Walk的結果，傳入val和P爲參數。
         2. 若newElement爲undefined，則
            1. 以P和false作參數，調用val的內部方法Delete
            2. 不然，以P，屬性描述{Value: newElement, Writable: true, Enumerable: true, Configurable: true}以及false作參數調用調用val的內部方法DefineOwnProperty
3. 返回傳入holder做爲this值以及以name和val構成的參數列表調用reviver的Call內部屬性的結果。

實現不容許更改JSON.parse的實現以擴展JSON語法。若是一個實現想要支持更改或者擴展過的JSON交換格式它必須以定義一個不一樣的parse函數的方式作這件事。

在對象中存在同名字符串的狀況下，同一key的值會被按照文本順序覆蓋掉。

stringify ( value [ , replacer [ , space ] ] )

stringify函數返回一個JSON格式的字符串，用以表示一個ECMAScript值。它能夠接受三個參數。第一個參數是必選的。value參數是一個ECMAScript值，它一般是對象或者數組，儘管它也能夠是String, Boolean, Number 或者是 null。可選的replacer參數要麼是個能夠修改對象和數組字符串化的方式的函數，要麼是個扮演選擇對象字符串化的屬性的白名單這樣的角色的String和Number組成的數組。可選的space參數是一個String或者Number，能夠容許結果中插入空白符以改善人類可讀性。

如下爲字符串化一對象的步驟：

1. 令stack爲空List
2. 令indent爲空String
3. 令PropertyList和ReplacerFunction爲undefined
4. 若Type(replacer)爲Object,則
   1. 若IsCallable(replacer)爲true,則
      1. 令ReplacerFunction爲replacer
   2. 不然若replacer的內部屬性Class爲"Array",則
      1. 令PropertyList爲一空內部類型List
      2. 對於全部名是數組下標的replacer的屬性v.以數組下標遞增順序枚舉屬性
         1. 令item爲undefined
         2. 若Type(v)爲String則 令item爲v.
         3. 不然若Type(v)爲Number則 令item爲ToString(v).
         4. 不然若Type(v)爲Object則,
            1. 若v的Class內部屬性爲"String" or "Number"則 令item爲ToString(v).
         5. 若item is not undefined and item爲not currently an element of PropertyList則,
            1. Append item to the end of PropertyList.
5. 若Type(space)爲Object則,
   1. 若space的Class內部屬性爲"Number"則,
      1. 令space爲ToNumber(space)
   2. 不然若space的Class內部屬性爲"String"則,
      1. 令space爲ToString(space)
6. 若Type(space)爲Number 令space爲min(10, ToInteger(space)) 設gap爲一包含space個空格的String. 這將會是空String加入space小於1.
7. 不然若Type(space)爲String
   1. 若space中字符個數爲10或者更小, 設gap爲space，不然設gap爲包含前10個space中字符的字符串
8. 不然 設gap爲空String.
9. 令wrapper爲一個如同以表達式new Object()建立的新對象,其中Object是這個名字的標準內置構造器。
10. 以參數空String, 屬性描述{Value: value, Writable: true, Enumerable: true, Configurable: true}, 和false調用wrapper的DefineOwnProperty內部方法。
11. 返回以空String和wrapper調用抽象方法Str的結果。

抽象操做Str(key, holder)能夠訪問調用它的stringify方法中的ReplacerFunction。其算法以下：

1. 令value爲以key爲參數調用holder的內部方法Get
2. 若Type(value)爲Object,則
   1. 令toJSON爲以"toJSON"爲參數調用value的內部方法Get
   2. If IsCallable(toJSON) is true
      1. 令value爲以調用toJSON的內部方法Call的結果，傳入value爲this值以及由key構成的參數列表
3. 若ReplacerFunction爲not undefined,則
   1. 令value爲以調用ReplacerFunction的內部方法Call的結果，傳入holder爲this值以及由key and value構成的參數列表
4. 若Type(value)爲Object則,
   1. 若value的Class內部屬性爲"Number"則,
      1. 令value爲ToNumber(value)
   2. 不然若value的Class內部屬性爲"String"則,
      1. 令value爲ToString(value)
   3. 不然若value的Class內部屬性爲"Boolean"則,
      1. 令value爲value的value of the PrimitiveValue內部屬性
5. 若value爲null則 返回 "null".
6. 若value爲true則 返回 "true".
7. 若value爲false則 返回 "false".
8. 若Type(value)爲String,則返回以value調用Quote抽象操做的結果。
9. 若Type(value)爲Number
   1. 若value爲finite則 返回 ToString(value).
   2. 不然, 返回"null".
10. 若Type(value)爲Object,且IsCallable(value)爲false
    1. 若value的Class內部屬性爲"Array"則
       1. 返回以value爲參數調用抽象操做JA的結果
    2. 不然, 返回以value.爲參數調用抽象操做value的結果
11. 返回undefined.

抽象操做Quote(value)將一個String值封裝在雙引號中，而且對其中的字符轉義。

1. 令product爲雙引號字符
2. 對value中的每個字符C
   1. 若C爲雙引號字符或者反斜槓字符
      1. 令product爲product和反斜槓鏈接的結果
      2. 令product爲product與C的鏈接
   2. 不然若C爲退格，formfeed換行回車揮着tab
      1. 令product爲product與反斜槓字符的鏈接
      2. 令abbrev爲以下表所示C對應的字符: backspace "b" formfeed "f" newline "n" carriage return "r" tab "t"
      3. 令product爲product與abbrev的鏈接
   3. 不然若C爲代碼值小於space的控制字符
      1. 令product爲product與反斜槓字符的鏈接
      2. 令product爲product與"u"的鏈接
      3. 令hex爲轉換C代碼值按十六進制轉換到四位字符串的結果
      4. 令product爲product與hex的鏈接
   4. 不然
      1. 令product爲product與C的鏈接
3. 令product爲product與雙引號字符的鏈接
4. 返回 product.

抽象操做JO(value)序列化一個對象，它能夠訪問調用它的方法中的stack, indent, gap, PropertyList,ReplacerFunction以及space

1. 若stack包含value，則拋出一個TypeError，由於對象結構中存在循環。
2. 將value添加到stack.
3. 令stepback爲indent
4. 令indent爲indent與gap的鏈接
5. 若PropertyList沒有被定義,則
   1. 令K爲PropertyList
6. 不然
   1. 令K爲以由全部Enumerable特性爲true的自身屬性名構成的內部String列表類型.
7. 令partial爲空List
8. 對於K的每個元素P
   1. 令strP爲以P和value爲參數調用抽象操做Str的結果
   2. 若strP沒有被定義
      1. 令member爲以P爲參數調用抽象操做P的結果
      2. 令member爲member與冒號字符的鏈接
      3. 若gap不爲空String
      4. 令member爲member與空格字符的鏈接
      5. 令member爲member與strP的鏈接
      6. 將member添加到partial.
9. 若partial爲empty,則
   1. 令final爲"{}"
10. 不然
    1. 若gap爲空String
       1. 令properties爲一個鏈接全部partial中的字符串而成的字符串，鍵值對之間用逗號分隔。第一個字符串以前和最後一個字符串以後沒有逗號。
       2. 令final爲鏈接 "{", properties, 和"}"的結果
    2. 不然 gap 不是空String
       1. 令separator爲鏈接 逗號字符，換行字符以及indent而成的字符串。
       2. 令properties爲一個鏈接全部partial中的字符串而成的字符串，鍵值對之間用separator分隔。第一個字符串以前和最後一個字符串以後沒有separator。
       3. 令final爲鏈接"{", 換行符, indent, properties, 換行符, stepback, 和"}"的結果。
11. 移除stack中的最後一個元素。
12. 令indent爲stepback
13. 返回final.

抽象操做JA(value)序列化一個數組。它能夠訪問調用它的stringify方法中的stack, indent, gap, PropertyList,ReplacerFunction以及space。數組的表示中僅包擴零到array.length-1的區間。命名的屬性將會被從字符串化操做中排除。數組字符串化成開頭的左方括號，逗號分隔的元素，以及結束的右方括號。

1. 若stack包含value，則拋出一個TypeError，由於對象結構中存在循環。
2. 將value添加到stack.
3. 令stepback爲indent
4. 令indent爲indent與gap的鏈接
5. 令partial爲空List
6. 令len爲以"length"爲參數調用value的內部方法Get
7. 令index爲0
8. 當index < len時重複如下
   1. 令strP爲the result of calling the abstract operation Str with arguments ToString(index) and value
   2. 若strP沒有被定義
      1. 添加null到 partial.
   3. 不然
      1. 添加strP到 partial.
   4. 使index增長1.
9. 若partial爲空,則
   1. 令final爲"[]"
10. 不然
    1. 若gap爲空String
       1. 令properties爲爲一個鏈接全部partial中的字符串而成的字符串，鍵值對之間用逗號分隔。第一個字符串以前和最後一個字符串以後沒有逗號。
       2. 令final爲鏈接 "[", properties, 和"]"的結果
    2. 不然
       1. 令separator爲逗號字符，換行字符以及indent而成的字符串。
       2. 令properties爲一個鏈接全部partial中的字符串而成的字符串，鍵值對之間用separator分隔。第一個字符串以前和最後一個字符串以後沒有separator。
       3. 令final爲鏈接"[", 換行符, indent, properties, 換行符, stepback, 和"]"的結果。
11. 移除stack中的最後一個元素。
12. 令indent爲stepback
13. 返回final.

JSON結構容許任何深度的嵌套，可是不可以循環引用。若value是或者包含了一個循環結構，則stringify函數必須拋出一個TypeError異常。如下是一個不可以被字符串化的值的例子：

a = []; a[0] = a; my_text = JSON.stringify(a); // This must throw an TypeError.

符號式簡單值按如下方式表示：

1. null值在JSON文本中表示爲字符串null
2. undefined 值不出現
3. true值在JSON文本中表示爲字符串true
4. false值在JSON文本中表示爲字符串false

字符串值用雙引號括起。字符"和\會被轉義成帶\前綴的。控制字符用轉義序列\uHHHH替換，或者使用簡略形式 \b(backspace), \f (formfeed), \n (newline), \r (carriage return), \t (tab)

有窮的數字按照調用ToString(number)字符串化。NaN和不論正負的Infinity都表示爲字符串null

沒有JSON表示的值（如undefined和函數）不會產生字符串。而是會產生undefined值。在數組中這些值表示爲字符串null。在對象中不能表示的值會致使屬性被排除在字符串化過程以外。

對象表示爲開頭的左大括號跟着零個或者多個屬性，以逗號分隔，以右大括號結束。屬性是用用來表示key或者屬性名的引號引發的字符串，冒號而後是字符串化的屬性值。數組表示爲開頭的左方括號，後跟零個或者多個值，以逗號分隔，以右方括號結束。

錯誤

在 EMCAScript 相關語言構造被求值之時，實現報告大部分錯誤。早期的錯誤是一種能夠檢測和優先報告程序中全部錯誤內任何構造的求值問題。具體實現必定要在一個程序首次執行評估時報告早期錯誤。早期錯誤在 eval 被調用時報告 eval 錯誤代碼，可是在 eval 代碼內之優先評估任意構造。

一個實現要處理任意實例中的如下幾種偏差做爲早期錯誤 :

1. 任意語法錯誤
2. 試圖定義一個有多個相同名字的 get 屬性設置或有多個相同名字的 set 屬性設置的 對象字面量
3. 試圖定義一個數據屬性設置而且 get 或 set 具備相同的名稱屬性設置的 對象字面量
4. 錯誤在正則表達式字面量中沒有實現語法擴展
5. 試圖在嚴格代碼模式下定義一個有多個相同名稱屬性設置數據的 對象字面量
6. with 語句在嚴格代碼模式下出現
7. 在嚴格模式下的函數定義或函數表達的參數列表內不止一次出現標識符值的狀況
8. 使用 return, break 和 continue 不當
9. 試圖在早期已經肯定爲非引用的任意值上調用 PutValue（例如，執行賦值語句 3 = 4）

一個實現不該過早處理其餘種類的錯誤，即便編譯器能夠證明某一構造會在任何狀況下產生執行錯誤。

一個實現應報告全部的指定錯誤，但如下狀況除外：

1. 實現能夠擴展程序語法和正則表達式或標誌語法。使用此功能，當它們遇到一個實現程序語法定義擴展或正則表達式或標記語法時，全部操做（如調用 eval，使用正則表達式字面，或使用 Function 或 RegExp 構造）被獲准展示實現定義擴展的行爲，而非拋出 SyntaxError 。
2. 一個實現能夠提供超出本規範中所描述的功能範圍外的類型，值，對象，屬性。這可能會致使構造（如尋找一個在全局做用域內的變量）實現定義的行爲而非拋出一個錯誤（如 ReferenceError）。
3. 當在 fractionDigits 或 precision 參數是在指定的範圍以外，一個實現能夠爲 toFixed, toExponential, 和 toPrecision 定義 RangeError 之外的其餘行爲。

文法摘要

詞法

SourceCharacter :: 任意 Unicode 編碼單元 InputElementDiv :: WhiteSpace LineTerminator Comment Token DivPunctuator InputElementRegExp :: WhiteSpace LineTerminator Comment Token RegularExpressionLiteral WhiteSpace :: <TAB> <VT> <FF> <SP> <#x0a> <BOM> <USP> LineTerminator :: <LF> <CR> <LS> <PS> LineTerminatorSequence :: <LF> <CR> [lookahead ∉ ] <LS> <PS> <CR> <LF> Comment :: MultiLineComment SingleLineComment MultiLineComment :: /* MultiLineCommentCharsopt */ MultiLineCommentChars :: MultiLineNotAsteriskChar MultiLineCommentCharsopt * PostAsteriskCommentCharsopt PostAsteriskCommentChars :: MultiLineNotForwardSlashorAsteriskChar MultiLineCommentCharsopt * PostAsteriskCommentCharsopt MultiLineNotAsteriskChar :: SourceCharacter 但非 星號 * MultiLineNotForwardSlashorAsteriskChar :: SourceCharacter 但非 正斜槓 / 或 星號 * SingleLineComment :: // SingleLineCommentCharsopt SingleLineCommentChars :: SingleLineCommentChar SingleLineCommentCharsopt SingleLineCommentChar :: SourceCharacter 但非 LineTerminator Token :: IdentifierName Punctuator NumericLiteral StringLiteral Identifier :: IdentifierName 但非 ReservedWord IdentifierName :: IdentifierStart IdentifierName IdentifierPart IdentifierStart :: UnicodeLetter $ _ \ UnicodeEscapeSequence IdentifierPart :: IdentifierStart UnicodeCombiningMark UnicodeDigit UnicodeConnectorPunctuation <ZWNJ> <ZWJ> UnicodeLetter 在如下 Unicode 分類中的字符：「Uppercase letter (Lu)」, 「Lowercase letter (Ll)」, 「Titlecase letter (Lt)」, 「Modifier letter (Lm)」, 「Other letter (Lo)」, 或 「Letter number (Nl)」. UnicodeCombiningMark 在如下 Unicode 分類中的字符：「Non-spacing mark (Mn)」 或 「Combining spacing mark (Mc)」 UnicodeDigit 在如下 Unicode 分類中的字符：「Decimal number (Nd)」 UnicodeConnectorPunctuation 在如下 Unicode 分類中的字符：「Connector punctuation (Pc)」 ReservedWord :: Keyword FutureReservedWord NullLiteral BooleanLiteral Keyword :: 如下之一 break do instanceof typeof case else new var catch finally return void continue for switch while debugger function this with default if throw delete in try FutureReservedWord :: 如下之一 class enum extends super const export import 或在嚴格模式下如下之一 implements let private public interface package protected static yield Punctuator :: 如下之一 { } ( ) [ ] . ; , < > <= >= == != === !== + - * % ++ -- << >> >>> & | ^ ! ~ && || ? : = += -= *= %= <<= >>= >>>= &= |= ^= DivPunctuator :: 如下之一 / /= Literal :: NullLiteral BooleanLiteral NumericLiteral StringLiteral RegularExpressionLiteral NullLiteral :: null BooleanLiteral :: true false NumericLiteral :: DecimalLiteral HexIntegerLiteral DecimalLiteral :: DecimalIntegerLiteral . DecimalDigitsopt ExponentPartopt . DecimalDigits ExponentPartopt DecimalIntegerLiteral ExponentPartopt DecimalIntegerLiteral :: 0 NonZeroDigit DecimalDigitsopt DecimalDigits :: DecimalDigit DecimalDigits DecimalDigit DecimalDigit :: 如下之一 0 1 2 3 4 5 6 7 8 9 NonZeroDigit:: 如下之一 1 2 3 4 5 6 7 8 9 ExponentPart:: ExponentIndicator SignedInteger ExponentIndicator :: 如下之一 e E SignedInteger :: DecimalDigits + DecimalDigits - DecimalDigits HexIntegerLiteral :: 0x HexDigit 0X HexDigit HexIntegerLiteral HexDigit HexDigit :: 如下之一 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F StringLiteral :: "DoubleStringCharactersopt " 'SingleStringCharactersopt ' DoubleStringCharacters :: DoubleStringCharacter DoubleStringCharactersopt SingleStringCharacters :: SingleStringCharacter SingleStringCharactersopt DoubleStringCharacter :: SourceCharacter 但非 double-quote " 或 backslash \ 或 LineTerminator \ EscapeSequence LineContinuation SingleStringCharacter :: SourceCharacter 但非 single-quote ' 或 backslash \ 或 LineTerminator \ EscapeSequence LineContinuation LineContinuation :: \ LineTerminatorSequence EscapeSequence :: CharacterEscapeSequence 0 [lookahead ∉ DecimalDigit] HexEscapeSequence UnicodeEscapeSequence CharacterEscapeSequence :: SingleEscapeCharacter NonEscapeCharacter SingleEscapeCharacter :: 如下之一 ' " \ b f n r t v NonEscapeCharacter :: SourceCharacter 但非 EscapeCharacter 或 LineTerminator EscapeCharacter :: SingleEscapeCharacter DecimalDigit x u HexEscapeSequence :: x HexDigit HexDigit UnicodeEscapeSequence :: u HexDigit HexDigit HexDigit HexDigit RegularExpressionLiteral :: / RegularExpressionBody / RegularExpressionFlags RegularExpressionBody :: RegularExpressionFirstChar RegularExpressionChars RegularExpressionChars :: [empty] RegularExpressionChars RegularExpressionChar RegularExpressionFirstChar :: RegularExpressionNonTerminator 但非 * 或 \ 或 / 或 [ RegularExpressionBackslashSequence RegularExpressionClass RegularExpressionChar :: RegularExpressionNonTerminator 但非 \ 或 / 或 [ RegularExpressionBackslashSequence RegularExpressionClass RegularExpressionBackslashSequence :: \ RegularExpressionNonTerminator RegularExpressionNonTerminator :: SourceCharacter 但非 LineTerminator RegularExpressionClass :: [ RegularExpressionClassChars ] RegularExpressionClassChars :: [ 空 ] RegularExpressionClassChars RegularExpressionClassChar RegularExpressionClassChar :: RegularExpressionNonTerminator 但非 ] 或 \ RegularExpressionBackslashSequence RegularExpressionFlags :: [ 空 ] RegularExpressionFlags IdentifierPart

數字轉換

StringNumericLiteral ::: StrWhiteSpaceopt StrWhiteSpaceoptStrNumericLiteral StrWhiteSpaceopt StrWhiteSpace ::: StrWhiteSpaceChar StrWhiteSpaceopt StrWhiteSpaceChar ::: WhiteSpace LineTerminator StrNumericLiteral ::: StrDecimalLiteral HexIntegerLiteral StrDecimalLiteral ::: StrUnsignedDecimalLiteral + StrUnsignedDecimalLiteral - StrUnsignedDecimalLiteral StrUnsignedDecimalLiteral ::: Infinity DecimalDigits . DecimalDigitsopt ExponentPartopt . DecimalDigits ExponentPartopt DecimalDigits ExponentPartopt DecimalDigits ::: DecimalDigit DecimalDigits DecimalDigit DecimalDigit ::: 如下之一 0 1 2 3 4 5 6 7 8 9 ExponentPart ::: ExponentIndicator SignedInteger ExponentIndicator ::: 如下之一 e E SignedInteger ::: DecimalDigits + DecimalDigits - DecimalDigits HexIntegerLiteral ::: 0x HexDigit 0X HexDigit HexIntegerLiteral HexDigit HexDigit ::: 如下之一 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F

表達式

PrimaryExpression : this Identifier Literal ArrayLiteral ObjectLiteral ( Expression ) ArrayLiteral : [ Elisionopt ] [ ElementList ] [ ElementList , Elisionopt ] ElementList : ElisionoptAssignmentExpression ElementList , ElisionoptAssignmentExpression Elision : , Elision , ObjectLiteral : { } { PropertyNameAndValueList } { PropertyNameAndValueList , } PropertyNameAndValueList : PropertyAssignment PropertyNameAndValueList , PropertyAssignment PropertyAssignment : PropertyName : AssignmentExpression get PropertyName() { FunctionBody } set PropertyName( PropertySetParameterList ) { FunctionBody } PropertyName : IdentifierName StringLiteral NumericLiteral PropertySetParameterList : Identifier MemberExpression : PrimaryExpression FunctionExpression MemberExpression [ Expression ] MemberExpression . IdentifierName new MemberExpression Arguments NewExpression : MemberExpression new NewExpression CallExpression : MemberExpression Arguments CallExpression Arguments CallExpression [ Expression ] CallExpression . IdentifierName Arguments : ( ) ( ArgumentList ) ArgumentList : AssignmentExpression ArgumentList , AssignmentExpression LeftHandSideExpression : NewExpression CallExpression PostfixExpression : LeftHandSideExpression LeftHandSideExpression [ 此處無換行 ] ++ LeftHandSideExpression [ 此處無換行 ] -- UnaryExpression : PostfixExpression delete UnaryExpression void UnaryExpression typeof UnaryExpression ++ UnaryExpression -- UnaryExpression + UnaryExpression - UnaryExpression ~ UnaryExpression ! UnaryExpression MultiplicativeExpression : UnaryExpression MultiplicativeExpression * UnaryExpression MultiplicativeExpression / UnaryExpression MultiplicativeExpression % UnaryExpression AdditiveExpression : MultiplicativeExpression AdditiveExpression + MultiplicativeExpression AdditiveExpression - MultiplicativeExpression ShiftExpression : AdditiveExpression ShiftExpression << AdditiveExpression ShiftExpression >> AdditiveExpression ShiftExpression >>> AdditiveExpression RelationalExpression : ShiftExpression RelationalExpression < ShiftExpression RelationalExpression > ShiftExpression RelationalExpression <= ShiftExpression RelationalExpression >= ShiftExpression RelationalExpression instanceof ShiftExpression RelationalExpression in ShiftExpression RelationalExpressionNoIn : ShiftExpression RelationalExpressionNoIn < ShiftExpression RelationalExpressionNoIn > ShiftExpression RelationalExpressionNoIn <= ShiftExpression RelationalExpressionNoIn >= ShiftExpression RelationalExpressionNoIn instanceof ShiftExpression EqualityExpression : RelationalExpression EqualityExpression == RelationalExpression EqualityExpression != RelationalExpression EqualityExpression === RelationalExpression EqualityExpression !== RelationalExpression EqualityExpressionNoIn : RelationalExpressionNoIn EqualityExpressionNoIn == RelationalExpressionNoIn EqualityExpressionNoIn != RelationalExpressionNoIn EqualityExpressionNoIn === RelationalExpressionNoIn EqualityExpressionNoIn !== RelationalExpressionNoIn BitwiseANDExpression : EqualityExpression BitwiseANDExpression & EqualityExpression BitwiseANDExpressionNoIn : EqualityExpressionNoIn BitwiseANDExpressionNoIn & EqualityExpressionNoIn BitwiseXORExpression : BitwiseANDExpression BitwiseXORExpression ^ BitwiseANDExpression BitwiseXORExpressionNoIn : BitwiseANDExpressionNoIn BitwiseXORExpressionNoIn ^ BitwiseANDExpressionNoIn BitwiseORExpression : BitwiseXORExpression BitwiseORExpression | BitwiseXORExpression BitwiseORExpressionNoIn : BitwiseXORExpressionNoIn BitwiseORExpressionNoIn | BitwiseXORExpressionNoIn LogicalANDExpression : BitwiseORExpression LogicalANDExpression && BitwiseORExpression LogicalANDExpressionNoIn : BitwiseORExpressionNoIn LogicalANDExpressionNoIn && BitwiseORExpressionNoIn LogicalORExpression : LogicalANDExpression LogicalORExpression || LogicalANDExpression LogicalORExpressionNoIn : LogicalANDExpressionNoIn LogicalORExpressionNoIn || LogicalANDExpressionNoIn ConditionalExpression : LogicalORExpression LogicalORExpression ? AssignmentExpression : AssignmentExpression ConditionalExpressionNoIn : LogicalORExpressionNoIn LogicalORExpressionNoIn ? AssignmentExpressionNoIn : AssignmentExpressionNoIn AssignmentExpression : ConditionalExpression LeftHandSideExpression AssignmentOperator AssignmentExpression AssignmentExpressionNoIn : ConditionalExpressionNoIn LeftHandSideExpression AssignmentOperator AssignmentExpressionNoIn AssignmentOperator : 如下之一 = *= /= %= += -= <<= >>= >>>= &= ^= |= Expression : AssignmentExpression Expression , AssignmentExpression ExpressionNoIn : AssignmentExpressionNoIn ExpressionNoIn , AssignmentExpressionNoIn

語句

Statement : Block VariableStatement EmptyStatement ExpressionStatement IfStatement IterationStatement ContinueStatement BreakStatement ReturnStatement WithStatement LabelledStatement SwitchStatement ThrowStatement TryStatement DebuggerStatement Block : { StatementListopt } StatementList : Statement StatementList Statement VariableStatement : var VariableDeclarationList ; VariableDeclarationList : VariableDeclaration VariableDeclarationList , VariableDeclaration VariableDeclarationListNoIn : VariableDeclarationNoIn VariableDeclarationListNoIn , VariableDeclarationNoIn VariableDeclaration : Identifier Initialiseropt VariableDeclarationNoIn : Identifier InitialiserNoInopt Initialiser : = AssignmentExpression InitialiserNoIn : = AssignmentExpressionNoIn EmptyStatement : ; ExpressionStatement : [lookahead ∉ {{, function}]Expression ; IfStatement : if ( Expression ) Statement else Statement if ( Expression ) Statement IterationStatement : do Statement while ( Expression ); while ( Expression ) Statement for ( ExpressionNoInopt; Expressionopt ; Expressionopt ) Statement for ( var VariableDeclarationListNoIn; Expressionopt ; Expressionopt ) Statement for ( LeftHandSideExpression in Expression ) Statement for ( var VariableDeclarationNoIn in Expression ) Statement ContinueStatement : continue [ 此處無換行 ]Identifieropt ; BreakStatement : break [ 此處無換行 ]Identifieropt ; ReturnStatement : return [ 此處無換行 ]Expressionopt ; WithStatement : with ( Expression ) Statement SwitchStatement : switch ( Expression ) CaseBlock CaseBlock : { CaseClausesopt } { CaseClausesoptDefaultClause CaseClausesopt } CaseClauses : CaseClause CaseClauses CaseClause CaseClause : case Expression : StatementListopt DefaultClause : default : StatementListopt LabelledStatement : Identifier : Statement ThrowStatement : throw [noLineTerminator here] Expression ; TryStatement : try Block Catch try Block Finally try Block Catch Finally Catch : catch ( Identifier ) Block Finally : finally Block DebuggerStatement : debugger ;

函數和程序

FunctionDeclaration : function Identifier ( FormalParameterListopt ) { FunctionBody } FunctionExpression : function Identifieropt ( FormalParameterListopt ) { FunctionBody } FormalParameterList : Identifier FormalParameterList , Identifier FunctionBody : SourceElementsopt Program : SourceElementsopt SourceElements : SourceElement SourceElements SourceElement SourceElement : Statement FunctionDeclaration

統一資源定位符字符分類

uri ::: uriCharactersopt uriCharacters ::: uriCharacter uriCharactersopt uriCharacter ::: uriReserved uriUnescaped uriEscaped uriReserved ::: 如下之一 ; / ? : @ & = + $ , uriUnescaped ::: uriAlpha DecimalDigit uriMark uriEscaped ::: % HexDigit HexDigit uriAlpha ::: 如下之一 a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z uriMark ::: 如下之一 - _ . ! ~ * ‘ ( )

正則表達式

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

JSON

JSON詞法

JSONWhiteSpace :: <TAB> <CR> <LF> <SP> JSONString :: " JSONStringCharactersopt " JSONStringCharacters :: JSONStringCharacter JSONStringCharactersopt JSONStringCharacter :: SourceCharacter 但非 雙引號 " 或反斜槓 \ 或 U+0000 抑或是 U+001F \ JSONEscapeSequence JSONEscapeSequence :: JSONEscapeCharacter UnicodeEscapeSequence JSONEscapeCharacter :: 如下之一 " / \ b f n r t JSONNumber :: -optDecimalIntegerLiteral JSONFractionopt ExponentPartopt JSONFraction :: . DecimalDigits JSONNullLiteral :: NullLiteral JSONBooleanLiteral :: BooleanLiteral

JSON語法

JSONText : JSONValue JSONValue : JSONNullLiteral JSONBooleanLiteral JSONObject JSONArray JSONString JSONNumber JSONObject : { } { JSONMemberList } JSONMember : JSONString : JSONValue JSONMemberList : JSONMember JSONMemberList , JSONMember JSONArray : [ ] [ JSONElementList ] JSONElementList : JSONValue JSONElementList , JSONValue

兼容性

附加語法

CMAScript 的過去版本中還包含了說明八進制直接量和八進制轉義序列的額外語法、語義。在此版本中已將這些附加語法、語義移除。這個非規範性的附錄給出與八進制直接量和八進制轉義序列一致的語法、語義，以兼容某些較老的 ECMAScript 程序。

數字直接量

7.8.3 中的語法、語義能夠作以下擴展，但在嚴格模式代碼裏不容許作這樣的擴展。

語法

NumericLiteral :: DecimalLiteral HexIntegerLiteral OctalIntegerLiteral OctalIntegerLiteral :: 0 OctalDigit OctalIntegerLiteral OctalDigit OctalDigit :: 如下之一 0 1 2 3 4 5 6 7

語義

• NumericLiteral :: OctalIntegerLiteral 的 MV 是 OctalIntegerLiteral 的 MV。
• OctalDigit :: 0 的 MV 是 0。
• OctalDigit :: 1 的 MV 是 1。
• OctalDigit :: 2 的 MV 是 2。
• OctalDigit :: 3 的 MV 是 3。
• OctalDigit :: 4 的 MV 是 4。
• OctalDigit :: 5 的 MV 是 5。
• OctalDigit :: 6 的 MV 是 6。
• OctalDigit :: 7 的 MV 是 7。
• OctalIntegerLiteral :: 0 OctalDigit 的 MV 是 OctalDigit 的 MV。
• OctalIntegerLiteral :: OctalIntegerLiteral OctalDigit 的 MV 是 OctalIntegerLiteral 的 MV 乘以 8 再加上 OctalDigit 的 MV。

字符串直接量

7.8.4 中的語法、語義能夠作以下擴展，但在嚴格模式代碼裏不容許作這樣的擴展。

語法

EscapeSequence :: CharacterEscapeSequence OctalEscapeSequence HexEscapeSequence UnicodeEscapeSequence OctalEscapeSequence :: OctalDigit [lookahead ∉ DecimalDigit] ZeroToThree OctalDigit [lookahead ∉DecimalDigit] FourToSeven OctalDigit ZeroToThree OctalDigit OctalDigit ZeroToThree :: 如下之一 0 1 2 3 FourToSeven :: 如下之一 4 5 6 7

語義

• EscapeSequence :: OctalEscapeSequence 的 CV 是 OctalEscapeSequence 的 CV。
• OctalEscapeSequence :: OctalDigit [lookahead ∉ DecimalDigit] 的 CV 是個字符，它的 unicode 代碼單元值是 OctalDigit 的 MV 。
• OctalEscapeSequence :: ZeroToThree OctalDigit [lookahead ∉ DecimalDigit] 的 CV 是個字符，它的 unicode 代碼單元值是 ZeroToThree 的 MV 乘以 8 再加上 OctalDigit 的 MV。
• OctalEscapeSequence :: FourToSeven OctalDigit 的 CV 是個字符，它的 unicode 代碼單元值是 FourToSeven 的 MV 乘以 8 再加上 OctalDigit 的 MV。
• OctalEscapeSequence :: ZeroToThree OctalDigit OctalDigit 的 CV 是個字符，它的 unicode 代碼單元值是 (ZeroToThree 的 MV 乘以 64 (8²) ) 加上 ( 第一個OctalDigit 的 MV 乘以 8 ) 加上 OctalDigit 的 MV。
• ZeroToThree :: 0 的 MV 是 0.
• ZeroToThree :: 1 的 MV 是 1。
• ZeroToThree :: 2 的 MV 是 2。
• ZeroToThree :: 3 的 MV 是 3。
• FourToSeven :: 4 的 MV 是 4。
• FourToSeven :: 5 的 MV 是 5。
• FourToSeven :: 6 的 MV 是 6。
• FourToSeven :: 7 的 MV 是 7。

附加屬性

一些ECMAScript的實現可能會包含一些標準原生對象上的附加屬性。這一非標準附錄提示了一些這樣的屬性常見的語義，可是這並不意味着他們和其語義成爲標準的一部分。

escape(string)

escape函數是全局對象的一個屬性。它經過將一些字符替換成十六進制轉義序列，計算出一個新字符串值。

對於代碼單元小於等於0xFF的被替換字符，使用 %xx 格式的兩位數轉義序列。對於代碼單元大於0xFF的被替換字符，使用 %uxxxx 格式的四位數轉義序列。

用一個參數 string 調用 escape 函數，採用如下步驟：

1. 調用 ToString(string)。
2. 計算 Result(1) 的字符數。
3. 令 R 爲空字符串。
4. 令 k 爲 0。
5. 若是 k 等於 Result(2), 返回 R。
6. 得到 Result(1) 中 k 位置的字符（表示爲16位無符號整數）。
7. 若是 Result(6) 是69個非空字符 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@*_+-./" 之一，則轉到步驟13。
8. 若是 Result(6) 小於256，則轉到步驟11。
9. 令 S 爲包含六個字符 "%u wxyz" 的字符串，其中 wxyz 是用四個十六進制數字編碼的 Result(6) 值。
10. 轉到步驟14。
11. 令 S 爲包含三個字符 "% xy" 的字符串，其中 xy 是用兩個十六進制數字編碼的 Result(6) 值。
12. 轉到步驟14。
13. 令 S 爲包含單個字符 Result(6) 的字符串。
14. 令 R 爲將以前的 R 和 S 值連起來組成的新字符串。
15. k 遞增1。
16. 轉到步驟5。

這裏的編碼方式有部分是基於 RFC 1738 描述的編碼方式, 但本標準規定的完整編碼方式只有上面描述的這些，不考慮 RFC 1738 中的內容。 此編碼方式並無反映出從 RFC 1738 到 RFC 3986 的變化。

unescape(string)

unescape 函數是全局對象的一個屬性。它經過將每一個多是 escape 函數導入的轉義序列，分別替換成表明這些轉義序列的字符， 計算出一個新字符串值。

用一個參數 string 調用 unescape 函數，採用如下步驟：

1. 調用 ToString(string)。
2. 計算 Result(1) 的字符數。
3. 令 R 爲空字符串。
4. 令 k 爲 0。
5. 若是 k 等於 Result(2)，返回 R。
6. 令 c 爲 Result(1) 中 k 位置的字符。
7. 若是 c 不是 % ，轉到步驟18。
8. 若是 k 大於 Result(2)−6，轉到步驟14。
9. 若是 Result(1) 中 k+1 位置的字符不是 u，轉到步驟14。
10. 若是 Result(1) 中分別在 k+2，k+3，k+4，k+5 位置的四個字符不全是十六進制數字，轉到步驟14。
11. 令 c 爲一個字符，它的代碼單元值是 Result(1) 中 k+2，k+3，k+4，k+5 位置的四個十六進制數字表明的整數。
12. k 遞增 5。
13. 轉到步驟18。
14. 若是 k 大於 Result(2)−3，轉到步驟18。
15. 若是 Result(1) 中分別在 k+1，k+2 位置的兩個字符不都是十六進制數字，轉到步驟18。
16. 令 c 爲一個字符，它的代碼單元值是兩個零加上 Result(1) 中 k+1，k+2 位置的兩個十六進制數字表明的整數。
17. k 遞增 2。
18. 令 R 爲將以前的 R 和 c 值連起來組成的新字符串。
19. k 遞增 1。
20. 轉到步驟5。

String.prototype.substr(start, length)

substr 方法有兩個參數 start 和 length，將this對象轉換爲一個字符串，並返回這個字符串中從 start 位置一直到 length 位置（或若是 length 是 undefined，就一直到字符串結束位置）的字符組成的子串。若是 start 是負數，那麼它就被看成是 (sourceLength+start)，這裏的 sourceLength 是字符串的長度。返回結果是一個字符串值，不是 String 對象。採用如下步驟：

1. 將 this 值做爲參數調用ToString。
2. 調用 ToInteger(start)。
3. 若是 length 是 undefined，就用 +∞；不然調用 ToInteger(length)。
4. 計算 Result(1) 的字符數。
5. 若是 Result(2) 是正數或零，就用 Result(2)；不然使用 max(Result(4)+Result(2),0)。
6. 計算 min(max(Result(3),0), Result(4)–Result(5))。
7. 若是 Result(6) ≤ 0, 返回空字符串 "" 。
8. 返回一個由 Result(1) 中的 Result(5) 位置的字符開始的連續的 Result(6) 個字符組成的字符串。

substr 方法的 length 屬性是2。

substr 函數被刻意設計成通用的；它並不要求其 this 值爲字符串對象。所以它能夠做爲方法轉移到其餘種類的對象中。

Date.prototype.getYear( )

對於近乎全部用途，getFullYear 方法都是首選的，由於它避免了「2000年問題」。

無參數方式調用 getYear 方法，採用如下步驟：

1. 令 t 爲 this時間值。
2. 若是 t 是 NaN, 返回 NaN。
3. 返回 YearFromTime(LocalTime(t)) − 1900。

Date.prototype.setYear(year)

對於近乎全部用途， setFullYear 方法都是首選的，由於它避免了「2000年問題」。

用一個參數 year 調用 setYear 方法，採用如下步驟：

1. 令 t 爲 LocalTime(this時間值) 的結果；但若是 this 時間值是 NaN，那麼令 t 爲 +0。
2. 調用 ToNumber(year)。
3. 若是 Result(2) 是 NaN，將 this 值的 [[PrimitiveValue]] 內部屬性設爲 NaN，並返回 NaN。
4. 若是 Result(2) 不是 NaN 而且 0 ≤ ToInteger(Result(2)) ≤ 99 ，則 Result(4) 是 ToInteger(Result(2)) + 1900。不然，Result(4) 是 Result(2)。
5. 計算 MakeDay(Result(4), MonthFromTime(t), DateFromTime(t))。
6. 計算 UTC(MakeDate(Result(5), TimeWithinDay(t)))。
7. 將 this 值的 [[PrimitiveValue]] 內部屬性設爲 TimeClip(Result(6))。
8. 返回 this 值的 [[PrimitiveValue]] 內部屬性值。

Date.prototype.toGMTString( )

toUTCString 屬性是首選的，toGMTString 屬性是爲了兼容較老的代碼才提供的。建議在新的 ECMAScript 代碼中使用 toUTCString 屬性。

Date.prototype.toGMTString 的初始值是與 Date.prototype.toUTCString 的初始值相同的函數對象。

ECMAScript 的嚴格模式

嚴格模式下的限制說明

• 在嚴格模式下的代碼中，"implements", "interface", "let", "package", "private", "protected", "public", "static", 和 "yield" 都被做爲將來可能會使用到的保留字（7.6.12）。
• 符合規範的實現中，當處理嚴格模式下的代碼時，不該該像 B.1.1 中描述地那樣將 OctalIntegerLiteral 擴展到 NumericLiteral（7.8.3）的語法中。
• 符合規範的實現中，當處理嚴格模式下的代碼時，不該該像 B.1.2 中描述地那樣將 OctalEscapeSequence 擴展到 EscapeSequence 的語法中。
• 沒法註冊一個未定義的標識符或者其餘沒法解析的引用到全局對象下。當在嚴格模式下進行一個簡單註冊時，它左部不能解析爲一個沒法解析的引用。若是是沒法解析的，那麼就會拋出一個 ReferenceError 異常。左部也不能是一個數據屬性的引用，
• eval 或者 arguments 不能出如今一個註冊操做（11.13）或者一個 Postfix 表達式的左部，也不能做爲 Prefix Increment（11.4.4）或者 prefix decrement 操做（11.4.5）上面的一元表達式操做。
• 嚴格模式下的 arguments 對象定義了不可配置的存取屬性，包括「caller」和「callee」，若是訪問這兩個對象則會拋出一個類型錯誤。
• 嚴格模式下的 Arguments 對象不會動態共享它們的數組索引值，這些索引值包含了函數綁定時對應格式的參數。
• 嚴格模式下的函數中，若是一個參數對象綁定了做用域內的 arguments 標識符來獲取參數對象，那麼這個參數對象是不可變的，並在以後也不能進行註冊操做。
• 在嚴格模式下，若是代碼包含了一個含有一個以上任意數據屬性的定義，那麼這就是一個語法錯誤。
• 在嚴格模式下，若是 eval 或者 argument 出如今屬性參數列表中，那麼這就是一個語法錯誤

第 5 版中可能會對第 3 版產生兼容性影響的更正及澄清

全體：在第 3 版規範中像「就像用表達式 new Array() 同樣」這樣的短語的意思受到了誤解。第 5 版規範中，對標準內置對象、屬性的全部內部引用和內部調用相關文本描述，都作了澄清：應使用實際的內置對象，而不是對應命名屬性的當前動態值。

11.8.2，11.8.3，11.8.5：ECMAScript 整體上是以從左到右的順序解釋執行，可是第 3 版規範中 > 和 <= 運算符的描述語言致使了局部從右到左的順序。本規範已經更正了這些運算符，如今徹底是從左到右的順序解釋執行。然而，這個對順序的修改，若是在解釋執行過程期間產生反作用，就有可能被觀察到。

11.1.4：第 5 版澄清了 Array Initialiser 結束位置的尾端逗號不計入數組長度。這不是對第 3 版語義的修改，但有些實如今以前可能對此有誤解。

11.2.3：第 5 版調換了算法步驟 2 和 3 的順序。第 1 版一直到第 3 版規定的順序是錯誤的，原來的順序在解釋執行 Arguments 時有反作用，可能影響到 MemberExpression 的解釋執行結果。

12.14：在第 3 版中，對於傳給 try 語句的 catch 子句的異常參數的名稱解析，用與 new Object() 同樣的方式建立一個對象來做爲解析這個名稱的做用域。若是實際的異常對象是個函數而且在catch 子句中調用了它，那麼做用域對象將會做爲 this 值傳給這個調用。在函數體裏能夠給它的 this 值定義新屬性，而且這些屬性名將在函數返回以後在 catch 子句的做用域內變成可見的標識符綁定。在第 5 版中，若是把異常參數做爲函數來調用，傳入的 this 值是 undefined 。

13：在第 3 版中，有 Identifier 的 FunctionExpression 產生式的算法，用與 new Object() 同樣的方式建立一個對象並加入到做用域鏈中，用來提供函數名查找的做用域。標識符解析規則（第 3 版裏的 10.1.4 ）會做用在這樣的對象上，若是須要，還會用對象的原型鏈來嘗試解析標識符。這種方式使得 Object.prototype 的全部屬性以標識符的形式在這個做用域裏可見。實踐中，大多數第 3 版的實現都沒有實行這個語義。地 5 版更改了這裏的語義，用一個聲明式環境記錄項來綁定了函數名。

14：在第 3 版中，產生式 SourceElements : SourceElements SourceElement 的算法不像相同形式的 Block，對 statement 的結果值作正確的傳遞。這可致使 eval 函數解釋執行一個 Program 文本時產生錯誤的結果。實踐中，大多數第 3 版的實現都作了正確的傳遞，而不關心第 5 版規定了什麼。

15.10.6：RegExp.prototype 如今是一個 RegExp 對象，而不是 Object 的一個實例。用 Object.prototype.toString 可看到它的 [[Class]] 內部屬性值如今是 "RegExp"，不是 "Object"。

第 5 版內容的增長與變化，介紹第 3 版不兼容問題

7.1：Unicode 格式控制字符在受處處理以前再也不從 ECMAScript 源文本中剝離。在第五版中，若是這樣一個字符在字符串字面量或者正則表達式字面量中出現，這個字符會被合併到字面量中，而在第三版裏，這個字符不會被合併。

7.2：Unicode 字符 <BOM> 如今是做爲空格使用，若是它出如今本該是一個標識符的位置的中間，則會產生一個語法錯誤，而在第三版裏不會。

7.3：換行符之前是做爲轉義字符處理，而如今容許換行符被包含在字符串字面量標記中。這在第三版中會產生一個語法錯誤。

7.8.5：如今的正則表達式字面量在字面量解析執行的時候都會返回一個惟一的對象。這個改變能夠被任意測試字面量值的對象 ID 或者一些敏感的反作用的程序檢測到。

7.8.5：第五版要求提早拋出任意可能的正則表達式結構錯誤，這些結構錯誤會在將正則表達式字面量轉換成正則表達式對象的時候產生。在第五版以前的實現容許延遲拋出 [TypeError]，直到真正執行到這個對象。

7.8.5：在第五版中，未轉義的 "/" 字符能夠做爲 CharacterClass 存在於正則表達式字面量中。在第三版裏，這樣的字符是做爲字面量的最後一個字符存在。

10.4.2：在第五版中，間接調用 eval 函數會將全局對象做爲 執行代碼 的變量環境和 詞法環境 。在第三版中，[eval] 函數的間接調用者的變量和 詞法環境 是做爲 執行代碼 的環境使用。

15.4.4：在第五版中，全部 Array.prototype 下的方法都是通用的。在第三版中，toString 和 toLocaleString 方法不是通用的，若是被非 Array 實例調用時會拋出一個 TypeError 的異常。

10.6：在第五版中，argument 對象與實際的參數符合，它的數組索引屬性是可枚舉的。在第三版中，這些屬性是不可枚舉的。

10.6：在第五版中，一個 arguments 對象的 Class 內置屬性值是「Arguments」。在第三版中，它是「Object」。當對 argument 對象調用toString 的時候

12.6.4：當 in 表達式執行一個 null 或者 undefined 時 ,for-in 語句再也不拋出 TypeError。取而代之的是將其做爲不包含可枚舉屬性的對象執行。

15：在第五版中，下面的新屬性都是在第三種中已存在的內建對象中定義，Object.getPrototypeOf, Object.getOwnPropertyDescriptor, Object.getOwnPropertyNames, Object.create, Object.defineProperty, Object.defineProperties, Object.seal, Object.freeze, Object.preventExtensions, Object.isSealed, Object.isFrozen, Object.isExtensible, Object.keys, Function.prototype.bind, Array.prototype.indexOf, Array.prototype.lastIndexOf, Array.prototype.every, Array.prototype.some, Array.prototype.forEach, Array.prototype.map, Array.prototype.filter, Array.prototype.reduce, Array.prototype.reduceRight, String.prototype.trim, Date.now, Date.prototype.toISOString, Date.prototype.toJSON。

15：實現如今要求忽略內建方法中的額外參數，除非明確指定。在第三版中，並無規定額外參數的處理方式，實現中明確容許拋出一個 TypeErrorBold text 錯誤。

15.1.1：全局對象的值屬性 NaN，Infinity 和 Undefined 改成只讀屬性。

15.1.2.1：實現再也不容許約束非直接調用 eval 的方式。另外間接調用 eval 會使用全局對象做爲變量環境，而不是使用調用者的變量環境做爲變量環境。

15.1.2.2：parseInt 的規範再也不容許實現將 0 開頭的字符串做爲 8 進制值。

15.3.4.3：在第三版中，若是傳入 Function.prototype.apply 的第二個參數不是一個數組對象或者一個 arguments 對象，就會拋出一個TypeError。在第五版中，參數也能夠是任意類型的含有 length 屬性的類數組對象。

15.3.4.3，15.3.4.4：在第三版中，在 Function.prototype.apply 或者 Function.prototype.call 中傳入 undefined 或者 null 做爲第一個參數會致使 全局對象 被做爲一個個參數傳入，間接致使目標函數的 [this] 會指向全局變量環境。若是第一個參數是一個 原始值 ，在 原始值 上調用 ToObject 的結果會做爲 this 的值。在第五版中，這些轉換不會出現，目標函數的 this 會指向真實傳入的參數。這個不一樣點通常狀況下對已存在的遵循 ECMAScript 第三版的代碼來講不太明顯，由於相應轉換會在目標函數生效以前執行。然而，基於不一樣的實現，若是使用 apply 或者 call 調用函數時，這個不一樣點就會很明顯。另外，用這個方法調用一個標準的內建函數，並使用 null 或者 undefined 做爲參數時，極可能會致使第五版標準下的實現與第三版標準下的實現不一樣。特別是第五版中表明性地規定了須要將實際調用的傳入的 this值做爲對象的內建函數，在傳入 null 或者 undefined 做爲 this 值時，會拋出一個 TypeError 異常。

15.3.5.2：在第五版中，函數實例的 prototype 屬性是不可枚舉的。在第三版中，是能夠枚舉的。

15.5.5.2：在第五版中，一個字符串對象的 primitiveValue 的單個字符能夠做爲字符串對象的數組索引屬性訪問。這些屬性是不可泄也不可配置的，並會影響任意名字相同的繼承屬性。在第三版中，這些屬性不會存在，ECMAScript 代碼能夠經過這些名字動態添加和移除可寫的屬性並訪問以這些名字繼承的屬性。

15.9.4.2：Date.parse 方法如今不要求第一個參數首先做爲 ISO 格式字符串解析。使用這個格式可是基於特定行爲實現（包括將來的一些行爲）或許會表現的不太同樣。

15.10.2.12：在第五版中，\s 如今能夠匹配 <BOM> 了

15.10.4.1：在第三版中，由 RegExp 構造器建立的對象的 source 字符串的精確形式由實現定義。在第五版中，字符串必須符合肯定的指定條件，所以會和第三版標準的實現的結果不同。

15.10.6.4：在第三版中，RegExp.prototype.toString 的規則不須要由 RegExp 對象的 source 屬性決定。在第五版中，結果必須由 source 屬性經由一個指定的規則，所以會和第三版實現的結果不同。

15.11.2.1，15.11.4.3：在第五版中，若是一個錯誤對象的 message 屬性原始值沒有經過 Error 構造器指定，那麼這個原始值就是一個空的字符串。在第三版中，這個原始值由實現決定。

15.11.4.4：在第三版中，Error.prototype.toString 的結果是由實現定義的。在第五版中，有完整的規範指定，所以可能會和第三版的實現不一樣。

15.12： 在第五版中，JSON 是在全局環境中定義的。第三版中，測試這個名詞的存在會發現它是 undefined，除非這個程序或者實現定義了這個名詞。

5.1 版中技術上的重大更正和闡明

7.8.4: CV 定義追加了 DoubleStringCharacter :: LineContinuation 與 SingleStringCharacter :: LineContinuation.

10.2.1.1.3：參數 S 是不能被忽略的。它控制着試圖設置一個不可改變的綁定時是否拋出異常。

10.2.1.2.2：在算法的第 5 步，真被傳遞後最後一個參數爲 [[DefineOwnProperty]]。

10.5：當重定義全局函數使，原算法步驟 5.E 調整爲如今的 5.F，並加入一個新的步驟 5.E 用來還原與第三版的兼容性。

11.5.3：在最後符號項，指定使用 IEEE754 舍入到最接近模式。

12.6.3：在步驟 3.a.ii 的兩種算法中修復缺失的 ToBoolean。

12.6.4：在最後兩段的額外最後一句中，闡明某些屬性枚舉的規定。

12.7，12.8，12.9：BNF 的修改成闡明 continue 或 break 語句沒有一個 Identifier 或一個 return 語句沒有一個 Expression 時，在分號以前能夠有一個 LineTerminator 。

12.14：算法 1 的步驟 3 算法 3 的步驟 2.a 中，糾正這樣的值域 B 是做爲參數傳遞而不是 B 自己。

15.1.2.2：在算法的步驟 2 中闡明 S 多是空字符串。

15.1.2.3：在算法的步驟 2 中闡明 trimmedString 能夠是空字符串。

15.1.3：添加註釋闡明 ECMAScript 中的 URI 語法基於 RFC 2396 和較新的 RFC 3986。

15.2.3.7：在算法步驟 5 和 6 中更正使用變量 P。

15.2.4.2：第五版處理 undefined 和 null 值致使現有代碼失敗。規範修改成保持這樣的代碼的兼容性。在算法中加入新的步驟 1 和 2。

15.3.4.3：步驟 5 和 7 版 5 算法已被刪除，由於它們規定要求 argArray 參數與泛數組狀對象的其它用法不一致。

15.4.4.12：在步驟 9.A，用 actualStart 替換不正確 relativeStart 引用。

15.4.4.15：闡明 fromIndex 的默認值是數組的長度減去 1。

15.4.4.18：在算法的第 9 步，undefined 是如今指定的返回值。

15.4.4.22：在步驟 9.c.ii 中，第一個參數的 [[Call]] 內部方法已經改變爲 undefined，保持與 Array.prototype.reduce 定義的一致性。

15.4.5.1：在算法步驟 3.l.ii 和 3.l.iii 中，變量的名字是相反的，致使一個不正確的相反測試。

15.5.4.9：規範要求每有關規範等效字符串刪除，算法從每個段落都承接 ，由於它在注 2 中被列爲建議的。

15.5.4.14：在 split 算法步驟 11.A 和 13.a，SplitMatch 參數的位置順序已修正爲匹配 SplitMatch 的實際參數特徵。在步 13.a.iii.7.d，lengthA 取代 A.length。

15.5.5.2：在首段中，刪除的單個字符屬性訪問「array index」語義的含義。改進算法步驟 3 和 5，這樣它們不執行「array index」的要求。

15.9.1.15：爲缺失字段指定了合法值範圍。淘汰「time-only」格式。全部可選字段指定默認值。

15.10.2.2：算法步驟編號爲第二步所產生的內部閉包被錯誤的編號，它們是額外的算法步驟。

15.10.2.6：在步驟 3 中的列表中抽象運算符 IsWordChar 的第一個字符是「a」而不是「A」。

15.10.2.8：在閉包算法返回抽象運算符 CharacterSetMatcher 中 ，爲了不與一個閉包的形參名稱衝突，步驟 3 中定義的變量做爲參數傳遞在第 4 步改名爲 ch。

15.10.6.2：步驟 9.e 被刪除，由於它執行了 I 的額外增量。

15.11.1.1：當 message 參數是 undefined 時，撤銷 message 自身屬性設置爲空字符串的要求。

15.11.1.2：當 message 參數是 undefined 時，撤銷 message 自身屬性設置爲空字符串的要求。

15.11.4.4：步驟 6-10 修改 / 添加正確處理缺乏或空的 message 屬性值。

15.11.1.2: 移除了當message參數爲undefined時將messge自身屬性設爲空字符串的要求。

15.12.3：在 JA 的內部操做的第一步 10.b.iii，串聯的最後一個元素是 「]」。

B.2.1：追加註釋，說明編碼是基於 RFC 1738 而不是新的 RFC 3986。

附錄 C：增長了 FutureReservedWords 在標準模式下的相應內容到 7.6.12 節。

參考書目

1. ANSI/IEEE Std 754-1985: IEEE Standard for Binary Floating-Point Arithmetic. Institute of Electrical and Electronic Engineers, New York (1985)
2. The Unicode Consortium. The Unicode Standard, Version 3.0, defined by: The Unicode Standard, Version 3.0 (Boston, MA, Addison-Wesley, 2000. ISBN 0-201-61635-5)
3. Unicode Inc. (1998), Unicode Technical Report #15: Unicode Normalization Forms
4. ISO 8601:2004(E) Data elements and interchange formats – Information interchange -- Representation of dates and times
5. RFC 1738 「Uniform Resource Locators (URL)」, available at <http://tools.ietf.org/html/rfc1738>
6. RFC 2396 「Uniform Resource Identifiers (URI): Generic Syntax」, available at <http://tools.ietf.org/html/rfc2396>
7. RFC 3629 「UTF-8, a transformation format of ISO 10646」, available at <http://tools.ietf.org/html/rfc3629>
8. RFC 4627 「The application/json Media Type for JavaScript Object Notation (JSON)「 , available at <http://tools.ietf.org/html/rfc4627>