ES5 標準對象說明

全局對象

English

test262

唯一的全局對象在控制進入任何執行環境前被創建。

除非另外指明，全局對象的標準內置屬性擁有特性 {[[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}。

全局對象沒有 [[Construct]] 內部屬性 ; 全局對象不可能當做構造器用 new 運算符調用。

全局對象沒有 [[Call]] 內部屬性，全局對象不可能當做函數來調用。

全局對象的 [[Prototype]] 和 [[Class]] 內部屬性值是依賴於實現的。

除了本規範定義的屬性之外，全局對象還可以擁有額外的宿主定義的屬性。全局對象可包含一個值是全局對象自身的屬性；例如，在 HTML 文檔對象模型中全局對象的 window 屬性是全局對象自身。

全局對象的值屬性

English

NaN

English

NaN 的值是 NaN（見 8.5）。這個屬性擁有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Infinity

English

Infinity 的值是 +∞（見 8.5）。這個屬性擁有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

undefined

English

undefined 的值是 undefined（見 8.1）。這個屬性擁有特性 <{ [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

全局對象的函數屬性

English

eval (x)

test262

當用一個參數 x 調用 eval 函數，採用如下步驟：

如果 Type(x) 不是 String，返回 x。
令 prog 爲 ECMAScript 代碼，它是將 x 作爲一個程序解析的結果。如果解析失敗，拋出一個 SyntaxError 異常 ( 見 16 章 )。
令 evalCtx 爲給 eval 代碼 prog 建立的新執行環境 (10.4.2)。
令 result 爲解釋執行程序 prog 的結果。
退出執行環境 evalCtx，恢復到之前的執行環境。
如果 result.type 是 normal 並且其完結類型值是 V，則返回 V 值。
如果 result.type 是 normal 並且其完結類型值是 empty，則返回 undefined 值。
否則，result.type 必定是 throw。將 result.value 作爲異常拋出。

直接調用 Eval

English

一個 eval 函數的直接調用是表示爲符合以下兩個條件的 CallExpression：

解釋執行 CallExpression 中的 MemberExpression 的結果是個引用，這個引用擁有一個環境記錄項作爲其基值，並且這個引用的名稱是 "eval"。

以這個引用作爲參數調用 GetValue 抽象操作的結果是 15.1.2.1 定義的標準內置函數。

parseInt (string, radix)

English

test262

parseInt 函數產生一個根據 radix 來解釋 string 得到的整數值。 string 開頭的空白會被忽略。如果 radix 是 undefined 或 0，則將 radix 當作 10 處理，除非數字是以字符對 0x 或 0X 開頭，在這種情形下將 radix 當作是 16。如果傳入的 radix 參數直接就是 16，那麼在數字前面加上 0x 或 0X 也無妨。

當調用 parseInt 函數時，採用以下步驟：

令 inputString 爲 ToString(string)。
令 S 爲一個新創建的子字符串，它由 inputString 的第一個非 StrWhiteSpaceChar 字符和它後面跟着的所有字符組成。( 換句話說，刪掉前面的空白。) 如果 inputString 不包含任何這樣的字符，則令 S 爲空字符串。
令 sign 爲 1。
如果 S 不爲空並且 S 的第一個字符是減號 -，則令 sign 爲 −1。
如果 S 不是空並且 S 的第一個字符加號 + 或減號 -，則刪除 S 的第一個字符。
令 R = ToInteger(radix)。
令 stripPrefix 爲 true。
如果 R ≠ 0，則
1. 如果 R < 2 或 R > 36，則返回 NaN。
2. 如果 R ≠ 16，令 stripPrefix 爲 false。
否則，R = 0
1. 令 R = 10。
如果 stripPrefix 是 true，則
1. 如果 S 長度大於 2 並且 S 的頭兩個字符是 “0x” 或 “0X”，則刪除 S 的頭兩個字符並且令 R = 16。
如果 S 包含任何不是 R進制 數位的字符，則令 Z 爲 S 中這樣的字符之前的所有字符組成的子字符串；否則令 Z 爲 S 。
如果 Z 是空，返回 NaN。
令 mathInt 爲 Z 的 R進制 表示的數學值，用字母 A-Z 和 a-z 來表示 10 到 35 之間的值。( 但如果 R 是 10 並且 Z 包含多餘 20 位的值，可以替換 20 位後的每個數字爲 0，這是實現可選的功能；如果 R 不是 2、4、8、10、16、32，則 mathInt 可以是 Z 的 R進制 表示的依賴於實現的近似值。)
令 number 爲 mathInt 的 Number 值。
返回 sign × number。

注：parseInt 可以只把 string 的開頭部分解釋爲整數值；它會忽略所有不能解釋爲整數記法的一部分的字符，並且沒有指示會給出任何這些忽略的字符。

parseFloat (string)

English

test262

parseFloat 函數根據 string 參數的內容解釋爲十進制字面量的結果來決定，產生一個數值。

當調用 parseFloat 函數，採用以下步驟：

令 inputString 爲 ToString(string)。
令 trimmedString 爲一個新創建的子字符串，它由 inputString 的非 StrWhiteSpaceChar 字符的最左邊字符和它右邊跟着的所有字符組成。( 換句話說，刪掉前面的空白。) 如果 inputString 不包含任何這樣的字符，則令 trimmedString 爲空字符串。
如果 trimmedString 或 trimmedString 的任何前綴都不滿足 StrDecimalLiteral 的語法，返回 NaN。
令 numberString 爲滿足 StrDecimalLiteral 語法的 trimmedString 的最長前綴，可能是 numberString 自身。
返回 numberString 數學值的 Number 值。

注： parseFloat 可以只把 string 的開頭部分解釋爲數值；它會忽略所有不能解釋爲數值字面量記法的一部分的字符，並且沒有指示會給出任何這些忽略的字符。

isNaN (number)

English

test262

如果指定參數爲 NaN，則返回 true，否則返回 false。

如果 ToString(number) 是 NaN，返回 true。
否則，返回 false。

注：一個用 ECMAScript 代碼來測試值 X 是否是 NaN 的方式是使用表達式 X !== X。僅當 X 是 NaN 時結果纔是 true。

isFinite (number)

English

test262

如果指定參數爲 NaN 或 +∞或−∞，則返回 false，否則返回 true。

如果 ToNumber(number) 是 NaN 或 +∞ 或 −∞，返回 false。
否則，返回 true。

處理 URI 的函數屬性

English

統一資源標識符，或叫做 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 :::
   uriCharacters_opt

 uriCharacters :::
   uriCharacter uriCharacters_opt

 uriCharacter :::
   uriReserved
   uriUnescaped
   uriEscaped

 uriReserved ::: one of
   ; / ? : @ & = + $ ,

 uriUnescaped :::
   uriAlpha
   DecimalDigit
   uriMark

 uriEscaped :::
   % HexDigit HexDigit

 uriAlpha ::: one of
   a b c d e f g h i j k l m n o p q r s t u v w x y z
   A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

 uriMark ::: one of
   - _ . ! ~ * ' ( )

注：以上語法是基於 RFC 2396 的，並且較新的 RFC 3986 引入的更改沒有反應在這裏。

當 URI 裏包含一個沒在上面列出的字符或有時不想讓給定的保留字符有特殊意義，那麼必須編碼這個字符。字符被轉換成 UTF-8 編碼，首先從 UTF-16 轉換成相應的代碼點值的替代。（注：對於 [0,127] 範圍的代碼單元，轉換到單字節時它們的值是相同的。）然後返回的字節序列轉換爲一個字符串，每個字節用一個“%xx”形式的轉移序列表示。

描述編碼和轉義過程的抽象操作 Encode 需要兩個字符串參數 string 和 unescapedSet。

令 strLen 爲 string 的字符個數。
令 R 爲空字符串。
令 k 爲 0。
重複
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。

令 strLen 爲 string 的字符個數。
令 R 爲空字符串。
令 k 爲 0。
重複
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 的字節數組。
    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 轉換得到的值，這是從一個字節數組到一個21位值的轉換過程。如果 Octets 不包含有效的 UTF-8 編碼的 Unicode 代碼點，則拋出一個 URIError 異常。
    9. 如果 V 小於 0x10000，則
      1. 令 C 爲代碼單元值是 V 的字符。
      2. 如果 C 不在 reservedSet 裏，則
        
        令 S 爲只包含字符 C 的字符串。
      3. 否則，C 在 reservedSet 裏
        
        令 S 爲 string 的從位置 start 到位置 k 的子字符串。
    10. 否則，V ≥ 0x10000
      1. 令 L 爲 (((V – 0x10000) & 0x3FF) + 0xDC00)。
      2. 令 H 爲 ((((V – 0x10000) >> 10) & 0x3FF) + 0xD800)。
      3. 令 S 爲代碼單元值是 H 和 L 的兩個字符組成的字符串。
令 R 爲之前的 R 和 S 連接成的新字符串。
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 編碼。

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

在這裏

uuuuu = vvvv + 1

以補足替代符的 0x10000 附加值，在 Unicode 標準 3.7 章節。

0xD800-0xDFFF 範圍的代碼單元值用來編碼替代符對；如上將 UTF-16 替代符對轉換組合成一個 UTF-32 表示法，並將其編碼到一個 UTF-8 的21位值中。這就是替代符對的解碼方式。

RFC 3629 禁止對無效 UTF-8 字節序列的解碼。例如，無效序列 C0 80 不能解碼成字符 U+0000。當 Decode 算法的實現遇到這樣的無效序列必須拋出一個 URIError 異常。

decodeURI (encodedURI)

English

decodeURI 函數計算出一個新版 URI，將 URI 中可能是 encodeURI 函數引入的每個轉義序列和 UTF-8 編碼組替換爲代表它們的字符。不是 encodeURI 導入的轉義序列不會被替換。

當以一個參數 encodedURI 調用 decodeURI 函數，採用如下步驟：

令 uriString 爲 ToString(encodedURI)。
令 reservedURISet 爲一個包含 uriReserved 中的所有字符組成的字符串連接上 "#" 組成的字符串。
返回調用 Decode(uriString, reservedURISet) 的結果。

注： "#" 字符不會從轉義序列中解碼，即使它不是 URI 保留字符。

decodeURIComponent (encodedURIComponent)

English

decodeURIComponent 函數計算出一個新版 URI，將 URI 中可能是 encodeURIComponent 函數引入的每個轉義序列和 UTF-8 編碼組替換爲代表它們的字符。

當以一個參數 encodedURIComponent 調用 decodeURIComponent 函數，採用如下步驟：

令 componentString 爲 ToString(encodedURIComponent)。
令 reservedURIComponentSet 爲一個空字符串。
返回調用 Decode(componentString, reservedURIComponentSet) 的結果。

encodeURI (uri)

English

encodeURI 函數計算出一個新版 URI，將 URI 中某些字符的每個實例替換爲代表這些字符 UTF-8 編碼的一個，兩個或三個轉義序列。

當以一個參數 uri 調用 encodeURI 函數，採用如下步驟：

令 uriString 爲 ToString(uri)。
令 unescapedURISet 爲一個包含 uriReserved 和 uriUnescaped 中所有字符組成的字符串連接上 "#" 組成的字符串。
返回調用 Encode(uriString, unescapedURISet) 的結果。

注：字符 "#" 不會被編碼爲一個轉義序列，即使它不是 URI 保留字符或非轉義字符。

encodeURIComponent (uriComponent)

English

encodeURIComponent 函數計算出一個新版 URI，將 URI 中某些字符的每個實例替換爲代表這些字符 UTF-8 編碼的一個，兩個或三個轉義序列。

當以一個參數 uriComponent 調用 encodeURIComponent 函數，採用如下步驟：

令 componentString 爲 ToString(uriComponent)。
令 unescapedURIComponentSet 爲一個包含 uriUnescaped 中所有字符組成的字符串。
返回調用 Encode(componentString, unescapedURIComponentSet) 的結果。

見 15.11.6.1.

RangeError ( . . . )

English

見 15.11.6.2.

ReferenceError ( . . . )

English

見 15.11.6.3.

SyntaxError ( . . . )

English

見 15.11.6.4.

TypeError ( . . . )

English

見 15.11.6.5.

URIError ( . . . )

English

見 15.11.6.6.

全局對象的其他屬性

English

Math

English

見 15.8.

JSON

English

見 15.12.

Object 對象

English

test262

作爲函數調用 Object 構造器

English

當把 Object 當做一個函數來調用，而不是一個構造器，它會執行一個類型轉換。

Object ( [ value ] )

English

當以一個參數 value 或者無參數調用 Object 函數，採用如下步驟：

如果 value 是 null、undefined 或未指定，則創建並返回一個新 Object 對象，這個對象與彷彿用相同參數調用標準內置的 Object 構造器 (15.2.2.1) 的結果一樣。
返回 ToObject(value)。

Object 構造器

English

當 Object 是 new 表達式調用的一部分時，它是一個構造器，可創建一個對象。

new Object ( [ value ] )

English

當以一個參數 value 或者無參數調用 Object 構造器，採用如下步驟：

如果提供了 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)。
斷言：未提供參數 value 或其類型是 Null 或 Undefined。
令 obj 爲一個新創建的原生 ECMAScript 對象。
設定 obj 的 [[Prototype]] 內部屬性爲標準內置的 Object 的 prototype 對象 (15.2.4)。
設定 obj 的 [[Class]] 內部屬性爲 "Object"。
設定 obj 的 [[Extensible]] 內部屬性爲 true。
設定 obj 的 8.12 指定的所有內部方法
返回 obj。

Object 構造器的屬性

English

Object 構造器的 [[Prototype]] 內部屬性值是標準內置 Function 的 prototype 對象。

除了內部屬性和 length 屬性（其值是 1）之外，Object 構造器擁有以下屬性：

Object.prototype

English

Object.prototype 的初始值是標準內置 Object 的 prototype 對象（15.2.4）。

這個屬性包含特性 {[[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }

Object.getPrototypeOf ( O )

English

當以參數 O 調用 getPrototypeOf 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常。
返回 O 的 [[Prototype]] 內部屬性的值。

Object.getOwnPropertyDescriptor ( O, P )

English

當調用 getOwnPropertyDescriptor 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常。
令 name 爲 ToString(P)。
令 desc 爲以參數 name 調用 O 的 [[GetOwnProperty]] 內部方法的結果。
返回調用 FromPropertyDescriptor(desc) 的結果。

Object.getOwnPropertyNames ( O )

English

當調用 getOwnPropertyNames 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常。
令 array 爲彷彿是用表達式 new Array () 創建新對象的結果，這裏的 Array 是標準內置構造器名。
令 n 爲 0。
對 O 的每個自身屬性 P
1. 令 name 爲值是 P 的名稱的字符串。
2. 以 ToString(n) 和屬性描述 {[[Value]]: name, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 爲參數調用 array 的 [[DefineOwnProperty]] 內部方法。
3. n 遞增 1。
返回 array。

注：如果 O 是一個字符串實例，第4步 處理的自身屬性集合包含 15.5.5.2 定義的隱藏屬性，他們對應對象的 [[PrimitiveValue]] 字符串中相應位置的字符。

Object.create ( O [, Properties] )

English

create 函數按照指定的原型創建一個新對象。當調用 create 函數，採用如下步驟：

如果 Type(O) 不是 Object 或 Null，則拋出一個 TypeError 異常。
令 obj 爲彷彿是用表達式 new Object() 創建新對象的結果，這裏的 Object 是標準內置構造器名。
設定 obj 的 [[Prototype]] 內部屬性爲 O。
如果傳入了 Properties 參數並且不是 undefined，則彷彿是用 obj 和 Properties 當作參數調用標準內置函數 Object.defineProperties 一樣給 obj 添加自身屬性。
返回 obj。

Object.defineProperty ( O, P, Attributes )

English

defineProperty 函數用於給一個對象添加一個自身屬性以及更新現有自身屬性的特性。當調用 defineProperty 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常。
令 name 爲 ToString(P)。
令 desc 爲以 Attributes 作爲參數調用 ToPropertyDescriptor 的結果。
以 name、desc、true 作爲參數調用 O 的 [[DefineOwnProperty]] 內部方法 .
返回 O。

Object.defineProperties ( O, Properties )

English

defineProperties 函數用於給一個對象添加一些自身屬性以及更新現有的一些自身屬性的特性。當調用 defineProperties 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常。
令 props 爲 ToObject(Properties)。
令 names 爲一個內部列表，它包含 props 的每個可遍歷自身屬性的名稱。
令 descriptors 爲一個空的內部列表。
對 names 的每個元素 P，按照列表順序 ,
1. 令 descObj 爲以 P 作爲參數調用 props 的 [[Get]] 內部方法的結果。
2. 令 desc 爲以 descObj 作爲參數調用 ToPropertyDescriptor 的結果。
3. 將 desc 插入 descriptors 的尾部。
對 descriptors 的每個元素 desc，按照列表順序 ,
1. 以參數 P、desc、true 調用 O 的 [[DefineOwnProperty]] 內部方法。
返回 O

如果一個實現爲 for-in 語句的定義了特定的枚舉順序，那麼在這個算法的 第3步 中的列表元素必須也用相同的順序排列。

Object.seal ( O )

English

當調用 seal 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常。
對 O 的每個命名自身屬性名 P,
1. 令 desc 爲以參數 P 調用 O 的 [[GetOwnProperty]] 內部方法的結果。
2. 如果 desc.[[Configurable]] 是 true，設定 desc.[[Configurable]] 爲 false。
3. 以 P、desc、true 爲參數調用 O 的 [[DefineOwnProperty]] 內部方法。
設定 O 的 [[Extensible]] 內部屬性爲 false。
返回 O。

Object.freeze ( O )

English

當調用 freeze 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常。
對 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]] 內部方法。
設定 O 的 [[Extensible]] 內部屬性爲 false。
返回 O。

Object.preventExtensions ( O )

English

當調用 preventExtensions 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常 .
設定 O 的 [[Extensible]] 內部屬性爲 false。
返回 O。

Object.isSealed ( O )

English

當以參數 O 調用 isSealed 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常。
對 O 的每個命名自身屬性名 P，
1. 令 desc 爲以參數 P 調用 O 的 [[GetOwnProperty]] 內部方法的結果 .
2. 如果 desc.[[Configurable]] 是 true，則返回 false。
如果 O 的 [[Extensible]] 內部屬性是 false，則返回 true。
否則，返回 false。

Object.isFrozen ( O )

English

當以參數 O 調用 isFrozen 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常。
對 O 的每個命名自身屬性名 P,
1. 令 desc 爲以參數 P 調用 O 的 [[GetOwnProperty]] 內部方法的結果 .
2. 如果 IsDataDescriptor(desc) 是 true，則
  1. 如果 desc.[[Writable]] 是 true，則返回 false。
3. 如果 desc.[[Configurable]] 是 true，則返回 false。
如果 O 的 [[Extensible]] 內部屬性是 false，則返回 true。
否則，返回 false。

Object.isExtensible ( O )

English

當以參數 O 調用 isExtensible 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常。
返回 O 的 [[Extensible]] 內部屬性布爾值。

Object.keys ( O )

English

當以參數 O 調用 keys 函數，採用如下步驟：

如果 Type(O) 不是 Object，則拋出一個 TypeError 異常。
令 n 爲 O 的可遍歷自身屬性的個數
令 array 爲彷彿是用表達式 new Array() 創建新對象的結果，這裏的 Array 是標準內置構造器名。
令 index 爲 0。
對 O 的每個可遍歷自身屬性名 P，
1. 以 ToString(index)，屬性描述 {[[Value]]: P, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}，和 false 作爲參數調用 array 的 [[DefineOwnProperty]] 內部方法。
2. index 遞增 1。
返回 array。

如果一個實現爲 for-in 語句的定義了特定的枚舉順序，那麼在這個算法的 第5步 中的必須使用相同的枚舉順序。

Object 的 prototype 對象的屬性

English

Object 的 prototype 對象的 [[Prototype]] 內部屬性的值是 null ，[[Class]] 內部屬性的值是 "Object"，[[Extensible]] 內部屬性的初始值是 true。

Object.prototype.constructor

English

Object.prototype.constructor 的初始值是標準內置的 Object 構造器。

Object.prototype.toString ( )

English

當調用 toString 方法，採用如下步驟：

如果 this 的值是 undefined，返回 "[object Undefined]"。
如果 this 的值是 null，返回 "[object Null]"。
令 O 爲以 this 作爲參數調用 ToObject 的結果。
令 class 爲 O 的 [[Class]] 內部屬性的值。
返回三個字符串 "[object "、class 和 "]" 連起來的字符串。

Object.prototype.toLocaleString ( )

English

當調用 toLocaleString 方法，採用如下步驟：

令 O 爲以 this 作爲參數調用 ToObject 的結果。
令 toString 爲以 "toString" 作爲參數調用 O 的 [[Get]] 內部方法的結果.
如果 IsCallable(toString) 是 false，拋出一個 TypeError 異常。
返回以 O 作爲 this 值，無參數調用 toString 的 [[Call]] 內部方法的結果。

注：這個函數給所有 Object 對象提供一個通用的 toLocaleString 接口，即使並不是所有的都使用它。目前，Array、Number、Date 都提供了它們自身的語言環境敏感的 toLocaleString 方法。

注：這個函數的第一個參數可能會在此標準的未來版本中使用到；因此建議實現不要用這個位置參數來做其他事情。

Object.prototype.valueOf ( )

English

當調用 valueOf 方法，採用如下步驟：

令 O 爲以 this 作爲參數調用 ToObject 的結果。
如果 O 是以一個宿主對象 (15.2.2.1) 爲參數調用 Object 構造器的結果，則
1. 返回 O 或返回先前傳遞給構造器的原宿主對象。返回的具體結果是由實現定義的。
返回 O。

Object.prototype.hasOwnProperty (V)

English

當以參數 V 調用 hasOwnProperty 方法，採用如下步驟：

令 P 爲 ToString(V)。
令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 desc 爲以 P 爲參數調用 O 的 [[GetOwnProperty]] 內部方法的結果。
如果 desc 是 undefined，返回 false。
返回 true。

注：不像 [[HasProperty]](8.12.6)，這個方法不考慮原形鏈中的對象。

注： 第1步 和 第2步 選擇這樣的順序是爲了確保，即使 this 值是 undefined 或 null，本規範之前版本中任何會在 第1步 拋出的異常，都會繼續在本規範中拋出。

Object.prototype.isPrototypeOf (V)

English

當以參數 V 調用 isPrototypeOf 方法，採用如下步驟：

如果 V 不是個對象，返回 false。
令 O 爲以 this 作爲參數調用 ToObject 的結果。
重複
1. 令 V 爲 V 的 [[Prototype]] 內部屬性的值。
2. 如果 V 是 null，返回 false
3. 如果 O 和 V 指向同一個對象，返回 true。

注： 第1步 和 第2步 選擇這樣的順序是爲了，當 V 不是對象並且 this 值是 undefined 或 null 時能夠保持本規範之前版本指定的行爲。

Object.prototype.propertyIsEnumerable (V)

English

當以參數 V 調用 propertyIsEnumerable 方法，採用如下步驟：

令 P 爲 ToString(V)。
令 O 爲以 this 作爲參數調用 ToObject 的結果。
令 desc 爲以 P 作爲參數調用 O 的 [[GetOwnProperty]] 內部方法的結果。
如果 desc 是 undefined，返回 false。
返回 desc.[[Enumerable]] 的值。

注：這個方法不考慮原型鏈中的對象。

Object 的實例的屬性

English

Object 的實例除了擁從 Object 的 prototype 對象繼承來的屬性之外不包含特殊的屬性。

Function 對象

English

test262

作爲函數調用 Function 構造器

English

當將 Function 作爲函數來調用，而不是作爲構造器，它會創建並初始化一個新函數對象。所以函數調用 Function(…) 與用相同參數的 new Function(…) 表達式創建的對象相同。

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

English

當以 p1、p2、…、pn 和 body 作爲參數調用 Function 函數（這裏的 n 可以是 0，也就是說沒有“p”參數，這時還可以不提供 body），採用如下步驟：

創建並返回一個新函數對象，它彷彿是用相同參數給標準內置構造器 Function (15.3.2.1). 用一個 new 表達式創建的。

Function 構造器

English

當 Function 作爲 new 表達式的一部分被調用時，它是一個構造器：它初始化新創建的對象。

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

English

最後一個參數指定爲函數的 body（可執行代碼）；之前的任何參數都指定爲形式參數。

當以 p1、p2、…、pn 和 body 作爲參數調用 Function 構造器（這裏的 n 可以是 0，也就是說沒有“p”參數，這時還可以不提供 body），採用如下步驟：

令 argCount 爲傳給這個函數調用的參數總數。
令 P 爲空字符串。
如果 argCount = 0，令 body 爲空字符串。
否則如果 argCount = 1，令 body 爲那個參數。
否則，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 個參數。
令 body 爲 ToString( body )。
如果 P 不可解析爲一個 FormalParameterList，則拋出一個 SyntaxError 異常。
如果 body 不可解析爲 FunctionBody，則拋出一個 SyntaxError 異常。
如果 body 是嚴格模式代碼 ( 見 10.1.1)，則令 strict 爲 true，否則令 strict 爲 false。
如果 strict 是 true，適用 13.1 指定拋出的任何異常。
返回一個新創建的函數對象，它是依照 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 構造器的屬性

English

Function 構造器自身是個函數對象，它的 [[Class]] 是 "Function"。Function 構造器的 [[Prototype]] 內部屬性值是標準內置 Function 的 prototype 對象 (15.3.4)。

Function 構造器的 [[Extensible]] 內部屬性值是 true.

Function 構造器有如下屬性 :

Function.prototype

English

Function.prototype 的初始值是標準內置 Function 的 prototype 對象 (15.3.4)。

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

Function.length

English

這是個值爲 1 的數據屬性。此屬性擁有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Function 的 prototype 對象的屬性

English

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

English

Function.prototype.constructor 的初始值是內置 Function 構造器。

Function.prototype.toString ( )

English

此函數的返回值的表示是依賴於實現的。這個表示包含 FunctionDeclaration 的語法。特別注意，怎樣在這個字符串表示中使用和放置空白、行終止符、分號，是依賴於實現的。

這個 toString 不是通用的；如果它的 this 值不是一個函數對象，它會拋出一個 TypeError 異常。因此，它不能當做方法來轉移到其他類型的對象中。

Function.prototype.apply (thisArg, argArray)

English

當以 thisArg 和 argArray 爲參數在一個 func 對象上調用 apply 方法，採用如下步驟：

如果 IsCallable( func ) 是 false，則拋出一個 TypeError 異常。
如果 argArray 是 null 或 undefined，則
1. 返回提供 thisArg 作爲 this 值並以空參數列表調用 func 的 [[Call]] 內部方法的結果。
如果 Type( argArray ) 不是 Object，則拋出一個 TypeError 異常。
令 len 爲以 "length" 作爲參數調用 argArray 的 [[Get]] 內部方法的結果。
令 n 爲 ToUint32( len )。
令 argList 爲一個空列表。
令 index 爲 0。
只要 index < n 就重複
1. 令 indexName 爲 ToString( index )。
2. 令 nextArg 爲以 indexName 作爲參數調用 argArray 的 [[Get]] 內部方法的結果。
3. 將 nextArg 作爲最後一個元素插入到 argList 裏。
4. 設定 index 爲 index + 1。
提供 thisArg 作爲 this 值並以 argList 作爲參數列表，調用 func 的 [[Call]] 內部方法，返回結果。

apply 方法的 length 屬性是 2。

注：在外面傳入的 thisArg 值會修改併成爲 this 值。thisArg 是 undefined 或 null 時它會被替換成全局對象，所有其他值會被應用 ToObject 並將結果作爲 this 值，這是第三版引入的更改。

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

English

當以 thisArg 和可選的 arg1、arg2 等等作爲參數在一個 func 對象上調用 call 方法，採用如下步驟：

如果 IsCallable(func) 是 false，則拋出一個 TypeError 異常。
令 argList 爲一個空列表。
如果調用這個方法的參數多餘一個，則從 arg1 開始以從左到右的順序將每個參數插入爲 argList 的最後一個元素。
提供 thisArg 作爲 this 值並以 argList 作爲參數列表，調用 func 的 [[Call]] 內部方法，返回結果。

call 方法的 length 屬性是 1。

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

English

bind 方法需要一個或更多參數，thisArg 和（可選的）arg1、arg2，等，執行如下步驟返回一個新函數對象：

令 Target 爲 this 值 .
如果 IsCallable( Target ) 是 false，拋出一個 TypeError 異常 .
令 A 爲一個（可能爲空的）新內部列表，它包含按順序的 thisArg 後面的所有參數（arg1、arg2，等）。
令 F 爲一個新原生 ECMAScript 對象。
依照 8.12 指定，設定 F 的除了 [[Get]] 之外的所有內部方法。
依照 15.3.5.4 指定，設定 F 的 [[Get]] 內部屬性。
設定 F 的 [[TargetFunction]] 內部屬性爲 Target。
設定 F 的 [[BoundThis]] 內部屬性爲 thisArg 的值。
設定 F 的 [[BoundArgs]] 內部屬性爲 A。
設定 F 的 [[Class]] 內部屬性爲 "Function"。
設定 F 的 [[Prototype]] 內部屬性爲 15.3.3.1 指定的標準內置 Function 的 prototype 對象。
依照 15.3.4.5.1 描述，設定 F 的 [[Call]] 內置屬性。
依照 15.3.4.5.2 描述，設定 F 的 [[Construct]] 內置屬性。
依照 15.3.4.5.3 描述，設定 F 的 [[HasInstance]] 內置屬性。
如果 Target 的 [[Class]] 內部屬性是 "Function"，則
1. 令 L 爲 Target 的 length 屬性減 A 的長度。
2. 設定 F 的 length 自身屬性爲 0 和 L 中更大的值。
否則設定 F 的 length 自身屬性爲 0.
設定 F 的 length 自身屬性的特性爲 15.3.5.1 指定的值。
設定 F 的 [[Extensible]] 內部屬性爲 true。
令 thrower 爲 [[ThrowTypeError]] 函數對象 (13.2.3)。
以 "caller", 屬性描述符 {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, 和 false 作爲參數調用 F 的 [[DefineOwnProperty]] 內部方法。
以 "arguments", 屬性描述符 {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, 和 false 作爲參數調用 F 的 [[DefineOwnProperty]] 內部方法。
返回 F.

bind 方法的 length 屬性是 1。

注：Function.prototype.bind 創建的函數對象不包含 prototype 屬性或 [[Code]]、[[FormalParameters]]、[[Scope]] 內部屬性。

[[Call]]

English

當調用一個用 bind 函數創建的函數對象 F 的 [[Call]] 內部方法，傳入一個 this 值和一個參數列表 ExtraArgs，採用如下步驟：

令 boundArgs 爲 F 的 [[BoundArgs]] 內部屬性值。
令 boundThis 爲 F 的 [[BoundThis]] 內部屬性值。
令 target 爲 F 的 [[TargetFunction]] 內部屬性值。
令 args 爲一個新列表，它包含與列表 boundArgs 相同順序相同值，後面跟着與 ExtraArgs 是相同順序相同值。
提供 boundThis 作爲 this 值，提供 args 爲參數調用 target 的 [[Call]] 內部方法，返回結果。

[[Construct]]

English

當調用一個用 bind 函數創建的函數對象 F 的 [[Construct]] 內部方法，傳入一個參數列表 ExtraArgs，採用如下步驟：

令 target 爲 F 的 [[TargetFunction]] 內部屬性值。
如果 target 不包含 [[Construct]] 內部方法，拋出一個 TypeError 異常。
令 boundArgs 爲 F 的 [[BoundArgs]] 內部屬性值。
令 args 爲一個新列表，它包含與列表 boundArgs 相同順序相同值，後面跟着與 ExtraArgs 是相同順序相同值。
提供 args 爲參數調用 target 的 [[Construct]] 內部方法，返回結果。

[[HasInstance]] (V)

English

當調用一個用 bind 函數創建的函數對象 F 的 [[HasInstance]] 內部方法，並以 V 作爲參數，採用如下步驟：

令 target 爲 F 的 [[TargetFunction]] 內部屬性值。
如果 target 不包含 [[HasInstance]] 內部方法，拋出一個 TypeError 異常。
提供 V 爲參數調用 target 的 [[HasInstance]] 內部方法，返回結果。

Function 的實例的屬性

English

除了必要的內部屬性之外，每個函數實例還有一個 [[Class]] 內部屬性並且在大多數情況下使用不同版本的 [[Call]] 內部屬性。函數實例根據怎樣創建的（見 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

English

length 屬性值是個整數，它指出函數預期的“一般的”參數個數。然而，語言允許用其他數量的參數來調用函數。當以與函數的 length 屬性指定的數量不同的參數個數調用函數時，它的行爲依賴於函數自身。這個屬性擁有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

prototype

English

prototype 屬性的值用於初始化一個新創建對象的的 [[Prototype]] 內部屬性，爲了這個新創建對象要先將函數對象作爲構造器調用。這個屬性擁有特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }。

注：用 Function.prototype.bind 創建的函數對象沒有 prototype 屬性。

[[HasInstance]] (V)

English

設 F 是個函數對象。當以 V 作爲參數調用 F 的 [[HasInstance]] 內部方法，採用如下步驟：

如果 V 不是個對象，返回 false。
令 O 爲用屬性名 "prototype" 調用 F 的 [[Get]] 內部方法的結果。
如果 Type(O) 不是 Object，拋出一個 TypeError 異常。
重複
1. 令 V 爲 V 的 [[Prototype]] 內部屬性值。
2. 如果 V 是 null，返回 false。
3. 如果 O 和 V 指向相同對象，返回 true。

注：用 Function.prototype.bind 創建的函數對象擁有的不同的 [[HasInstance]] 實現，在 15.3.4.5.3 中定義。

[[Get]] (P)

English

函數對象與其他原生 EMACScript 對象 (8.12.3) 用不同的 [[Get]] 內部方法。

設 F 是一個函數對象，當以屬性名 P 調用 F 的 [[Get]] 內部方法，採用如下步驟：

令 v 爲傳入 P 作爲屬性名參數調用 F 的默認 [[Get]] 內部方法 (8.12.3) 的結果。
如果 P 是 "caller" 並且 v 是個嚴格模式函數對象，拋出一個 TypeError 異常。
返回 v。

注：用 Function.prototype.bind 創建的函數對象使用默認的 [[Get]] 內部方法。

Array 對象

English

test262

數組對象會給予一些特定種類的屬性名特殊待遇。對一個屬性名 P（字符串形式），當且僅當 ToString(ToUint32(P)) 等於 P 並且 ToUint32(P) 不等於 2³² - 1 時，它是個數組索引。一個屬性名是數組索引的屬性還叫做元素。所有數組對象都有一個 length 屬性，其值始終是一個小於 2³² 的非負整數。length 屬性值在數值上比任何名爲數組索引的屬性名稱還要大；每當創建或更改一個數組對象的屬性，都要調整其他屬性以保持上面那個條件不變。具體來說，每當添加一個名爲數組索引的屬性時，如果需要就更改 length 屬性爲在數值上比這個數組索引大 1 的值；每當更改 length 屬性，所有屬性名是數組索引並且其值不小於新 length 的屬性會被自動刪除。這個限制只應用於數組對象的自身屬性，並且從原型中繼承的 length 或數組索引不影響這個限制。

對一個對象 O，如果以下算法返回 true，那麼就叫這個對象爲稀疏的：

令 len 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
對每個範圍在 0 ≤ i < ToUint32(len) 的整數 i
1. 令 elem 爲以 ToString(i) 作爲參數調用 O 的 [[GetOwnProperty]] 內部方法的結果。
2. 如果 elem 是 undefined，返回 true。
返回 false。

作爲函數調用 Array 構造器

English

當將 Array 作爲函數來調用，而不是作爲構造器，它會創建並初始化一個新數組對象。所以函數調用 Array(…) 與用相同參數的 new Array(…) 表達式創建的對象相同。

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

English

當調用 Array 函數，採用如下步驟：

創建並返回一個新函數對象，它彷彿是用相同參數給標準內置構造器 Array 用一個 new 表達式創建的 (15.4.2)。

Array 構造器

English

當 Array 作爲 new 表達式的一部分被調用時，它是一個構造器：它初始化新創建的對象。

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

English

當且僅當以無參數或至少兩個參數調用 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)

English

新構造對象的 [[Prototype]] 內部屬性要設定爲原始的數組原型對象，他是 Array.prototype(15.4.3.1) 的初始值。新構造對象的 [[Class]] 內部屬性要設定爲 "Array"。新構造對象的 [[Extensible]] 內部屬性要設定爲 true。

如果參數 len 是個Number值並且 ToUint32(len) 等於 len，則新構造對象的 length 屬性要設定爲 ToUint32(len)。如果參數 len 是個數字值並且 ToUint32(len) 不等於 len，則拋出一個 RangeError 異常。

如果參數 len 不是Number值，則新構造對象的 length 屬性要設定爲 0，並且新構造對象的 0 屬性要設定爲 len，設定它的特性爲 { [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true }。

Array 構造器的屬性

English

Array 構造器的 [[Prototype]] 內部屬性值是函數原型對象 (15.3.4)。

Array 構造器除了有一些內部屬性和 length 屬性（其值是 1）之外，還有如下屬性：

Array.prototype

English

Array.prototype 的初始值是數組原型對象 (15.4.4)。

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

Array.isArray ( arg )

English

isArray 函數需要一個參數 arg，如果參數是個對象並且 [[Class]] 內部屬性是 "Array"，返回布爾值 true；否則它返回 false。採用如下步驟：

如果 Type(arg) 不是 Object，返回 false。
如果 arg 的 [[Class]] 內部屬性值是 "Array"，則返回 true。
返回 false。

數組原型對象的屬性

English

數組原型對象的 [[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

English

Array.prototype.constructor 的初始值是標準內置 Array 構造器。

Array.prototype.toString ( )

English

當調用 toString 方法，採用如下步驟：

令 array 爲用 this 值調用 ToObject 的結果。
令 func 爲以 "join" 作爲參數調用 array 的 [[Get]] 內部方法的結果。
如果 IsCallable(func) 是 false，則令 func 爲標準內置方法 Object.prototype.toString (15.2.4.2)。
提供 array 作爲 this 值並以空參數列表調用 func 的 [[Call]] 內部方法，返回結果。

注： toString 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 toString 函數是依賴於實現的。

Array.prototype.toLocaleString ( )

English

先用數組元素的 toLocaleString 方法，將他們轉換成字符串。然後將這些字符串串聯，用一個分隔符分割，這裏的分隔符字符串是與特定語言環境相關，由實現定義的方式得到的。調用這個函數的結果除了與特定語言環境關聯之外，與 toString 的結果類似。

結果是按照一下方式計算的：

令 array 爲以 this 值作爲參數調用 ToObject 的結果。
令 arrayLen 爲以 "length" 作爲參數調用 array 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(arrayLen)。
令 separator 爲宿主環境的當前語言環境對應的列表分隔符字符串（這是實現定義的方式得到的）。
如果 len 是零，返回空字符串。
令 firstElement 爲以 "0" 作爲參數調用 array 的 [[Get]] 內部方法的結果。
如果 firstElement 是 undefined 或 null，則
1. 令 R 爲空字符串。
否則
1. 令 elementObj 爲 ToObject(firstElement).
2. 令 func 爲以 "toLocaleString" 作爲參數調用 elementObj 的 [[Get]] 內部方法的結果。
3. 如果 IsCallable(func) 是 false，拋出一個 TypeError 異常。
4. 令 R 爲提供 elementObj 作爲 this 值並以空參數列表調用 func 的 [[Call]] 內部方法的結果。
令 k 爲 1。
只要 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。
返回 R

注：此函數的第一個參數可能會在本標準的未來版本中用到；建議實現不要以任何其他用途使用這個參數位置。

注：toLocaleString 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 toLocaleString 函數是依賴於實現的。

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

English

當以零個或更多個參數 item1、item2，等，調用 concat 方法時，會返回一個數組。返回的數組包含調用對象的數組元素和隨後順序每個參數的數組元素。

採用如下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 A 爲彷彿是用表達式 new Array() 創建的新數組，這裏的 Array 是標準內置構造器名。
令 n 爲 0。
令 items 爲一個內部列表，他的第一個元素是 O，之後的元素是調用時傳給這個函數的各參數（以從左到右的順序）。
只要 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)、屬性描述符 { [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true } 和 false 作爲參數調用 A 的 [[DefineOwnProperty]] 內部方法。
    4. n 遞增 1。
    5. k 遞增 1。
3. 否則，E 不是數組
  1. 以 ToString(n)、屬性描述符 { [[Value]]: E, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: false } 和 false 作爲參數調用 A 的 [[DefineOwnProperty]] 內部方法。
  2. n 遞增 1。
返回 A。

concat 方法的 length 屬性是 1。

注：concat 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 concat 函數是依賴於實現的。

Array.prototype.join (separator)

English

數組元素先被轉換爲字符串，再將這些字符串用 separator 分割連接在一起。如果沒提供分隔符，將一個逗號用作分隔符。

join 方法需要一個參數 separator，執行以下步驟 :

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenVal 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenVal)。
如果 separator 是 undefined，令 separator 爲單字符字符串 ","。
令 sep 爲 ToString(separator)。
如果 len 是零，返回空字符串。
令 element0 爲以 "0" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
如果 element0 是 undefined 或 null, 令 R 爲空字符串；否則，令 R 爲 ToString(element0)。
令 k 爲 1.
只要 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。
返回 R。

join 方法的 length 屬性是 1。

注： join 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 join 函數是依賴於實現的。

Array.prototype.pop ( )

English

test262

刪除並返回數組的最後一個元素。

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenVal 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenVal)。
如果 len 是零
1. 以 "length"、0 和 true 作爲參數調用 O 的 [[Put]] 內部方法。
2. 返回 undefined。
否則，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 [ , … ] ] ] )

English

將參數以他們出現的順序追加到數組末尾。數組的新 length 屬性值會作爲調用的結果返回。

當以零或更多個參數 item1、item2，等，調用 push 方法，採用以下步驟：

令 O 爲以 this 值作爲參數調用 ToString 的結果。
令 lenVal 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 n 爲 ToUint32(lenVal)。
令 items 爲一個內部列表，它的元素是調用這個函數時傳入的參數（從左到右的順序）。
只要 items 不是空就重複
1. 刪除 items 的第一個元素，並令 E 爲這個元素的值。
2. 以 ToString(n)、E 和 true 作爲參數調用 O 的 [[Put]] 內部方法。
3. n 遞增 1。
以 "length"、n 和 true 作爲參數調用 O 的 [[Put]] 內部方法。
返回 n。

push 方法的 length 屬性是 1。

注： push 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 push 函數是依賴於實現的。

Array.prototype.reverse ( )

English

重新排列數組元素，以翻轉它們的順序。對象會被當做調用的結果返回。

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenVal 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenVal)。
令 middle 爲 floor(len / 2)。
令 lower 爲 0。
只要 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。
返回 O。

注： reverse 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 reverse 函數是依賴於實現的。

Array.prototype.shift ( )

English

刪除並返回數組的第一個元素。

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenVal 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenVal)。
如果 len 是零 , 則
1. 以 "length"、0 和 true 作爲參數調用 O 的 [[Put]] 內部方法。
2. 返回 undefined。
令 first 爲以 "0" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 k 爲 1。
只要 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。
以 ToString(len - 1) 和 true 作爲參數調用 O 的 [[Delete]] 內部方法。
以 "length"、(len - 1) 和 true 作爲參數調用 O 的 [[Put]] 內部方法。
返回 first。

