Array 對象

2018-06-16 15:28 更新

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

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

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

作為函數調用 Array 構造器

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

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

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

  1. 創(chuàng)建并返回一個新函數對象，它仿佛是用相同參數給標準內置構造器 Array 用一個 new 表達式創(chuàng)建的 (15.4.2)。

Array 構造器

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

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

 當且僅當以無參數或至少兩個參數調用 Array 構造器時，適用這里的描述。

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

 新構造對象的 [[Class]] 內部屬性要設定為 "Array"。

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

 新構造對象的 length 屬性要設定為參數的個數。

 新構造對象的 0 屬性要設定為 item0( 如果提供了 ); 新構造對象的 1 屬性要設定為 item1( 如果提供了 ); 更多的參數可應用普遍規(guī)律，新構造對象的 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 方法，將他們轉換成字符串。然后將這些字符串串聯，用一個分隔符分割，這里的分隔符字符串是與特定語言環(huán)境相關，由實現定義的方式得到的。調用這個函數的結果除了與特定語言環(huán)境關聯之外，與 toString 的結果類似。

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

  1. 令 array 為以 this 值作為參數調用 ToObject 的結果。
  2. 令 arrayLen 為以 "length" 作為參數調用 array 的 [[Get]] 內部方法的結果。
  3. 令 len 為 ToUint32(arrayLen)。
  4. 令 separator 為宿主環(huán)境的當前語言環(huán)境對應的列表分隔符字符串（這是實現定義的方式得到的）。
  5. 如果 len 是零 , 返回空字符串。
  6. 令 firstElement 為以 "0" 作為參數調用 array 的 [[Get]] 內部方法的結果。
  7. 如果 firstElement 是 undefined 或 null, 則令 R 為空字符串。
  8. 否則令 elementObj 為 ToObject(firstElement).令 func 為以 "toLocaleString" 作為參數調用 elementObj 的 [[Get]] 內部方法的結果。如果 IsCallable(func) 是 false, 拋出一個 TypeError 異常。令 R 為提供 elementObj 作為 this 值并以空參數列表調用 func 的 [[Call]] 內部方法的結果。
  9. 令 k 為 1。
  10. 只要 k < len 就重復令 S 為串聯 R 和 separator 產生的字符串。令 nextElement 為以 ToString(k) 作為參數調用 array 的 [[Get]] 內部方法的結果。如果 nextElement 是 undefined 或 null, 則令 R 為空字符串。否則令 elementObj 為 ToObject(nextElement).令 func 為以 "toLocaleString" 作為參數調用 elementObj 的 [[Get]] 內部方法的結果。如果 IsCallable(func) 是 false, 拋出一個 TypeError 異常。令 R 為提供 elementObj 作為 this 值并以空參數列表調用 func 的 [[Call]] 內部方法的結果。令 R 為串聯 S 和 R 產生的字符串。k 遞增 1。
  11. 返回 R

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

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

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

 當以零或更多個參數 item1, item2, 等等，調用 concat 方法，返回一個數組，這個數組包含對象的數組元素和后面跟著的每個參數按照順序組成的數組元素。

 采用如下步驟：

  1. 令 O 為以 this 值作為參數調用 ToObject 的結果。
  2. 令 A 為仿佛是用表達式 new Array() 創(chuàng)建的新數組，這里的 Array 是標準內置構造器名。
  3. 令 n 為 0。
  4. 令 items 為一個內部列表，他的第一個元素是 O，其后的元素是傳給這個函數調用的參數（以從左到右的順序）。
  5. 只要 items 不是空就重復刪除 items 的第一個元素，并令 E 為這個元素值。如果 E 的 [[Class]] 內部屬性是 "Array", 則令 k 為 0。令 len 為以 "length" 為參數調用 E 的 [[Get]] 內部方法的結果。只要 k < len 就重復令 P 為 ToString(k).令 exists 為以 P 作為參數調用 E 的 [[HasProperty]] 內部方法的結果。如果 exists 是 true, 則令 subElement 為以 P 作為參數調用 E 的 [[Get]] 內部方法的結果。以 ToString(n), 屬性描述符 {[[Value]]: subElement, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作為參數調用 A 的 [[DefineOwnProperty]] 內部方法。n 遞增 1.k 遞增 1.否則 , E 不是數組以 ToString(n), 屬性描述符 {[[Value]]: E, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作為參數調用 A 的 [[DefineOwnProperty]]</nowiki> 內部方法。n 遞增 1.
  6. 返回 A.

 concat 方法的 length 屬性是 1。

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

Array.prototype.join (separator)

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

 join 方法需要一個參數 separator, 執(zhí)行以下步驟 :

  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 就重復令 S 為串聯 R 和 sep 產生的字符串值 .令 element 為以 ToString(k) 作為參數調用 O 的 [[Get]] 內部方法的結果 .如果 element 是 undefined 或 null, 令 next 為空字符串 ; 否則 , 令 next 為 ToString(element).令 R 為串聯 S 和 next 產生的字符串值 .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 是零 ,以 "length", 0, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .返回 undefined.
  5. 否則 , len > 0令 indx 為 ToString(len–1).令 element 為 以 indx 作為參數調用 O 的 [[Get]] 內部方法的結果 .以 indx 和 true 作為參數調用 O 的 [[Delete]] 內部方法 .以 "length", indx, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .返回 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 不是空就重復刪除 items 的第一個元素，并令 E 為這個元素的值 .以 ToString(n), E, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .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 就重復令 upper 為 len?lower ?1.令 upperP 為 ToString(upper).令 lowerP 為 ToString(lower).令 lowerValue 為以 lowerP 作為參數調用 O 的 [[Get]] 內部方法的結果 .令 upperValue 為以 upperP 作為參數調用 O 的 [[Get]] 內部方法的結果 .令 lowerExists 為以 lowerP 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .令 upperExists 為以 upperP 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 lowerExists 是 true 并且 upperExists 是 true, 則以 lowerP, upperValue, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .以 upperP, lowerValue, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .否則如果 lowerExists 是 false 并且 upperExists 是 true, 則以 lowerP, upperValue, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .以 upperP 和 true 作為參數調用 O 的 [[Delete]] 內部方法 .否則如果 lowerExists 是 true 并且 upperExists 是 false, 則以 lowerP 和 true 作為參數調用 O 的 [[Delete]] 內部方法 .以 upperP, lowerValue, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .否則 , lowerExists 和 upperExists 都是 false不需要做任何事情 .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 是零 , 則以 "length", 0, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .返回 undefined.
  5. 令 first 為以 "0" 作為參數調用 O 的 [[Get]] 內部方法的結果 .
  6. 令 k 為 1.
  7. 只要 k < len 就重復令 from 為 ToString(k).令 to 為 ToString(k–1).令 fromPresent 為以 from 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 fromPresent 是 true, 則令 fromVal 為以 from 作為參數調用 O 的 [[Get]] 內部方法的結果 .以 to, fromVal, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .否則 , fromPresent 是 false以 to 和 ture 作為參數調用 O 的 [[Delete]] 內部方法 .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() 創(chuàng)建的新數組，這里的 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 就重復令 Pk 為 ToString(k).令 kPresent 為 Pk 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 kValue 為以 Pk 作為參數調用 O 的 [[Get]] 內部方法的結果 .以 ToString(n), 屬性描述符 {[[Value]]: kValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作為參數調用 A 的 [[DefineOwnProperty]] 內部方法 .k 遞增 1.n 遞增 1.
  11. 返回 A.

 slice 方法的 length 屬性是 2。

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

Array.prototype.sort (comparefn)

 給 this 數組的元素 排序。排序不一定是穩(wěn)定的（相等的元素們不一定按照他們原來的順序排列）。如果 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（下面描述）執(zhí)行一個依賴于實現的調用序列，這里對每個 [[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] 用來指：假定在執(zhí)行這個函數之前以 j 作為參數調用 obj 的 [[Get]] 內部方法的結果，符號 new[j] 用來指：假定在執(zhí)行這個函數后以 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, 則如果 IsCallable(comparefn) 是 false, 拋出一個 TypeError 異常 .傳入 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() 創(chuàng)建的新數組，這里的 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 就重復令 from 為 ToString(actualStart+k).令 fromPresent 為 以 from 作為參數調用 O 的 [[HasProperty]] 內部方法的結果。如果 fromPresent 是 true, 則令 fromValue 為 以 from 作為參數調用 O 的 [[Get]] 內部方法的結果。以 ToString(k), 屬性描述符 {[[Value]]: fromValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作為參數調用 A 的 [[DefineOwnProperty]] 內部方法。k 遞增 1.
  10. 令 items 為一個內部列表，它的元素是實際參數列表中 item1 開始的參數（從左到右的順序）。如果沒傳入這些項目，則列表是空的。
  11. 令 itemCount 為 items 的元素個數 .
  12. 如果 itemCount < actualDeleteCount, 則令 k 為 actualStart.只要 k < (len – actualDeleteCount) 就重復令 from 為 ToString(k+actualDeleteCount).令 to 為 ToString(k+itemCount).令 fromPresent 為 以 from 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 fromPresent 是 true, 則令 fromValue 為 以 from 作為參數調用 O 的 [[Get]] 內部方法的結果 .以 to, fromValue, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .否則 , fromPresent 是 false以 to 和 true 作為參數調用 O 的 [[Delete]] 內部方法 .k 遞增 1.令 k 為 len.只要 k > (len – actualDeleteCount +itemCount) 就重復以 ToString(k–1) 和 true 作為參數調用 O 的 [[Delete]] 內部方法 .k 遞減 1.
  13. 否則如果 itemCount > actualDeleteCount, 則令 k 為 (len – actualDeleteCount).只要 k > actualStart 就重復令 from 為 ToString(k + actualDeleteCount – 1).令 to 為 ToString(k + itemCount – 1)令 fromPresent 為 以 from 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 fromPresent 是 true, 則令 fromValue 為 以 from 作為參數調用 O 的 [[Get]] 內部方法的結果 .以 to, fromValue, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .否則 , fromPresent 是 false以 to 和 true 作為參數調用 O 的 [[Delete]] 內部方法 .k 遞減 1.
  14. 令 k 為 actualStart.
  15. 只要 items 不是空 就重復刪除 items 的第一個元素 , 并令 E 為這個元素值 .以 ToString(k), E, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .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, 就重復令 from 為 ToString(k–1).令 to 為 ToString(k+argCount –1).令 fromPresent 為 以 from 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 fromPresent 是 true, 則令 fromValue 為 以 from 作為參數調用 O 的 [[Get]] 內部方法的結果 .以 to, fromValue, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .否則 , fromPresent 是 false以 to 和 true 作為參數調用 O 的 [[Delete]] 內部方法 .k 遞減 1.
  7. 令 j 為 0.
  8. 令 items 為一個內部列表，它的元素是調用這個函數時傳入的實際參數（從左到右的順序）。
  9. 只要 items 不是空，就重復刪除 items 的第一個元素，并令 E 為這個元素值 .以 ToString(j), E, 和 true 作為參數調用 O 的 [[Put]] 內部方法 .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, 則令 k 為 n.
  8. 否則 , n<0令 k 為 len - abs(n).如果 k 小于 0, 則令 k 為 0.
  9. 只要 k<len，就重復令 kPresent 為 以 ToString(k) 為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 elementK 為 以 ToString(k) 為參數調用 O 的 [[Get]] 內部方法的結果 .令 same 為 對 searchElement 和 elementK 執(zhí)行嚴格相等比較算法的結果 .如果 same 是 true, 返回 k.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令 k 為 len - abs(n).
  8. 只要 k≥ 0 就重復令 kPresent 為 以 ToString(k) 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 elementK 為 以 ToString(k) 作為參數調用 O 的 [[Get]] 內部方法的結果 .令 same 為 對 searchElement 和 elementK 執(zhí)行嚴格相等比較算法的結果 .如果 same 是 true, 返回 k.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 ，就重復令 Pk 為 ToString(k).令 kPresent 為 以 Pk 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 kValue 為 以 Pk 作為參數調用 O 的 [[Get]] 內部方法的結果 .令 testResult 為 以 T 作為 this 值以包含 kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .如果 ToBoolean(testResult) 是 false, 返回 false.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 ，就重復令 Pk 為 ToString(k).令 kPresent 為 以 Pk 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 kValue 為 以 Pk 作為參數調用 O 的 [[Get]] 內部方法的結果 .令 testResult 為 以 T 作為 this 值以包含 kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .如果 ToBoolean(testResult) 是 true, 返回 true.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 ，就重復令 Pk 為 ToString(k).令 kPresent 為 以 Pk 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 kValue 為 以 Pk 作為參數調用 O 的 [[Get]] 內部方法的結果 .以 T 作為 this 值以包含 kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法 .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) 創(chuàng)建的新數組，這里的 Array 是標準內置構造器名，len 是 len 的值。
  7. 令 k 為 0.
  8. 只要 k < len ，就重復令 Pk 為 ToString(k).令 kPresent 為 以 Pk 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 kValue 為 以 Pk 作為參數調用 O 的 [[Get]] 內部方法的結果 .令 mappedValue 為 以 T 作為 this 值以包含 kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .以 Pk, 屬性描述符 {[[Value]]: mappedValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作為參數調用 A 的 [[DefineOwnProperty]] 內部方法 .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) 創(chuàng)建的新數組，這里的 Array 是標準內置構造器名，len 是 len 的值。
  7. 令 k 為 0.
  8. 令 to 為 0.
  9. 只要 k < len ，就重復令 Pk 為 ToString(k).令 kPresent 為 以 Pk 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 kValue 為 以 Pk 作為參數調用 O 的 [[Get]] 內部方法的結果 .令 selected 為 以 T 作為 this 值以包含 kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .如果 ToBoolean(selected) 是 true, 則以 ToString(to), 屬性描述符 {[[Value]]: kValue, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, 和 false 作為參數調用 A 的 [[DefineOwnProperty]] 內部方法 .to 遞增 1.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 參數有傳入值 , 則設定 accumulator 為 initialValue.
  8. 否則 , initialValue 參數沒有傳入值令 kPresent 為 false.只要 kPresent 是 false 并且 k < len ，就重復令 Pk 為 ToString(k).令 kPresent 為 以 Pk 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 accumulator 為 以 Pk 作為參數調用 O 的 [[Get]] 內部方法的結果 .k 遞增 1.如果 kPresent 是 false, 拋出一個 TypeError 異常 .
  9. 只要 k < len ，就重復令 Pk 為 ToString(k).令 kPresent 為 以 Pk 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 kValue 為 以 Pk 作為參數調用 O 的 [[Get]] 內部方法的結果 .令 accumulator 為 以 undefined 作為 this 值并以包含 accumulator, kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .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 參數有傳入值 , 則設定 accumulator 為 initialValue.
  8. 否則 , initialValue 參數沒有傳入值令 kPresent 為 false.只要 kPresent 是 false 并且 k ≥ 0 ，就重復令 Pk 為 ToString(k).令 kPresent 為 以 Pk 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 accumulator 為 以 Pk 作為參數調用 O 的 [[Get]] 內部方法的結果 .k 遞減 1.如果 kPresent 是 false, 拋出一個 TypeError 異常 .
  9. 只要 k ≥ 0 ，就重復令 Pk 為 ToString(k).令 kPresent 為 以 Pk 作為參數調用 O 的 [[HasProperty]] 內部方法的結果 .如果 kPresent 是 true, 則令 kValue 為 以 Pk 作為參數調用 O 的 [[Get]] 內部方法的結果 .令 accumulator 為 以 undefined 作為 this 值并以包含 accumulator, kValue, k, 和 O 的參數列表調用 callbackfn 的 [[Call]] 內部方法的結果 .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 或一個訪問器描述符，因為在創(chuàng)建數組時的 length 是一個不可刪除或重新配置的數據屬性。
  2. 令 oldLen 為 oldLenDesc.[[Value]].
  3. 如果 P 是 "length", 則如果 Desc 的 [[Value]] 字段不存在 , 則以 "length", Desc, 和 Throw 作為參數在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9)，返回結果。令 newLenDesc 為 Desc 的一個拷貝 .令 newLen 為 ToUint32(Desc.[[Value]]).如果 newLen 不等于 ToNumber( Desc.[[Value]]), 拋出一個 RangeError 異常 .設定 newLenDesc.[[Value]] 為 newLen.如果 newLen ≥oldLen, 則以 "length", newLenDesc, 和 Throw 作為參數在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9)，返回結果。如果 oldLenDesc.[[Writable]] 是 false，拒絕如果 newLenDesc.[[Writable]] 不存在或值是 true, 令 newWritable 為 true.否則 ,因為它將使得無法刪除任何元素，所以需要延后設定 [[Writable]] 特性為 false.令 newWritable 為 false.設定 newLenDesc.[[Writable]] 為 true.令 succeeded 為 以 "length", newLenDesc, 和 Throw 作為參數在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9) 的結果如果 succeeded 是 false, 返回 false..只要 newLen < oldLen，就重復 ,設定 oldLen 為 oldLen – 1.令 deleteSucceeded 為 以 ToString(oldLen) 和 false 作為參數調用 A 的 [[Delete]] 內部方法的結果 .如果 deleteSucceeded 是 false, 則設定 newLenDesc.[[Value]] 為 oldLen+1.如果 newWritable 是 false, 設定 newLenDesc.[[Writable]] 為 false.以 "length", newLenDesc, 和 false 為參數在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9).拒絕 .如果 newWritable 是 false, 則以 "length", 屬性描述符 {[[Writable]]: false}, 和 false 作為參數在 A 上調用 [[DefineOwnProperty]] 內部方法 (8.12.9). 這個調用始終返回 true.返回 true.
  4. 否則如果 P 是一個數組索引 (15.4), 則令 index 為 ToUint32(P).如果 index ≥ oldLen 并且 oldLenDesc.[[Writable]] 是 false，拒絕 .令 succeeded 為 以 P, Desc, 和 false 作為參數在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9) 的結果 .如果 succeeded 是 false，拒絕 .如果 index ≥ oldLen設定 oldLenDesc.[[Value]] 為 index + 1.以 "length", oldLenDesc, 和 false 作為參數在在 A 上調用默認的 [[DefineOwnProperty]] 內部方法 (8.12.9). 這個調用始終返回 true.返回 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。


以上內容是否對您有幫助：
在線筆記
App下載
App下載

掃描二維碼

下載編程獅App

公眾號
微信公眾號

編程獅公眾號