Array 对象

数组对象会给予一些种类的属性名特殊待遇。对一个属性名 P（字符串形式），当且仅当 ToString(ToUint32(P)) 等于 P 并且 ToUint32(P) 不等于 232−1 时，它是个 数组索引 。一个属性名是数组索引的属性还叫做 元素 。所有数组对象都有一个 length 属性，其值始终是一个小于 232 的非负整数。length 属性值在数值上比任何名为数组索引的属性的名称还要大；每当创建或更改一个数组对象的属性，要调整其他的属性以保持上面那个条件不变的需要。具体来说，每当添加一个名为数组索引的属性时，如果需要就更改 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 作为函数来调用，而不是作为构造器，它会创建并初始化一个新数组对象。所以函数调用 Array(…) 与用相同参数的 new Array(…) 表达式创建的对象相同。

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

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

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

Array 构造器

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

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

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

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

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

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

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

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

new Array (len)

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

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

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

Array 构造器的属性

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

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

Array.prototype

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

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

Array.isArray ( arg )

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

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

数组原型对象的属性

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

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

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

 数组原型对象不包含它自身的 valueOf 属性；然而，它从标准内置 Object 原型对象继承 valueOf 属性。

Array.prototype.constructor

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

Array.prototype.toString ( )

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

1. 令 array 为用 this 值调用 ToObject 的结果。
2. 令 func 为以 "join" 作为参数调用 array 的 [[Get]] 内部方法的结果。
3. 如果 IsCallable(func) 是 false, 则令 func 为标准内置方法 Object.prototype.toString (15.2.4.2)。
4. 提供 array 作为 this 值并以空参数列表调用 func 的 [[Call]] 内部方法，返回结果。

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

Array.prototype.toLocaleString ( )

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

 结果是按照一下方式计算的：

1. 令 array 为以 this 值作为参数调用 ToObject 的结果。
2. 令 arrayLen 为以 "length" 作为参数调用 array 的 [[Get]] 内部方法的结果。
3. 令 len 为 ToUint32(arrayLen)。
4. 令 separator 为宿主环境的当前语言环境对应的列表分隔符字符串（这是实现定义的方式得到的）。
5. 如果 len 是零 , 返回空字符串。
6. 令 firstElement 为以 "0" 作为参数调用 array 的 [[Get]] 内部方法的结果。
7. 如果 firstElement 是 undefined 或 null, 则令 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() 创建的新数组，这里的 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, 执行以下步骤 :

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() 创建的新数组，这里的 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 数组的元素 排序。排序不一定是稳定的（相等的元素们不一定按照他们原来的顺序排列）。如果 comparefn 不是 undefined，它就必须是个函数，这个函数接受两个参数 x 和 y，如果 x < y 返回一个负值，如果 x = y 返回零，如果 x > y 返回一个正值。

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

 以 "length" 作为参数调用 obj 的 [[Get]] 内部方法，将结果作为参数调用 Uint32，令 len 为返回的结果。

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

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

• obj 是 稀疏的 (15.4)
• 0 ≤ j < len
• 以 ToString(j) 作为参数调用 proto 的 [[HasProperty]] 内部方法的结果是 true

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

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

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

 否则，采用如下步骤。

1. 对 obj 的 [[Get]] , [[Put]], [[Delete]] 内部方法和 SortCompare（下面描述）执行一个依赖于实现的调用序列，这里对每个 [[Get]], [[Put]], 或 [[Delete]] 调用的第一个参数是小于 len 的非负整数 ，SortCompare 调用的参数是前面调用 [[Get]] 内部方法的结果。调用 [[Put]] 和 [[Delete]] 内部方法时，throw 参数是 true。如果 obj 不是 稀疏的 ，则必须不调用 [[Delete]]。
2. 返回 obj。

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

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

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

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

• 当用指定值 a 和 b 作为两个参数调用 comparefn(a,b)，总是返回相同值 v。此外 Type(v) 是 Number, 并且 v 不是 NaN。注意，这意味着对于给定的 a 和 b，a <CF b, a =CF b, and a >CF b 中正好有一个是真。
• 调用 comparefn(a,b) 不改变 this 对象。
• a =CF a ( 自反性 )
• 如果 a =CF b, 则 b =CF a ( 对称性 )
• 如果 a =CF b 并且 b =CF c, 则 a =CF c (=CF 传递 )
• 如果 a <CF b 并且 b <CF c, 则 a <CF c (<CF 传递 )
• 如果 a >CF b 并且 b >CF c, 则 a >CF c (>CF 传递 )

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

 当用两个参数 j 和 k 调用抽象操作 SortCompare，采用如下步骤：

1. 令 jString 为 ToString(j).
2. 令 kString 为 ToString(k).
3. 令 hasj 为 以 jString 作为参数调用 obj 的 [[HasProperty]] 内部方法的结果。
4. 令 hask 为 以 kString 作为参数调用 obj 的 [[HasProperty]] 内部方法的结果。
5. 如果 hasj 和 hask 都是 false, 则返回 +0.
6. 如果 hasj 是 false, 则返回 1.
7. 如果 hask 是 false, 则返回 –1.
8. 令 x 为 以 jString 作为参数调用 obj 的 [[Get]] 内部方法的结果。
9. 令 y 为 以 kString 作为参数调用 obj 的 [[Get]] 内部方法的结果。
10. 如果 x 和 y 都是 undefined, 返回 +0.
11. 如果 x 是 undefined, 返回 1.
12. 如果 y 是 undefined, 返回 −1.
13. 如果 参数 comparefn 不是 undefined, 则如果 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() 创建的新数组，这里的 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 执行严格相等比较算法的结果 .如果 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 执行严格相等比较算法的结果 .如果 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) 创建的新数组，这里的 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) 创建的新数组，这里的 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 或一个访问器描述符，因为在创建数组时的 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。