注： shift 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 shift 函數是依賴於實現的。

Array.prototype.slice (start, end)

English

slice 方法需要 start 和 end 兩個參數，返回一個數組，這個數組包含從下標爲 start 的元素到下標爲 end（不含 end）的元素（或如果 end 是 undefined 就到數組末尾）。如果 start 爲負，它會被當做是 length + start，這裏的 length 是數組長度。如果 end 爲負，它會被當做是 length + end，這裏的 length 是數組長度。採用如下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 A 爲彷彿用表達式 new Array() 創建的新數組，這裏的 Array 是標準內置構造器名。
令 lenVal 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenVal)。
令 relativeStart 爲 ToInteger(start)。
如果 relativeStart 爲負，令 k 爲 max((len + relativeStart), 0)；否則令 k 爲 min(relativeStart, len)。
如果 end 是 undefined，令 relativeEnd 爲 len；否則令 relativeEnd 爲 ToInteger(end)。
如果 relativeEnd 爲負，令 final 爲 max((len + relativeEnd), 0)；否則令 final 爲 min(relativeEnd, len)。
令 n 爲 0。
只要 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。
返回 A。

slice 方法的 length 屬性是 2。

注： slice 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 slice 函數是依賴於實現的。

Array.prototype.sort (comparefn)

English

給 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 的行爲也是實現定義的。

否則，採用如下步驟。

根據實現定義的排序算法，通過調用若干次 obj 的 [[Get]]、[[Put]]、[[Delete]] 內部方法和 SortCompare 的有機組合來完成排序。這裏對每個 [[Get]]、[[Put]] 或 [[Delete]] 調用的第一個參數是小於 len 的非負整數，SortCompare 調用的參數是前面調用 [[Get]] 內部方法的結果。調用 [[Put]] 和 [[Delete]] 內部方法時，throw 參數是 true。如果 obj 不是稀疏的，則必須不調用 [[Delete]]。
返回 obj。

返回的對象必須擁有下面兩個性質。

必須有這樣的數學排列 π，它是由比 len 小的非負整數組成，對於每個比 len 小的非負整數 j，如果屬性 old[j] 存在 , 則 new[π(j)] 有與 old[j] 相同的值，如果屬性 old[j] 不存在，則 new[π(j)] 也不存在。
對於都比 len 小的所有非負整數 j 和 k，如果 SortCompare(j, k) < 0, 則 π(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、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，採用如下步驟：

令 jString 爲 ToString(j)。
令 kString 爲 ToString(k)。
令 hasj 爲以 jString 作爲參數調用 obj 的 [[HasProperty]] 內部方法的結果。
令 hask 爲以 kString 作爲參數調用 obj 的 [[HasProperty]] 內部方法的結果。
如果 hasj 和 hask 都是 false，則返回 +0。
如果 hasj 是 false，則返回 1。
如果 hask 是 false，則返回 -1。
令 x 爲以 jString 作爲參數調用 obj 的 [[Get]] 內部方法的結果。
令 y 爲以 kString 作爲參數調用 obj 的 [[Get]] 內部方法的結果。
如果 x 和 y 都是 undefined，返回 +0。
如果 x 是 undefined，返回 1。
如果 y 是 undefined，返回 −1。
如果參數 comparefn 不是 undefined, 則
1. 如果 IsCallable(comparefn) 是 false，拋出一個 TypeError 異常。
2. 傳入 undefined 作爲 this 值，以 x 和 y 作爲參數調用 comparefn 的 [[Call]] 內部方法，返回結果。
令 xString 爲 ToString(x)。
令 yString 爲 ToString(y)。
如果 xString < yString，返回 −1。
如果 xString > yString，返回 1。
返回 +0。

注：因爲不存在的屬性值總是比 undefined 屬性值大，並且 undefined 屬性值總是比任何其他值大，所以 undefined 屬性值總是排在結果的末尾，後面跟着不存在的屬性值。

注： sort 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 sort 函數是依賴於實現的。

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

English

當以兩個或更多參數 start、deleteCount 和（可選的）item1、item2, 等，調用 splice 方法，從數組索引 start 開始的 deleteCount 個數組元素會被替換爲參數 item1、item2, 等。返回一個包含參數元素（如果有）的數組。採用以下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 A 爲彷彿用表達式 new Array() 創建的新數組，這裏的 Array 是標準內置構造器名。
令 lenVal 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenVal)。
令 relativeStart 爲 ToInteger(start)。
如果 relativeStart 爲負，令 actualStart 爲 max((len + relativeStart),0); 否則令 actualStart 爲 min(relativeStart, len)。
令 actualDeleteCount 爲 min(max(ToInteger(deleteCount),0),len - actualStart)。
令 k 爲 0。
只要 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.
令 items 爲一個內部列表，它的元素是實際參數列表中 item1 開始的參數（從左到右的順序）。如果沒傳入這些項目，則列表是空的。
令 itemCount 爲 items 的元素個數。
如果 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.
否則如果 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。
令 k 爲 actualStart。
只要 items 不是空就重複
1. 刪除 items 的第一個元素，並令 E 爲這個元素值。
2. 以 ToString(k)、E 和 true 作爲參數調用 O 的 [[Put]] 內部方法。
3. k 遞增 1。
以 "length"、(len - actualDeleteCount + itemCount) 和 true 作爲參數調用 O 的 [[Put]] 內部方法。
返回 A。

splice 方法的 length 屬性是 2。

注： splice 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 splice 函數是依賴於實現的。

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

English

將參數們插入到數組的開始位置，它們在數組中的順序與它們出現在參數列表中的順序相同。

當以零或更多個參數 item1、item2，等，調用 unshift 方法，採用如下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenVal 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenVal)。
令 argCount 爲實際參數的個數。
令 k 爲 len。
只要 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。
令 j 爲 0。
令 items 爲一個內部列表，它的元素是調用這個函數時傳入的實際參數（從左到右的順序）。
只要 items 不是空，就重複
1. 刪除 items 的第一個元素，並令 E 爲這個元素值 .
2. 以 ToString(j)、E 和 true 作爲參數調用 O 的 [[Put]] 內部方法。
3. j 遞增 1。
以 "length"、len + argCount 和 true 作爲參數調用 O 的 [[Put]] 內部方法。
返回 len + argCount。

unshift 方法的 length 屬性是 1。

注： unshift 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 unshift 函數是依賴於實現的。

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

English

indexOf 按照索引的升序比較 searchElement 和數組裏的元素們，它使用內部的嚴格相等比較算法（11.9.6），如果找到一個或更多這樣的位置，返回這些位置中第一個索引；否則返回 -1。

可選的第二個參數 fromIndex 默認是 0（即搜索整個數組）。如果它大於或等於數組長度，返回 -1，即不會搜索數組。如果它是負的，就把它當作從數組末尾到計算後的 fromIndex 的偏移量。如果計算後的索引小於 0，就搜索整個數組。

當用一個或兩個參數調用 indexOf 方法，採用以下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenValue 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenValue)。
如果 len 是 0，返回 -1。
如果傳入了參數 fromIndex，則令 n 爲 ToInteger(fromIndex)；否則令 n 爲 0。
如果 n ≥ len，返回 -1。
如果 n ≥ 0，則
1. 令 k 爲 n。
否則，n < 0
1. 令 k 爲 len - abs(n)。
2. 如果 k 小於 0，則令 k 爲 0。
只要 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。
返回 -1。

indexOf 方法的 length 屬性是 1。

注： indexOf 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 indexOf 函數是依賴於實現的。

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

English

lastIndexOf 按照索引的降序比較 searchElement 和數組裏的元素們，它使用內部的嚴格相等比較算法 (11.9.6)，如果找到一個或更多這樣的位置，返回這些位置中最後一個索引；否則返回 -1。

可選的第二個參數 fromIndex 默認是數組的長度減一（即搜索整個數組）。如果它大於或等於數組長度，將會搜索整個數組。如果它是負的，就把它當作從數組末尾到計算後的 fromIndex 的偏移量。如果計算後的索引小於 0，返回 -1。

當用一個或兩個參數調用 lastIndexOf 方法，採用如下步驟 :

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenValue 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenValue)。
如果 len 是 0，返回 -1。
如果傳入了參數 fromIndex，則令 n 爲 ToInteger(fromIndex); 否則令 n 爲 len。
如果 n ≥ 0，則令 k 爲 min(n, len - 1)。
否則，n < 0
1. 令 k 爲 len - abs(n)。
只要 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。
返回 -1。

lastIndexOf 方法的 length 屬性是 1。

注： lastIndexOf 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 lastIndexOf 函數是依賴於實現的。

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

English

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 方法，採用以下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenValue 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenValue)。
如果 IsCallable(callbackfn) 是 false，拋出一個 TypeError 異常。
如果提供了 thisArg，令 T 爲 thisArg；否則令 T 爲 undefined。
令 k 爲 0。
只要 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。
返回 true。

every 方法的 length 屬性是 1。

注： every 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 every 函數是依賴於實現的。

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

English

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 方法，採用以下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenValue 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenValue)。
如果 IsCallable(callbackfn) 是 false, 拋出一個 TypeError 異常。
如果提供了 thisArg，令 T 爲 thisArg；否則令 T 爲 undefined。
令 k 爲 0。
只要 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。
返回 false。

some 方法的 length 屬性是 1。

注： some 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 some 函數是依賴於實現的。

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

English

callbackfn 應該是個函數，它接受三個參數。forEach 按照索引的升序，對數組裏存在的每個元素調用一次 callbackfn。callbackfn 只被實際存在的數組元素調用；它不會被缺少的數組元素調用。

如果提供了一個 thisArg 參數，它會被當作 this 值傳給每個 callbackfn 調用。如果沒提供它，用 undefined 替代。

調用 callbackfn 時將傳入三個參數：元素的值，元素的索引，和遍歷的對象。

對 forEach 的調用不直接更改對象，但是對 callbackfn 的調用可能更改對象。

forEach 處理的元素範圍是在首次調用 callbackfn 之前設定的。在 forEach 調用開始後追加到數組裏的元素們不會被 callbackfn 訪問。如果更改以存在數組元素，forEach 訪問這些元素時的值會傳給 callbackfn；在 forEach 調用開始後刪除的和之前被訪問過的元素們是不訪問的。

當以一個或兩個參數調用 forEach 方法，採用以下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenValue 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenValue)。
如果 IsCallable(callbackfn) 是 false，拋出一個 TypeError 異常。
如果提供了 thisArg，令 T 爲 thisArg；否則令 T 爲 undefined。
令 k 爲 0。
只要 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。
返回 undefined。

forEach 方法的 length 屬性是 1。

注：forEach 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 forEach 函數是依賴於實現的。

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

English

callbackfn 應該是個函數，它接受三個參數。map 按照索引的升序，對數組裏存在的每個元素調用一次 callbackfn，並用結果構造一個新數組。callbackfn 只被實際存在的數組元素調用；它不會被缺少的數組元素調用。

如果提供了一個 thisArg 參數，它會被當作 this 值傳給每個 callbackfn 調用。如果沒提供它，用 undefined 替代。

調用 callbackfn 時將傳入三個參數：元素的值，元素的索引，和遍歷的對象。

對 map 的調用不直接更改對象，但是對 callbackfn 的調用可能更改對象。

map 處理的元素範圍是在首次調用 callbackfn 之前設定的。在 map 調用開始後追加到數組裏的元素們不會被 callbackfn 訪問。如果更改以存在數組元素，map 訪問這些元素時的值會傳給 callbackfn；在 map 調用開始後刪除的和之前被訪問過的元素們是不訪問的。

當以一個或兩個參數調用 map 方法，採用以下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenValue 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenValue)。
如果 IsCallable(callbackfn) 是 false，拋出一個 TypeError 異常。
如果提供了 thisArg，令 T 爲 thisArg；否則令 T 爲 undefined。
令 A 爲彷彿用 new Array(len) 創建的新數組，這裏的 Array 是標準內置構造器名，len 是 len 的值。
令 k 爲 0。
只要 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。
返回 A。

map 方法的 length 屬性是 1。

注：map 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 map 函數是依賴於實現的。

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

English

callbackfn 應該是個函數，它接受三個參數並返回一個可轉換爲布爾值 true 和 false 的值。filter 按照索引的升序，對數組裏存在的每個元素調用一次 callbackfn，並用使 callbackfn 返回 true 的所有值構造一個新數組。callbackfn 只被實際存在的數組元素調用；它不會被缺少的數組元素調用。

如果提供了一個 thisArg 參數，它會被當作 this 值傳給每個 callbackfn 調用。如果沒提供它，用 undefined 替代。

調用 callbackfn 時將傳入三個參數：元素的值，元素的索引，和遍歷的對象。

對 filter 的調用不直接更改對象，但是對 callbackfn 的調用可能更改對象。

filter 處理的元素範圍是在首次調用 callbackfn 之前設定的。在 filter 調用開始後追加到數組裏的元素們不會被 callbackfn 訪問。如果更改以存在數組元素，filter 訪問這些元素時的值會傳給 callbackfn；在 filter 調用開始後刪除的和之前被訪問過的元素們是不訪問的。

當以一個或兩個參數調用 filter 方法，採用以下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenValue 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenValue)。
如果 IsCallable(callbackfn) 是 false, 拋出一個 TypeError 異常。
如果提供了 thisArg，令 T 爲 thisArg；否則令 T 爲 undefined。
令 A 爲彷彿用 new Array() 創建的新數組，這裏的 Array 是標準內置構造器名。
令 k 爲 0。
令 to 爲 0。
只要 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。
返回 A。

filter 方法的 length 屬性是 1。

注：filter 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 filter 函數是依賴於實現的。

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

English

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 方法，採用以下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenValue 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenValue)。
如果 IsCallable(callbackfn) 是 false，拋出一個 TypeError 異常。
如果 len 是 0 並且 initialValue 不是 present，拋出一個 TypeError 異常。
令 k 爲 0。
如果 initialValue 參數有傳入值，則
1. 設定 accumulator 爲 initialValue。
否則，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 異常。
只要 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。
返回 accumulator。

reduce 方法的 length 屬性是 1。

注：reduce 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 reduce 函數是依賴於實現的。

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

English

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 方法，採用以下步驟：

令 O 爲以 this 值作爲參數調用 ToObject 的結果。
令 lenValue 爲以 "length" 作爲參數調用 O 的 [[Get]] 內部方法的結果。
令 len 爲 ToUint32(lenValue)。
如果 IsCallable(callbackfn) 是 false，拋出一個 TypeError 異常。
如果 len 是 0 並且 initialValue 不是 present，拋出一個 TypeError 異常。
令 k 爲 0。
如果 initialValue 參數有傳入值，則
1. 設定 accumulator 爲 initialValue。
否則，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 異常。
只要 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.
返回 accumulator。

reduceRight 方法的 length 屬性是 1。

注：reduceRight 函數被有意設計成通用的；它的 this 值並非必須是數組對象。因此，它可以作爲方法轉移到其他類型的對象中。一個宿主對象是否可以正確應用這個 reduceRight 函數是依賴於實現的。

Array 實例的屬性

English

Array 實例從數組原型對象繼承屬性，Array 實例的 [[Class]] 內部屬性是 "Array"。Array 實例還有以下屬性。

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

English

數組對象使用一個，用在其他原生 ECMAscript 對象的 [[DefineOwnProperty]] 內部方法 (8.12.9) 的變化版。

設 A 爲一個數組對象，Desc 爲一個屬性描述符，Throw 爲一個布爾標示。

在以下算法中，術語“拒絕”指代“如果 Throw 是 true，則拋出 TypeError 異常，否則返回 false。

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

令 oldLenDesc 爲以 "length" 作爲參數調用 A 的 [[GetOwnProperty]] 內部方法的結果。結果絕不會是 undefined 或一個訪問器描述符，因爲在創建數組時的 length 是一個不可刪除或重新配置的數據屬性。
令 oldLen 爲 oldLenDesc.[[Value]]。
如果 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]] 內部方法。
    4. 拒絕。
13. 如果 newWritable 是 false，則
  1. 以 "length"，屬性描述符 {[[Writable]]: false} 和 false 作爲參數在 A 上調用 [[DefineOwnProperty]] 內部方法。這個調用始終返回 true。
14. 返回 true。
否則如果 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]] 內部方法。這個調用始終返回 true。
6. 返回 true。
以 P、Desc 和 Throw 作爲參數在在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9)，返回結果。

length

English

數組對象的 length 屬性是個數據屬性，其值總是在數值上大於任何屬性名是數組索引的可刪除屬性的屬性名。

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

注：試圖將數組的 length 屬性設置爲一個值時，如果這個值小於或等於數組中最大不可刪除的數字屬性，那麼 length 將會被設置爲比那個屬性大一的數字。見 15.4.5.1。

String 對象

English

test262

作爲函數調用 String 構造器

English

當將 String 作爲函數調用，而不是作爲構造器，它執行一個類型轉換。

String ( [ value ] )

English

返回一個由 ToString(value) 計算出的字符串值（不是 String 對象）。如果沒有提供 value，返回空字符串 ""。

String 構造器

English

當 String 作爲一個 new 表達式的一部分被調用，它是個構造器：它初始化新創建的對象。

new String ( [ value ] )

English

新構造對象的 [[Prototype]] 內部屬性設定爲標準內置的字符串原型對象，它是 String.prototype 的初始值 (15.5.3.1)。

新構造對象的 [[Class]] 內部屬性設定爲 "String"。

新構造對象的 [[Extensible]] 內部屬性設定爲 true。

新構造對象的 [[PrimitiveValue]] 內部屬性設定爲 ToString(value)，或如果沒提供 value 則設定爲空字符串。

String 構造器的屬性

English

String 構造器的 [[Prototype]] 內部屬性的值是標準的內置 Function 原型對象。

除了內部屬性和 length 屬性（值爲 1）之外，String 構造器還有以下屬性：

String.prototype

English

String.prototype 的初始值是標準的內置 String 原型對象。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

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

English

返回一個字符串值，包含的字符數與參數數目相同。每個參數指定返回字符串中的一個字符，也就是說第一個參數第一個字符，以此類推（從左到右）。一個參數轉換爲一個字符，通過先應用 ToUint16 操作，再將返回的16位整數看作字符的代碼單元值。如果沒提供參數，返回空字符串。

fromCharCode 函數的 length 屬性是 1。

字符串原型對象的屬性

English

字符串原型對象本身是一個值爲空字符串的 String 對象（它的 [[Class]] 是 "String"）。

字符串原型對象的 [[Prototype]] 內部屬性值是標準的內置 Object 原型對象。

String.prototype.constructor

English

String.prototype.constructor 的初始值是內置 String 構造器。

String.prototype.toString ( )

English

返回 this 字符串值。（注，對於一個 String 對象，toString 方法和 valueOf 方法返回相同值。）

toString 函數是非通用的；如果它的 this 值不是一個字符串或字符串對象，則拋出一個 TypeError 異常。因此它不能作爲方法轉移到其他類型對象上。

String.prototype.valueOf ( )

English

返回 this 字符串值。

valueOf 函數是非通用的；如果它的 this 值不是一個字符串或字符串對象，則拋出一個 TypeError 異常。因此它不能作爲方法轉移到其他類型對象上。

String.prototype.charAt (pos)

English

將 this 對象轉換爲一個字符串，返回包含了這個字符串 pos 位置的字符的字符串。如果那個位置沒有字符，返回空字符串。返回結果是個字符串值，不是字符串對象。

如果 pos 是一個數字類型的整數值，則 x.charAt(pos) 與 x.substring(pos, pos + 1) 的結果相等。

當用一個參數 pos 調用 charAt 方法，採用以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
令 position 爲 ToInteger(pos)。
令 size 爲 S 的字符數。
如果 position < 0 或 position ≥ size，返回空字符串。
返回一個長度爲 1 的字符串，它包含 S 中 position 位置的一個字符，在這裏 S 中的第一個（最左邊）字符被當作是在位置 0，下一個字符被當作是在位置 1，等等。

注： charAt 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.charCodeAt (pos)

English

將 this 對象轉換爲一個字符串，返回一個代表這個字符串 pos 位置字符的代碼單元值的數字（小於 2¹⁶ 的非負整數）。如果那個位置沒有字符，返回 NaN。

當用一個參數 pos 調用 charCodeAt 方法，採用以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
令 position 爲 ToInteger(pos)。
令 size 爲 S 的字符數。
如果 position < 0 或 position ≥ size，返回 NaN.
返回一個數字類型值，值是字符串 S 中 position 位置字符的代碼單元值。在這裏 S 中的第一個（最左邊）字符被當作是在位置 0，下一個字符被當作是在位置 1，等等。

注： charCodeAt 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

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

English

當用一個或更多參數 string1、string2，等，調用 concat 方法，它返回一個字符串，其中包含了轉換成字符串類型的 this 對象中的所有字符和後面跟着的每個參數（例如：string1、string2，等）轉換成字符串類型后里面的所有字符。返回結果是一個字符串值，不是一個字符串對象。採用以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
令 args 爲一個內部列表，它是傳給這個函數的參數列表的拷貝。
令 R 爲 S。
只要 args 不是空，就重複
1. 刪除 args 的第一個元素，並令 next 爲這個元素。
2. 令 R 爲一個包含了 R 中原有的所有字符跟上 ToString(next) 中的所有字符的字符串值。
返回 R。

concat 方法的 length 屬性是 1.

注： concat 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.indexOf (searchString, position)

English

將 this 對象轉換爲一個字符串，如果 searchString 在這個字符串裏大於或等於 position 的位置中的一個或多個位置使它呈現爲字符串的子串，那麼返回這些位置中最小的索引；否則返回 -1。如果 position 是 undefined，就認爲它是 0，以搜索整個字符串。

indexOf 需要兩個參數 searchString 和 position，執行以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
令 searchStr 爲 ToString(searchString)。
令 pos 爲 ToInteger(position)。（如果 position 是 undefined，此步驟產生 0）。
令 len 爲 S 的字符數。
令 start 爲 min(max(pos, 0), len)。
令 searchLen 爲 SearchStr 的字符數。
返回一個不小於 start 的可能的最小值整數 k，使得 k + searchLen 不大於 len，並且對所有小於 searchLen 的非負數整數 j、S 的 k + j 位置字符和 searchStr 的 j 位置字符相同；但如果沒有這樣的整數 k，則返回 -1。

indexOf 的 length 屬性是 1。

注： indexOf 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.lastIndexOf (searchString, position)

English

將 this 對象轉換爲一個字符串，如果 searchString 在這個字符串裏小於或等於 position 的位置中的一個或多個位置使它呈現爲字符串的子串，那麼返回這些位置中最大的索引；否則返回 -1。如果 position 是 undefined ，就認爲它是字符串值的長度，以搜索整個字符串。

lastIndexOf 需要兩個參數 searchString 和 position，執行以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
令 searchStr 爲 ToString(searchString)。
令 numPos 爲 ToNumber(position)。( 如果 position 是 undefined，此步驟產生 NaN)。
如果 numPos 是 NaN，令 pos 爲 +∞；否則，令 pos 爲 ToInteger(numPos)。
令 len 爲 S 的字符數。
令 start 爲 min(max(pos, 0), len)。
令 searchLen 爲 SearchStr 的字符數。
返回一個不大於 start 的可能的最大值整數 k，使得 k + searchLen 不大於 len，並且對所有小於 searchLen 的非負數整數 j，S 的 k + j 位置字符和 searchStr 的 j 位置字符相同；但如果沒有這樣的整數 k，則返回 -1。。

lastIndexOf 的 length 屬性是 1。

注： lastIndexOf 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.localeCompare (that)

English

當以一個參數 that 來調用 localeCompare 方法，它返回一個非 NaN 數字值，這個數字值反應了對 this 值（轉換爲字符串）和 that 值（轉換爲字符串）進行語言環境敏感的字符串比較的結果。兩個字符串 S 和 That 用實現定義的一種方式進行比較。比較結果是按照系統默認語言環境指定的順序來排列字符串。根據這三種情況：S 在 That 前面、兩字符串相同、S 在 That 後面，分別返回：負數、零、正數。

在執行比較之前執行以下步驟以預備好字符串：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
令 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)

English

當以 regexp 作爲參數調用 match 方法，採用以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
如果 Type(regexp) 是 Object 並且 regexp 的 [[Class]] 內部屬性的值是 "RegExp"，則令 rx 爲 regexp；
否則，令 rx 爲彷彿是用表達式 new RegExp(regexp) 創建的新正則對象，這裏的 RegExp 是標準內置構造器名。
令 global 爲以 "global" 爲參數調用 rx 的 [[Get]] 內部方法的結果。
令 exec 爲標準內置函數 RegExp.prototype.exec ( 見 15.10.6.2)
如果 global 不是 true，則
1. 以 rx 作爲 this 值，用包含 S 的參數列表調用 exec 的 [[Call]] 內部方法，返回結果。
否則，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)

English

首先根據以下步驟設定 string：

以 this 值作爲參數調用 CheckObjectCoercible。
令 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 裏的所有捕獲值。第 m + 2 個參數是發生的匹配在 string 裏的偏移量，第 m + 3 個參數是 string。結果是將輸入的原字符串裏的每個匹配子字符串替換爲相應函數調用的返回值（必要的情況下轉換爲字符串）得到的字符串。

否則，令 newstring 表示 replaceValue 轉換爲字符串的結果。結果是將輸入的原字符串裏的每個匹配子字符串替換爲 newstring 裏的字符根據表22指定的替代文本替換得到的字符串。替換這些 $ 是由左到右進行的，並且一旦執行了這樣的替換，新替換的文本不受進一步替換。例如，"$1,$2".replace(/(\$(\d))/g, "$$1-$1$2") 返回 "$1-$11,$1-$22"。newstring 裏的一個 $ ，如果不符合以下任何格式，就保持原狀。

**表22 替代文本符號替換**
字符	替代文本
$$	$
$&	匹配到的子字符串
$`	string 中匹配到的子字符串之前部分。
$'	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)

English

當用參數 regexp 調用 search 方法，採用以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 string 爲以 this 值作爲參數調用 ToString 的結果。
如果 Type(regexp) 是 Object 且 regexp 的 [[Class]] 內部屬性的值是 "RegExp", 則令 rx 爲 regexp；
否則，令 rx 爲彷彿是用表達式 new RegExp(regexp) 創建的新正則對象，這裏的 RegExp 是標準內置構造器名。
從 string 開始位置搜索正則表達式模式 rx 的匹配。如果找到匹配，令 result 爲匹配在 string 裏的偏移量；如果沒有找到匹配，令 result 爲 -1。執行搜索時 regexp 的 lastIndex 和 global 屬性是被忽略的。regexp 的 lastIndex 屬性保持不變。
返回 result。

注： search 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.slice (start, end)

English

slice 方法需要兩個參數 start 和 end，將 this 對象轉換爲一個字符串，返回這個字符串中從 start 位置的字符到（但不包含）end 位置的字符的一個子字符串（或如果 end 是 undefined，就直接到字符串尾部）。用 sourceLength 表示字符串長度，如果 start 是負數，就把它看做是 sourceLength + start；如果 end 是負數，就把它看做是 sourceLength + end。返回結果是一個字符串值，不是字符串對象。採用以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
令 len 爲 S 的字符數 .
令 intStart 爲 ToInteger(start)。
如果 end 是 undefined，令 intEnd 爲 len；否則令 intEnd 爲 ToInteger(end)。
如果 intStart 是 negative，令 from 爲 max(len + intStart , 0)；否則令 from 爲 min(intStart , len)。
如果 intEnd 是 negative，令 to 爲 max(len + intEnd, 0)；否則令 to 爲 min(intEnd，len)。
令 span 爲 max(to - from, 0 )。
返回一個包含 S 中 form 位置的字符開始的 span 個連續字符的字符串。

slice 方法的 length 屬性是 2。

注： slice 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.split (separator, limit)

English

將 this 字符串轉換爲一個字符串，返回一個數組對象，裏面存儲了這個字符串的子字符串。子字符串是從左到右搜索 separator 的匹配來確定的；這些匹配結果不成爲返回數組的任何子字符串元素，但被用來分割字符串。separator 的值可以是一個任意長度的字符串，也可以是一個正則對象（即，一個 [[Class]] 內部屬性爲 "RegExp" 的對象；見 15.10）。

separator 值可以是一個空字符串、一個空正則表達式或一個可匹配空字符串的正則表達式。這種情況下，separator 不匹配輸入字符串開頭和末尾的空的子串，也不匹配分隔符的之前匹配結果末尾的空字串。（例如，如果 separator 是空字符串，要將字符串分割爲單個字符們；結果數組的長度等於字符串長度，且每個字串都包含一個字符。）如果 separator 是正則表達式，在 this 字符串的給定位置中只考慮首次匹配結果，即使如果在這個位置上回溯可產生一個非空的子串。（例如，"ab".split(/a*?/) 的執行結果是數組 ["a","b"]，而 "ab".split(/a*/) 的執行結果是數組 ["","b"] 。）

如果 this 對象是（或轉換成）空字符串，返回的結果取決於 separator 是否可匹配空字符串。如果可以，結果是不包含任何元素的數組。否則，結果是包含一個空字符串元素的數組。

如果 separator 是包含捕獲括號的正則表達式，則對 separator 的每次匹配，捕獲括號的結果 ( 包括 undefined ) 都拼接爲輸出數組。

例如，

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

執行結果是數組：

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

如果 separator 是 undefined，則返回結果是隻包含 this 值（轉換爲字符串）一個字符串元素的數組。如果 limit 不是 undefined，則輸出數組被切斷爲包含不大於 limit 個元素。

當調用 split 方法，採用以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
令 A 爲彷彿使用表達式 new Array() 創建的新對象，這裏的 Array 是標準內置構造器名。
令 lengthA 爲 0。
如果 limit 是 undefined，令 lim = 2³² - 1; 否則令 lim = ToUint32(limit)。
令 s 爲 S 的字符數。
令 p = 0。
如果 separator 是正則對象（它的 [[Class]] 是 "RegExp"），令 R = separator；否則，令 R = ToString(separator)。
如果 lim = 0，返回 A。
如果 separator 是 undefined, 則
1. 以 "0"、屬性描述符 {[[Value]]: S, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 作爲參數調用 A 的 [[DefineOwnProperty]] 內部方法。
2. 返回 A。
如果 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。
令 q = p。
只要 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。
令 T 爲爲一個字符串，它的值等於包含在 S 中 p（包括它）位置到 q（不包括）位置的字符的子字符串的值。
以 ToString(lengthA)、屬性描述符 {[[Value]]: T, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true} 和 false 作爲參數調用 A 的 [[DefineOwnProperty]] 內部方法。
返回 A。

SplitMatch 抽象操作需要三個參數，字符串 S、整數 q、字符串或正則對象 R，按照以下順序執行並返回一個 MatchResult：

如果 R 是個正則對象 ( 它的 [[Class]] 是 "RegExp")，則
1. 以 S 和 q 作爲參數調用 R 的 [[Match]] 內部方法，並返回 MatchResult 的結果。
否則，Type(R) 必定是 String。令 r 爲 R 的字符數。
令 s 爲 S 的字符數 .
如果 q + r > s 則返回 MatchResult failure。
如果存在一個在 0（包括）到 r（不包括）之間的整數 i，使得 S 的 q + i 位置上的字符和 R 的 i 位置上的字符不同，則返回 failure。
令 cap 爲 captures 的空數組 ( 見 15.10.2.1)。
返回 State 數據結構 (q + r, cap). ( 見 15.10.2.1)

split 方法的 length 屬性是 2.

注：分隔符是正則對象時，split 方法忽略 separator.global 的值。

注： split 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.substring (start, end)

English

substring 方法需要兩個參數 start 和 end，將 this 對象轉換爲一個字符串，返回一個子串，這個子串包含了在轉換結果字符串中從 start 位置字符一直到（但不包括）end 位置的字符（或如果 end 是 undefined，就到字符串末尾）。返回結果是字符串值，不是字符串對象。

如果任一參數是 NaN 或負數，它被零取代；如果任一參數大於字符串長度，它被字符串長度取代。

如果 start 大於 end，交換它們的值。

採用以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
令 len 爲 S 的字符數。
令 intStart 爲 ToInteger(start)。
如果 end 是 undefined，令 intEnd 爲 len；否則令 intEnd 爲 ToInteger(end)。
令 finalStart 爲 min(max(intStart, 0 ), len)。
令 finalEnd 爲 min(max(intEnd, 0 ), len)。
令 from 爲 min(finalStart, finalEnd)。
令 to 爲 max(finalStart, finalEnd)。
返回一個長度是 to - from 的字符串，它包含 S 中從索引值 form 到 to - 1（按照索引升序）的所有字符。

substring 方法的 length 屬性是 2。

注： substring 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.toLowerCase ( )

English

採用以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
令 L 爲一個字符串，L 的每個字符是 S 中相應字符的 Unicode 小寫等量，或者（如果沒有 Unicode 小寫等量存在）是實際的 S 中相應字符值。
返回 L。

爲了此操作，字符串的16位代碼單元被看作是 Unicode 基本多文種平面中的代碼點。代理代碼點直接從 S 轉移到 L，不做任何映射。

返回結果必須是根據 Unicode 字符數據庫裏的大小寫映射得到的（對此數據庫明確規定，不僅包括 UnicodeData.txt 文件，而且還包括 Unicode 2.1.8 和更高版本里附帶的 SpecialCasings.txt 文件）。

注：某些字符的大小寫映射可產生多個字符。這種情況下結果字符串與原字符串的長度未必相等。因爲 toUpperCase 和 toLowerCase 都有上下文敏感的行爲，所以這倆函數不是對稱的。也就是說，s.toUpperCase().toLowerCase() 不一定等於 s.toLowerCase()。

注： toLowerCase 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.toLocaleLowerCase ( )

English

此函數產生依照宿主環境的當前語言設置更正的結果，而不是獨立於語言環境的結果，除此之外它的運作方式與 toLowerCase 完全一樣。只有在少數情況下有一個區別（如，土耳其語），就是那個語言和正規 Unicode 大小寫映射有衝突時的規則。

注：此函數的第一個參數可能會用於本標準的未來版本；建議實現不以任何用途使用這個參數位置。

注： toLocaleLowerCase 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.toUpperCase ( )

English

此函數的將字符映射到在 Unicode 字符數據庫中與其等值的大寫字符，除此之外此函數的行爲採用與 String.prototype.toLowerCase 完全相同的方式。

注： toUpperCase 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.toLocaleUpperCase ( )

English

此函數產生依照宿主環境的當前語言設置更正的結果，而不是獨立於語言環境的結果，除此之外它的運作方式與 toUpperCase 完全一樣。只有在少數情況下有一個區別（如，土耳其語），就是那個語言和正規 Unicode 大小寫映射有衝突時的規則。

注：此函數的第一個參數可能會用於本標準的未來版本；建議實現不以任何用途使用這個參數位置。

注： toLocaleUpperCase 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String.prototype.trim ( )

English

採用以下步驟：

以 this 值作爲參數調用 CheckObjectCoercible。
令 S 爲以 this 值作爲參數調用 ToString 的結果。
令 T 爲一個字符串值，它是 S 的一個拷貝，並刪除了開頭和結尾中空白的。空白的定義是空白字符和行終止符的並集。
返回 T。

注： trim 函數被有意設計成通用的；它不要求它的 this 值是字符串對象。因此，他可以當做方法轉移到其他類型對象。

String 實例的屬性

English

字符串實例從字符串原型對象繼承屬性，字符串實例的 [[Class]] 內部屬性值是 "String"。字符串實例還有 [[PrimitiveValue]] 內部屬性，length 屬性，和一組屬性名是數組索引的可遍歷屬性。

[[PrimitiveValue]] 內部屬性是代表這個字符串對象的字符串值。以數組索引命名的屬性對應字符串值裏的單字符。一個特殊的 [[GetOwnProperty]] 內部方法用來爲數組索引命名的屬性指定數字，值，和特性。

length

English

在代表這個字符串對象的字符串值裏的字符數。

一旦創建了一個字符串對象，這個屬性是不可變的。它有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

[[GetOwnProperty]] ( P )

English

數組對象使用一個，用在其他原生 ECMAscript 對象的 [[GetOwnProperty]] 內部方法的變化版。這個特殊內部方法用來給命名屬性添加訪問器，對應到字符串對象的單字符。

設 S 爲一個字符串對象，P 爲一個字符串。

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

令 desc 爲以 P 爲參數調用 S 的默認 [[GetOwnProperty]] 內部方法的結果。
如果 desc 不是 undefined，返回 desc。
如果 ToString(abs( ToInteger(P ))) 與 P 的值不同，返回 undefined。
令 str 爲 S 的 [[PrimitiveValue]] 內部屬性字符串值。
令 index 爲 ToInteger(P)。
令 len 爲 str 裏的字符數。
如果 len ≤ index，返回 undefined。
令 resultStr 爲一個長度爲 1 的字符串，裏面包含 str 中 index 位置的一個字符，在這裏 str 中的第一個（最左邊）字符被認爲是在位置 0，下一個字符在位置 1，依此類推。
返回一個屬性描述符 { [[Value]]: resultStr, [[Enumerable]]: true, [[Writable]]: false, [[Configurable]]: false }

Boolean 對象

English

test262

作爲函數調用 Boolean 構造器

English

當把 Boolean 作爲函數來調用，而不是作爲構造器，它執行一個類型轉換。

Boolean (value)

English

返回由 ToBoolean(value) 計算出的 Boolean 值（非 Boolean 對象）。

Boolean 構造器

English

當 Boolean 作爲 new 表達式的一部分來調用，那麼它是一個構造器：它初始化新創建的對象。

new Boolean (value)

English

新構造對象的 [[Prototype]] 內部屬性設定爲原始 Boolean 原型對象，它是 Boolean.prototype 的初始值。

新構造對象的 [[Class]] 內部屬性設定爲 "Boolean"。

新構造對象的 [[PrimitiveValue]] 內部屬性設定爲 ToBoolean(value)。

新構造對象的 [[Extensible]] 內部屬性設定爲 true。

Boolean 構造器的屬性

English

Boolean 構造器的 [[Prototype]] 內部屬性的值是 Function 原型對象。

除了內部屬性和 length 屬性（值爲 1）外，Boolean 構造器還有以下屬性：

Boolean.prototype

English

Boolean.prototype 的初始值是 Boolean 原型對象。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Boolean 原型對象的屬性

English

Boolean 原型對象自身是一個值爲 false 的 Boolean 對象（它的 [[Class]] 是 "Boolean"）。

Boolean 原型對象的 [[Prototype]] 內部屬性值是標準的內置 Object 原型對象。

Boolean.prototype.constructor

English

Boolean.prototype.constructor 的初始值是內置的 Boolean 構造器。

Boolean.prototype.toString ( )

English

採用以下步驟：

令 B 爲 this 值。
如果 Type(B) 是 Boolean，則令 b 爲 B。
否則如果 Type(B) 是 Object 且 B 的 [[Class]] 內部屬性值是 "Boolean"，則令 b 爲 B 的 [[PrimitiveValue]] 內部屬性值。
否則拋出一個 TypeError 異常。
如果 b 是 true，則返回 "true"；否則返回 "false"。

Boolean.prototype.valueOf ( )

English

採用以下步驟：

令 B 爲 this 值。
如果 Type(B) 是 Boolean，則令 b 爲 B。
否則如果 Type(B) 是 Object 且 B 的 [[Class]] 內部屬性值是 "Boolean"，則令 b 爲 B 的 [[PrimitiveValue]] 內部屬性值。
否則拋出一個 TypeError 異常。
返回 b。

Boolean 實例的屬性

English

Boolean 實例從 Boolean 原型對象繼承屬性，且 Boolean 實例的 [[Class]] 內部屬性值是 "Boolean"。Boolean 實例還有一個 [[PrimitiveValue]] 內部屬性。

[[PrimitiveValue]] 內部屬性是代表這個 Boolean 對象的 Boolean 值。

Number 對象

English

test262

作爲函數調用的 Number 構造器

English

當把 Number 當作一個函數來調用，而不是作爲構造器，它執行一個類型轉換。

Number ( [ value ] )

English

如果提供了 value，返回 ToNumber(value) 計算出的 Number 值（非 Number 對象），否則返回 +0。

Number 構造器

English

當把 Number 作爲 new 表達式的一部分來調用，它是構造器：它初始化新創建的對象。

new Number ( [ value ] )

English

新構造對象的 [[Prototype]] 內部屬性設定爲原始 Number 原型對象，它是 Number.prototype 的初始值。

新構造對象的 [[Class]] 內部屬性設定爲 "Number"。

新構造對象的 [[PrimitiveValue]] 內部屬性在提供了 value 時設定爲 ToNumber(value)，否則設定爲 +0。

新構造對象的 [[Extensible]] 內部屬性設定爲 true。

Number 構造器的屬性

English

Number 構造器的 [[Prototype]] 內部屬性值是 Function 原型對象。

除了內部屬性和 length 屬性（值爲 1）之外，Number 構造器還有以下屬性：

Number.prototype

English

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

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Number.MAX_VALUE

English

Number.MAX_VALUE 的值是 Number 類型的最大正有限值，約爲 1.7976931348623157×10³⁰⁸。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Number.MIN_VALUE

English

Number.MIN_VALUE 的值是 Number 類型的最小正有限值，約爲 5×10^-324。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Number.NaN

English

Number.NaN 的值是 NaN。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Number.NEGATIVE_INFINITY

English

Number.NEGATIVE_INFINITY 的值是-∞。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Number.POSITIVE_INFINITY

English

Number.POSITIVE_INFINITY 的值是 +∞。

這個屬性有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

Number 原型對象的屬性

English

Number 原型對象其自身是 Number 對象（其 [[Class]] 是 "Number"），其值爲 +0。

Number 原型對象的 [[Prototype]] 內部屬性值是標準內置 Object 原型對象。

除非另外明確聲明，以下定義的 Number 原型對象的方法是非通用的，傳遞給它們的 this 值必須是 Number 值或 [[Class]] 內部屬性值是 "Number" 的對象。

在以下對作爲 Number 原型對象屬性的函數的描述中，短語“this Number 對象”是指函數調用中的 this，或如果 Type( this ) 是 Number，“this Number 對象”指彷彿是用表達式 new Number( this ) 創建的對象，這裏 Number 是標準內置構造器名。此外，短語“this Number 值”是指代表 this Number 對象 的 Number 值，也就是 this Number 對象 的 [[PrimitiveValue]] 內部屬性值；或如果 this 是 Number 類型，“this Number 值”指 this。如果 this 值不是 [[Class]] 內部屬性爲 "Number" 的對象，也不是 Number 類型的值，則拋出一個 TypeError 異常。

Number.prototype.constructor

English

Number.prototype.constructor 的初始值是內置 Number 構造器。

Number.prototype.toString ( [ radix ] )

English

可選參數 radix 應當是 2 到 36 閉區間上的整數。如果 radix 不存在或是 undefined，用數字 10 作爲 radix 的值。如果 ToInteger(radix) 是數字 10，則將 this Number 對象 作爲一個參數傳給 ToString 抽象操作；返回結果字符串值。

如果 ToInteger( radix ) 不是在 2 到 36 閉區間上的整數，則拋出一個 RangeError 異常。如果 ToInteger( radix ) 是 2 到 36 的整數，但不是 10，則結果是 this Number 值 使用指定基數表示法的字符串。字母 a-z 用來指值爲 10 到 35 的數字。基數不爲 10 時的精確算法是依賴於實現的，然而算法應當是 9.8.1 指定算法的推廣形式。

toString 函數不是通用的；如果 this 值不是數字或 Number 對象，拋出一個 TypeError 異常。因此它不能當作方法轉移到其他類型對象上。

Number.prototype.toLocaleString()

English

根據宿主環境的當前語言環境慣例來格式化 this Number 值，生成代表這個值的字符串。此函數是依賴於實現的，允許但不鼓勵它的返回值與 toString 相同。

注：此函數的第一個參數可能會用於本標準的未來版本 ; 建議實現不以任何用途使用這個參數位置。

Number.prototype.valueOf ( )

English

返回 this Number 值。

valueOf 函數不是通用的；如果 this 值不是數字或 Number 對象，拋出一個 TypeError 異常。因此它不能當作方法轉移到其他類型對象上。

Number.prototype.toFixed (fractionDigits)

English

返回一個包含了代表 this Number 值的留有小數點後 fractionDigits 個數字的十進制固定小數點記法的字符串。如果 fractionDigits 是 undefined，就認爲是 0。具體來說，執行以下步驟：

令 f 爲 ToInteger(fractionDigits)。（如果 fractionDigits 是 undefined，此步驟產生 0 值。）
如果 f < 0 或 f > 20，拋出一個 RangeError 異常。
令 x 爲 this Number 值。
如果 x 是 NaN，返回字符串 "NaN"。
令 s 爲空字符串。
如果 x < 0，則
1. 令 s 爲 "-"。
2. 令 x = -x。
如果 x ≥ 10²¹，則
1. 令 m = ToString(x)。
否則，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 的結果。
返回串聯字符串 s 和 m 的結果。

toFixed 方法的 length 屬性是 1。

如果以多個參數調用 toFixed 方法，則行爲是不確定的（見15章）。

實現是被允許在 fractionDigits 小於 0 或大於 20 時擴展 toFixed 的行爲。在這種情況下，對這樣的 fractionDigits 值 toFixed 將未必拋出 RangeError。

注：對於某些值，toFixed 的輸出可比 toString 的更精確，因爲 toString 只打印區分相鄰 Number 值的足夠的有效數字。例如，

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

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

Number.prototype.toExponential (fractionDigits)

English

返回一個代表 this Number 值 的科學計數法的字符串，它的有效數字的小數點前有一個數字，有效數字的小數點後有 fractionDigits 個數字。如果 fractionDigits 是 undefined，包括指定唯一 Number 值需要的儘可能多的有效數字（就像 ToString，但在這裏總是以科學計數法輸出）。具體來說執行以下步驟：

令 x 爲 this Number 值。
令 f 爲 ToInteger(fractionDigits)。
如果 x 是 NaN，返回字符串 "NaN"。
令 s 爲空字符串。
如果 x < 0，則
1. 令 s 爲 "-"。
2. 令 x = -x。
如果 x = +∞，則
1. 返回串聯字符串 s 和 "Infinity" 的結果。
如果 fractionDigits 不是 undefined 且（f < 0 或 f > 20），拋出一個 RangeError 異常。
如果 x = 0，則
1. 令 f = 0。
2. 令 m 爲包含 f + 1 個 '0' 的字符串。
3. 令 e = 0。
否則，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 的 Number 值是 x，且 f 的值儘可能小。注：n 的十進制表示有 f + 1 個數字，n 不能被 10 整除，並且 n 的最少有效位數不一定唯一由這些條件確定。
3. 令 m 爲由 n 的十進制表示裏的數組成的字符串（沒有前導零）。
如果 f ≠ 0，則
1. 令 a 爲 m 中的第一個字符，令 b 爲 m 中的其餘字符。
2. 令 m 爲串聯三個字符串 a、"." 的 b 的結果。
如果 e = 0，則
1. 令 c = "+"。
2. 令 d = "0"。
否則
1. 如果 e > 0，則令 c = "+"。
2. 否則，e ≤ 0
  1. 令 c = "-"。
  2. 令 e = -e。
3. 令 d 爲有 e 的十進制表示裏的數組成的字符串（沒有前導零）。
令 m 爲串聯四個字符串 m、"e"、c 和 d 的結果。
返回串聯字符串 s 和 m 的結果。

toExponential 方法的 length 屬性是 1。

如果用多於一個參數調用 toExponential 方法，則行爲是未定義的（見15章）。

一個實現可以擴展 fractionDigits 的值小於 0 或大於 20 時 toExponential 的行爲。這種情況下對這樣的 fractionDigits 值，toExponential 不一定拋出 RangeError 異常。

注：對於需要提供比上述規則更準確轉換的實現，建議用以下算法作爲指引替代步驟 9.2.1：

令 e、n 和 f 爲整數，使得滿足 f ≥ 0，10^f ≤ n < 10^f+1，n × 10^e-f 的 Number 值是 x，且 f 的值儘可能小。如果這樣的 n 值可能多個，選擇使 n × 10^e-f 的值儘可能接近 x 的 n 值。如果有兩個這樣的 n 值，選擇偶數。

Number.prototype.toPrecision (precision)

English

返回一個字符串，它代表 this Number 值 的科學計數法（有效數字的小數點前有一個數字，有效數字的小數點後有 precision - 1 個數字）或十進制固定計數法（precision 個有效數字）。如果 precision 是 undefined，用 ToString 調用代替。具體來說執行以下步驟：

令 x 爲 this 數字值。
如果 precision 是 undefined，返回 ToString(x)。
令 p 爲 ToInteger(precision)。
如果 x 是 NaN，返回字符串 "NaN"。
令 s 爲空字符串。
如果 x < 0，則
1. 令 s 爲 "-"。
2. 令 x = -x。
如果 x = +∞，則
1. 返回串聯字符串 s 和 "Infinity" 的結果。
如果 p < 1 或 p > 21，拋出一個 RangeError 異常。
如果 x = 0，則
1. 令 m 爲 p 個 '0' 組成的字符串。
2. 令 e = 0。
否則 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 的結果。
如果 e = p - 1，則返回串聯字符串 s 和 m 的結果。
如果 e ≥ 0，則
1. 令 m 爲 m 的前 e + 1 個字符，字符 '.'，m 的其餘 p - (e + 1) 個字符串聯的結果。
否則 e < 0，
1. 令 m 爲字符串 "0."、- (e + 1) 個字符 '0'、字符串 m 串聯的結果。
返回字符串 s 和 m 串聯的結果。

toPrecision 方法的 length 屬性是 1。

如果用多於一個參數調用 toPrecision 方法，則行爲是未定義的（見15章）。

一個實現可以擴展 precision 的值小於 1 或大於 21 時 toPrecision 的行爲。這種情況下對這樣的 precision 值，toPrecision 不一定拋出 RangeError 異常。

Number 實例的屬性

English

Number 實例從 Number 原型對象繼承屬性，Number 實例的 [[Class]] 內部屬性是 "Number"。Number 實例還有一個 [[PrimitiveValue]] 內部屬性。

[[PrimitiveValue]] 內部屬性是代表 this Number 對象 的 Number 值。

Math 對象

English

test262

Math 對象是擁有一些命名屬性的單一對象，其中一些屬性值是函數。

Math 對象的 [[Prototype]] 內部屬性值是標準內置 Object 原型對象 (15.2.4)。Math 對象的 [[Class]] 內部屬性值是 "Math"。

Math 對象沒有 [[Construct]] 內部屬性 ; Math 對象不能作爲構造器被 new 運算符調用。

Math 對象沒有 [[Call]] 內部屬性；Math 對象不能作爲函數被調用。

注：本規範中，短語“x 的 Number 值”的技術含義定義在 8.5。

Math 對象的值屬性

English