学会微笑

ECMA-262 7ᵗʰ Edition 第 22 章

学会微笑 · 2017-01-05翻译 · 69阅读 原文链接

22 索引的集合#

22.1 Array对象#

Array对象是会对某些属性名特殊处理的外来对象。看9.4.2可以了解这些特殊处理的定义。

22.1.1 Array构造函数#

Array构造函数是全局对象Array属性的内部对象和初始值。当作为构造函数被调用,它创建并且初始化一个新的Array对象,当作为一个函数被调用而不是构造函数,它也会创建和初始化一个新的Array对象。因此,相同参数的方法调用 Array(…)和对象创建表达式new Array(…)是等价的。

Array构造函数是一个单一的方法,它的行为基于参数的个数和类型被重载。

Array构造函数设计成可派生的。它可能被当成一个类定义的extends语句的值来使用。想要继承外来Array对象行为的子类构造函数必须包含一个对Array构造函数的super调用来初始化一个外来Array对象子类的实例。另一方面,作为一个外来对象,大部分Array.prototype方法是一个不依赖this值的通用方法。

Array构造函数的length属性是1。

22.1.1.1 Array()#

这个描述应用在当且仅当Array构造函数在没有参数的情况下调用。

  1. numberOfArgs作为参数的个数传递给方法调用。
  2. 断言: numberOfArgs = 0。
  3. 如果NewTarget等于undefined,让NewTarget成为活跃的方法对象,否则不变。
  4. proto = GetPrototypeFromConstructor(newTarget"%ArrayPrototype%")。
  5. 返回ArrayCreate(0, proto)。

22.1.1.2Array (len)#

这个描述应用在当且仅当Array构造函数在只有一个参数的情况下调用。

  1. numberOfArgs作为参数的个数传递给方法调用。
  2. 断言: numberOfArgs = 1。
  3. 如果NewTarget等于undefined,让NewTarget成为活跃的方法对象,否则不变。
  4. proto=GetPrototypeFromConstructor(newTarget"%ArrayPrototype%")。
  5. 让array = ArrayCreate(0, proto)。
  6. 如果(len)的类型不是Number,那么 1、 让defineStatus = CreateDataProperty(array"0"len)。 2、 断言: defineStatus = true。 3、 让intLen = 1。
  7. 否则, 1、 让intLen = ToUint32(len)。 2、 如果intLenlen, 抛出RangeError异常。
  8. 执行! Set(array"length"intLentrue)。
  9. 返回array

22.1.1.3 Array(...items )#

这个描述应用在当且仅当Array构造函数在至少有两个参数的情况下调用。

Array方法被调用,会发生以下步骤:

  1. numberOfArgs作为参数的个数传递给方法调用。
  2. 断言: numberOfArgs ≥ 2。
  3. 如果NewTarget等于undefined,让NewTarget成为活跃的方法对象,否则不变。
  4. proto = GetPrototypeFromConstructor(newTarget"%ArrayPrototype%")。
  5. array = ArrayCreate(numberOfArgsproto)。
  6. k = 0。
  7. items等于一个零开始的包含顺序参数列表的List
  8. 重复, 当k < numberOfArgs
    1. Pk = ToString(k)。
    2. itemK = items[k]。
    3. defineStatus = CreateDataProperty(arrayPkitemK)。
    4. 断言: defineStatus = true
    5. k加1。
  9. 断言: arraylength属性为numberOfArgs
  10. 返回array

22.1.2 Array构造函数的属性#

Array构造函数的[[Prototype]]内部位置的值是原有对象的%FunctionPrototype%

Array构造函数有以下属性:

22.1.2.1Array.from( items [ , mapfn [ , thisArg ] ] )#

from方法带着items参数以及可选参数mapfnthisArg调用,会发生以下步骤:

  1. C = this
  2. 如果mapfn等于undefined, 让mapping = false
  3. 否则,
    1. 如果IsCallable(mapfn)等于false, 抛出TypeError异常。
    2. 如果thisArg有定义, 让T = thisArg; 否则让T = undefined
    3. mapping = true
  4. usingIterator = GetMethod(items, @@iterator)。
  5. 如果usingIterator不等于undefined, 那么
    1. 如果IsConstructor(C)等于true,那么
      1. A = Construct(C)。
    2. 否则,
      1. A = ArrayCreate(0)。
    3. iterator = GetIterator(itemsusingIterator)。
    4. k = 0。
    5. 重复
      1. 如果 k ≥ 253-1, 那么
        1. error = Completion{[[Type]]: throw, [[Value]]: a newly created TypeError object, [[Target]]: empty}。
        2. 返回 IteratorClose(iteratorerror)。
      2. Pk = ToString(k)。
      3. next = IteratorStep(iterator)。
      4. 如果 next 等于 false, 那么
        1. 执行 Set(A"length"ktrue)。
        2. 返回 A
      5. nextValue = IteratorValue(next)。
      6. 如果 mapping 等于 true, 那么
        1. mappedValue = Call(mapfnT, « nextValuek »)。
        2. 如果 mappedValue 等于 an abrupt completion, 返回 IteratorClose(iteratormappedValue)。
        3. mappedValue = mappedValue.[[Value]]。
      7. 否则, 让 mappedValue = nextValue
      8. defineStatus = CreateDataPropertyOrThrow(APkmappedValue)。
      9. 如果 defineStatus 是一个 abrupt completion, 返回 IteratorClose(iteratordefineStatus)。
      10. k 加 1。
  6. 注释: items 不可迭代因此假设他是一个类数组。
  7. arrayLike = ToObject(items)。
  8. len = ToLength(Get(arrayLike"length"))。
  9. 如果 IsConstructor(C) 等于 true, 那么
    1. A = Construct(C, « len »)。
  10. 否则,
    1. A = ArrayCreate(len)。
  11. k = 0。
  12. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kValue = Get(arrayLikePk)。
    3. 如果 mapping 等于 true, 那么
      1. mappedValue = Call(mapfnT, « kValuek »)。
    4. 否则, 让 mappedValue = kValue
    5. 执行 CreateDataPropertyOrThrow(APkmappedValue)。
    6. k 加 1。
  13. 执行 Set(A"length"lentrue)。
  14. 返回 A

注释

from函数是一个特意的通用的工厂方法; 它不要求this的值是一个数组构造函数。 因此它可以被其他任何构造函数通过以单个数字参数调用来转变或者继承。

22.1.2.2Array.isArray ( arg )#

isArray有一个参数arg, 步骤如下:

  1. 返回 IsArray(arg)。

22.1.2.3Array.of ( ...items )#

of方法以任何数量的参数调用, 都是以下步骤发生:

  1. len 等于调用时传给函数的参数个数。
  2. items等于传给函数参数的List
  3. C = this
  4. 如果 IsConstructor(C) is true, 那么
    1. A = Construct(C, « len »)。
  5. 否则,
    1. A = ArrayCreate(len)。
  6. k = 0。
  7. 重复, 当 k < len
    1. kValue = items[k]。
    2. Pk = ToString(k)。
    3. 执行 CreateDataPropertyOrThrow(APkkValue)。
    4. k 加 1。
  8. 执行 Set(A"length"lentrue)。
  9. 返回 A

注释 1

假设items参数是一个有序的其余参数值。

注释 2

of函数是一个特有的通用的工厂方法; 它不要求this的值是一个数组构造函数。 因此它可以被其他任何构造函数通过以单个数字参数调用来转变或者继承。

22.1.2.4 Array.prototype#

Array.prototype的值是%ArrayPrototype%——固有数组原型对象。

这个属性有以下特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

22.1.2.5get Array [ @@species ]#

Array[@@species]是一个可访问属性,它的赋值属性方法是undefined。 它的访问属性方法步骤如下:

  1. 返回 this

这个方法的 name 属性是 "get [Symbol.species]"

注释

正常来说数组原型对象方法会使用 this 对象的构造函数去创建派生对象。但是,子类构造函数可以通过重定义@@species属性来覆盖这个默认行为。

22.1.3Array的Prototype对象的属性#

Array的prototype对象是固有对象%ArrayPrototype%。 Array的prototype是Array的内部对象, 并且为每个对象声明了内部方法。它有一个初始值为0的 length 属性, 它的特性是 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }。

Array的prototype对象内部的[[Prototype]]是固有对象%ObjectPrototype%

注释

Array的prototype对象被声明为数组外来对象来保证兼容为ECMAScript 2015规范写的ECMAScript代码。

22.1.3.1Array.prototype.concat ( ...arguments )#

concat 方法用零个或多个参数调用, 它返回一个顺序包含每个参数的数组元素的数组。

以下步骤会发生:

  1. O = ToObject(this value)。
  2. A = ArraySpeciesCreate(O, 0)。
  3. n = 0。
  4. items 等于一个 List, 这个List的第一个元素是 O, 其余的元素是从左到右排列的传给函数调用的参数。
  5. 重复, 当 items 不为空
    1. 移除 items 的第一个元素并且让 E 等于移除的这个元素。
    2. spreadable = IsConcatSpreadable(E)。
    3. 如果 spreadable 等于 true, 那么
      1. k = 0。
      2. len = ToLength(? Get(E"length"))。
      3. 如果 n + len > 253-1, 抛出TypeError异常。
      4. 重复, 当 k < len
        1. P = ToString(k)。
        2. exists = HasProperty(EP)。
        3. 如果 exists 等于 true, 那么
          1. subElement = Get(EP)。
          2. 执行 CreateDataPropertyOrThrow(AToString(n), subElement)。
        4. n 加 1。
        5. k 加 1。
    4. 否则 E 作为单项目添加而不展开,
      1. 如果 n≥253-1, 抛出TypeError异常。
      2. 执行 CreateDataPropertyOrThrow(AToString(n), E)。
      3. n 加 1。
  6. 执行 Set(A"length"ntrue)。
  7. 返回 A

concat 方法的 length 属性值是1。

注释 1

在第6步中对 length 属性的明确的设置是有必要的,为了保证结果数组的随之而来的元素没有出现的情况下它的值是正确的。

注释 2

concat 函数是一个特有的通用的工厂方法; 它不要求this的值是一个数组构造函数。 因此它可以被其他任何构造函数通过以单个数字参数调用来转变或者继承。

22.1.3.1.1 执行期语义: IsConcatSpreadable ( O )#

抽象操作 IsConcatSpreadable 以 O 为参数调用时步骤如下:

  1. 如果O类型不是对象, 返回 false
  2. spreadable = Get(O, @@isConcatSpreadable)。
  3. 如果 spreadable 等于 not undefined, 返回 ToBoolean(spreadable)。
  4. 返回 IsArray(O)。

22.1.3.2Array.prototype.constructor#

Array.prototype.constructor 的初始值是固有对象%Array%

22.1.3.3Array.prototype.copyWithin (targetstart [ , end ] )#

copyWithin 方法有三个参数 targetstartend

注释 1

end 参数是一个可选的作为默认值的this对象的长度。如果 target 为负, 它被看作是 length+targetlength 是数组的长度。 如果 start 为负, 它被看作是length+start。 如果 end 为负, 它被看作是 length+end

步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(? Get(O"length"))。
  3. relativeTarget = ToInteger(target)。
  4. 如果 relativeTarget < 0, 让 to = max((len + relativeTarget), 0); 否则 让 to = min(relativeTargetlen)。
  5. relativeStart = ToInteger(start)。
  6. 如果 relativeStart < 0, 让 from = max((len + relativeStart), 0); 否则 让 from = min(relativeStartlen)。
  7. 如果 end 等于 undefined, 让 relativeEnd = len; 否则 让 relativeEnd = ToInteger(end)。
  8. 如果 relativeEnd < 0, 让 final = max((len + relativeEnd), 0); 否则 让 final = min(relativeEndlen)。
  9. count = min(final-fromlen-to)。
  10. 如果 from<to and to<from+count, 那么
    1. direction = -1。
    2. from = from + count - 1。
    3. to = to + count - 1。
  11. 否则,
    1. direction = 1。
  12. 重复, 当 count > 0
    1. fromKey = ToString(from)。
    2. toKey = ToString(to)。
    3. fromPresent = HasProperty(OfromKey)。
    4. 如果 fromPresent 等于 true, 那么
      1. fromVal = Get(OfromKey)。
      2. 执行 Set(OtoKeyfromValtrue)。
    5. 否则 fromPresent 等于 false
      1. 执行 DeletePropertyOrThrow(OtoKey)。
    6. from = from + direction
    7. to = to + direction
    8. count = count - 1。
  13. 返回 O

注释 2

copyWithin 函数是一个特有的通用的; 它不要求this的值是一个数组构造函数。 因此它可以被其他任何构造函数通过以单个数字参数调用来转变或者继承。

22.1.3.4Array.prototype.entries ( )#

步骤如下:

  1. O = ToObject(this value)。
  2. 返回 CreateArrayIterator(O"key+value")。

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

注释 1

callbackfn 应该是一个函数,这个函数接收三个参数返回一个变化的Boolean值(true 或者 false)。every 方法以上升的顺序展现数组中的每个元素并在展示的时候调用一次callbackfn方法,直到它发现其中一个元素的callbackfn 返回了 false。 如果这个元素被发现,every 直接返回 false。否则, 如果所有元素的 callbackfn 返回 trueevery 将会返回 truecallbackfn 仅在数组元素真实存在时调用,数组元素丢失则不会调用。

如果提供了 thisArg 参数, 它被用作每个 callbackfn 调用的 this值。如果没提供,就用 undefined 来代替。

callbackfn有三个参数:元素的值, 元素的索引, 和被遍历的对象。

every 不改变调用者对象,但是对象会被 callbackfn 的调用改变。

every 是在第一次调用 callbackfn 的时候处理元素的范围。在调用 every 后再被添加到数组里的元素是不会被 callbackfn 访问。如果已经存在的元素被改变,传递给 callbackfn 的值是时 every 访问它的时候的值。在 every 调用之后访问开始和之前被删除的元素不会被访问。在数学运算中 every 表现的像 "for all"。特别的,对于空的数组,它返回 true

every 以一个或两个参数调用时,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(? Get(O"length"))。
  3. 如果 IsCallable(callbackfn) 等于 false, 抛出TypeError异常。
  4. 如果提供了 thisArg 参数, 让 T = thisArg; 否则 让 T = undefined
  5. k = 0。
  6. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kPresent = HasProperty(OPk)。
    3. 如果 kPresent 等于 true, 那么
      1. kValue = Get(OPk)。
      2. testResult = ToBoolean(Call(callbackfnT, « kValuekO »))。
      3. 如果 testResult 等于 false, 返回 false
    4. k 加 1。
  7. 返回 true

注释 2

every 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

22.1.3.6Array.prototype.fill (value [ , start [ , end ] ] )#

fill 有三个参数 valuestart and end

注释 1

startend 参数是可选的并且有默认值是0和 this 对象的长度。如果 start 为负, 它被看作是length+startlength表示的是数组的长度。如果 end 为负,它被看作是 length+end

步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(? Get(O"length"))。
  3. relativeStart = ToInteger(start)。
  4. 如果 relativeStart < 0, 让 k = max((len + relativeStart), 0); 否则 让 k = min(relativeStartlen)。
  5. 如果 end 等于 undefined, 让 relativeEnd = len; 否则 让 relativeEnd = ToInteger(end)。
  6. 如果 relativeEnd < 0, 让 final = max((len + relativeEnd), 0); 否则 让 final = min(relativeEndlen)。
  7. 重复, 当 k < final
    1. Pk = ToString(k)。
    2. 执行 Set(OPkvaluetrue)。
    3. k 加 1。
  8. 返回 O

注释 2

fill 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

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

注释 1

callbackfn 应该是一个函数,这个函数接收3个参数返回一个变化的Boolean值(true 或者 false)。filter 以上升的顺序遍历数组中的每个元素,为每个元素调用一次 callbackfn,并且创建一个新的数组存放每个 callbackfn 返回 true的元素的值。callbackfn 只在元素真实存在的时候调用;不会在数组元素丢失时调用。

如果提供了 thisArg 参数,它会在每次 callbackfn 调用时被用作 this 的值。如果没有提供,就用 undefined 来代替。

callbackfn 有三个参数: 元素的值, 元素的索引, 被遍历的对象。

filter 不直接改变调用的对象,但是对象可能被 callbackfn 的调用改变。

filter是在第一次调用 callbackfn 的时候处理元素的范围。在调用 filter 后再被添加到数组里的元素是不会被 callbackfn 访问。如果已经存在的元素被改变,传递给 callbackfn 的值是时 filter 访问它的时候的值。在 filter 调用之后访问开始和之前被删除的元素不会被访问。

filter 方法以一个或两个参数调用,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(? Get(O"length"))。
  3. 如果 IsCallable(callbackfn) 等于 false, 抛出TypeError异常。
  4. 如果提供了 thisArg 参数, 让 T = thisArg; 否则 让 T = undefined
  5. A = ArraySpeciesCreate(O, 0)。
  6. k = 0。
  7. to = 0。
  8. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kPresent = HasProperty(OPk)。
    3. 如果 kPresent 等于 true, 那么
      1. kValue = Get(OPk)。
      2. selected = ToBoolean(? Call(callbackfnT, « kValuekO »))。
      3. 如果 selected 等于 true, 那么
        1. 执行 CreateDataPropertyOrThrow(AToString(to), kValue)。
        2. to 加 1。
    4. k 加 1。
  9. 返回 A

注释 2

filter 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

22.1.3.8Array.prototype.find ( predicate [ , thisArg ] )#

find 方法以一个或两个参数调用, predicate and thisArg

注释 1

predicate 应该是一个函数,这个函数接收3个参数返回一个变化的Boolean值(true 或者 false)。 find 以上升的顺序遍历数组中的每个元素,为每个元素调用一次 predicate,知道它发现某个元素的 predicate 返回了 true。这个元素找到了, find 直接返回这个元素的值。否则,返回 undefined

如果提供了 thisArg 参数,它会在每次 predicate 调用时被用作 this 的值。如果没有提供,就用 undefined 来代替。

predicate 有三个参数: 元素的值, 元素的索引, 被遍历的对像。

find 不直接改变调用的对象,但是对象可能被 predicate 的调用改变。

find是在第一次调用 predicate 的时候处理元素的范围。在调用 find 后再被添加到数组里的元素是不会被 predicate 访问。如果已经存在的元素被改变,传递给 predicate 的值是时 filter 访问它的时候的值。在 filter 调用之后访问开始和之前被删除的元素不会被访问。

find 方法调用,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(? Get(O"length"))。
  3. 如果 IsCallable(predicate) 等于 false, 抛出TypeError异常。
  4. 如果 thisArg was supplied, 让 T = thisArg; 否则 让 T = undefined
  5. k = 0。
  6. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kValue = Get(OPk)。
    3. testResult = ToBoolean(? Call(predicateT, « kValuekO »))。
    4. 如果 testResult 等于 true, 返回 kValue
    5. k 加 1。
  7. 返回 undefined

注释 2

find 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

22.1.3.9Array.prototype.findIndex ( predicate [ , thisArg ] )#

注释 1

predicate 应该是一个函数,这个函数接收3个参数返回一个变化的Boolean值(true 或者 false)。findIndex 以上升的顺序遍历数组中的每个元素,为每个元素调用一次 predicate, 直到找到某个元素的 predicate 返回 true。 如果这个元素被找到, findIndex 直接返回元素的索引。否则, findIndex 返回 -1。

如果提供了 thisArg 参数,它会在每次 predicate 调用时被用作 this 的值。如果没有提供,就用 undefined 来代替。

predicate 有三个参数: 元素的值,元素的索引,被遍历的对象。

findIndex 不直接改变调用的对象,但是对象可能被 predicate 的调用改变。

findIndex 是在第一次调用 callbackfn 的时候处理元素的范围。在调用 findIndex 后再被添加到数组里的元素是不会被 callbackfn 访问。如果已经存在的元素被改变,传递给 predicate 的值是时 findIndex 访问它的时候的值。

findIndex 方法以一个或两个参数调用,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(? Get(O"length"))。
  3. 如果 IsCallable(predicate) 等于 false, 抛出TypeError异常。
  4. 如果提供了 thisArg, 让 T = thisArg; 否则 让 T = undefined
  5. k = 0。
  6. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kValue = Get(OPk)。
    3. testResult = ToBoolean(Call(predicateT, « kValuekO »))。
    4. 如果 testResult 等于 true, 返回 k
    5. k 加 1。
  7. 返回 -1。

注释 2

findIndex 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

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

注释 1

callbackfn 应该是一个接收三个参数的函数。forEach 以上升的顺序遍历数组中的每个元素,为每个元素调用一次 callbackfncallbackfn 仅在数组元素真实存在时调用,数组元素丢失时不调用。

如果提供了 thisArg 参数,它会在每次 callbackfn 调用时被用作 this 的值。如果没有提供,就用 undefined 来代替。

callbackfn有三个参数:元素的值,元素的索引,和被遍历的对象。

forEach 不直接改变调用的对象,但是对象可能被 callbackfn 的调用改变。

forEach 方法以一个或两个参数调用时,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. 如果 IsCallable(callbackfn) 等于 false, 抛出TypeError异常。
  4. 如果提供了 thisArg, 让 T = thisArg; 否则 让 T = undefined
  5. k = 0。
  6. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kPresent = HasProperty(OPk)。
    3. 如果 kPresent 等于 true, 那么
      1. kValue = Get(OPk)。
      2. 执行 Call(callbackfnT, « kValuekO »)。
    4. k 加 1。
  7. 返回 undefined

注释 2

forEach 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

22.1.3.11Array.prototype.includes ( searchElement [ , fromIndex ] )#

注释 1

includes以上升的顺序遍历数组中的每个元素 使用 SameValueZero 算法和 searchElement比较,如果找到了某个位置相同, 返回 true; 否则,返回 false

可选的第二个参数 fromIndex 默认值为0 (表示整个数组都会被查找)。如果它大于或等于数组的长度,返回false, 数组也不会被查找。如果为负,它被用作数组最后一个元素偏移 fromIndex。 如果计算所以小于0,整个数组会被查找。

includes 调用时,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. 如果 len 等于 0, 返回 false
  4. n = ToInteger(fromIndex). (如果 fromIndex 等于 undefined,这一步产生的值为0。)
  5. 如果 n ≥ 0, 那么
    1. k = n
  6. 否则 n < 0,
    1. k = len + n
    2. 如果 k < 0, 让 k = 0。
  7. 重复, 当 k < len
    1. elementK = Get(OToString(k))。
    2. 如果 SameValueZero(searchElementelementK) is true, 返回 true
    3. k 加 1。
  8. 返回 false

注释 2

includes 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

注释 3

includes 方法有意分日从两方面来区别于 indexOf 方法。首先,它使用 SameValueZero 算法来代替 Strict Equality Comparison, 以至于可以发现为 NaN 的数组元素。其次, 它不忽略丢失的数组元素,而是把它们看做 undefined

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

注释 1

indexOf 上升的顺序遍历数组中的每个元素使用Strict Equality Comparison算法和 searchElement 对比,如果找到一个或者多个,返回最小的索引;否则返回 -1。

可选的第二个参数 fromIndex 默认值为0 (表示整个数组都会被查找)。如果它大于或等于数组的长度,返回 -1, 数组也不会被查找。如果为负,它被用作数组最后一个元素偏移 fromIndex。 如果计算所以小于0,整个数组会被查找。

indexOf 方法以一个或两个参数调用,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. 如果 len 等于 0, 返回 -1。
  4. n = ToInteger(fromIndex). (如果 fromIndex 等于 undefined, 这一步结果为0)
  5. 如果 nlen, 返回 -1。
  6. 如果 n ≥ 0, 那么
    1. 如果 n 等于 -0, 让 k = +0; 否则 让 k = n
  7. 否则 n < 0,
    1. k = len + n
    2. 如果 k < 0, 让 k = 0。
  8. 重复, 当 k < len
    1. kPresent = HasProperty(OToString(k))。
    2. 如果 kPresent 等于 true, 那么
      1. elementK = Get(OToString(k))。
      2. same = (Strict Equality Comparison) searchElement === elementK
      3. 如果 same 等于 true, 返回 k
    3. k 加 1。
  9. 返回 -1。

注释 2

indexOf 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

22.1.3.13Array.prototype.join (separator)#

注释 1

把数组元素转变成字符串,The elements of the array are converted to Strings,把这些字符串连起来并且用 separator 分隔。如果没有提供 separator,一个逗号会作为分隔符。

join 方法有一个参数, separator, 步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. 如果 separator 等于 undefined, 让 separator = ","
  4. sep = ToString(separator)。
  5. 如果 len 等于 zero, 返回空字符串。
  6. element0 = Get(O"0")。
  7. 如果 element0 等于 undefined 或者 null, 让 R 等于空字符串; 否则, 让 R = ToString(element0)。
  8. k = 1
  9. 重复, 当 k < len
    1. S 等于Rsep 连接后得到的字符串。
    2. element = Get(OToString(k))。
    3. 如果 element 等于 undefined 或者 null, 让 next 等于空字符串; 否则, 让 next = ToString(element)。
    4. R等于 Snext 连接后的字符串。
    5. k 加 1。
  10. 返回 R

注释 2

join 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

22.1.3.14Array.prototype.keys ( )#

步骤如下:

  1. O = ToObject(this)。
  2. 返回 CreateArrayIterator(O"key")。

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

注释 1

lastIndexOf 以下降的方式遍历数组元素用 Strict Equality Comparison 算法和 searchElement 比较,如果找到一个或多个相同的,返回找到的最大的索引;否则,返回 -1。

可选的第二个参数 fromIndex 默认值为数组长度减一(表示查找整个数组)。如果它大于或等于数组长度,会查找整个数组。如果为负 If it is greater than or equal to the length of the array, the whole array will be searched. If it is negative,它被用作从数组的末尾到计算 fromIndex 的偏移量。如果计算索引小于0,返回 -1。

lastIndexOf 方法以一个或两个参数调用,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. 如果 len 等于 0, 返回 -1。
  4. 如果传递了 fromIndex 参数, 让 n = ToInteger(fromIndex); 否则 让 n = len-1。
  5. 如果 n ≥ 0, 那么
    1. 如果 n 等于 -0, 让 k = +0; 否则 让 k = min(nlen - 1)。
  6. 否则 n < 0,
    1. k = len + n
  7. 重复, 当 k ≥ 0
    1. kPresent = HasProperty(OToString(k))。
    2. 如果 kPresent 等于 true, 那么
      1. elementK = Get(OToString(k))。
      2. same = (Strict Equality Comparison) searchElement === elementK
      3. 如果 same 等于 true, 返回 k
    3. Decrease k 加 1。
  8. 返回 -1。

注释 2

lastIndexOf 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

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

注释 1

callbackfn 应该是一个接收三个参数的函数。 map 以上升的顺序遍历数组中的每个元素,每个元素调用一次 callbackfn 并且从结果构建一个新数组。callbackfn 只在数组元素真实存在的时候调用; 数组元素丢失则不会调用。

如果提供了 thisArg 参数,它会在每次 callbackfn 调用时被用作 this 的值。如果没有提供,就用 undefined 来代替。

callbackfn 有三个参数:元素的值,元素的索引,和被遍历的对象。

map 不直接改变调用的对象,但是对象可能被 callbackfn 的调用改变。

map 是在第一次调用 callbackfn 的时候处理元素的范围。在调用 map 后再被添加到数组里的元素是不会被 callbackfn 访问。如果已经存在的元素被改变,传递给 callbackfn 的值是时 map 访问它的时候的值。在 map 调用之后访问开始和之前被删除的元素不会被访问。

map 方法以一个或两个两个参数调用,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. 如果 IsCallable(callbackfn) 等于 false, 抛出TypeError异常。
  4. 如果提供了 thisArg , 让 T = thisArg; 否则 让 T = undefined
  5. A = ArraySpeciesCreate(Olen)。
  6. k = 0。
  7. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kPresent = HasProperty(OPk)。
    3. 如果 kPresent 等于 true, 那么
      1. kValue = Get(OPk)。
      2. mappedValue = Call(callbackfnT, « kValuekO »)。
      3. 执行 CreateDataPropertyOrThrow(APkmappedValue)。
    4. k 加 1。
  8. 返回 A

注释 2

map 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

22.1.3.17Array.prototype.pop ( )#

注释 1

移除数组的最后一个元素并且返回移除的这个元素。

pop 方法调用时,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. 如果 len 等于 zero, 那么
    1. 执行 Set(O"length", 0, true)。
    2. 返回 undefined
  4. 否则 len > 0,
    1. newLen = len-1。
    2. indx = ToString(newLen)。
    3. element = Get(Oindx)。
    4. 执行 DeletePropertyOrThrow(Oindx)。
    5. 执行 Set(O"length"newLentrue)。
    6. 返回 element

注释 2

pop 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

22.1.3.18Array.prototype.push ( ...items )#

注释 1

把参数出现的顺序追加到数组的最后。数组的新长度作为函数调用的结果返回。

push 方法以0个或多个参数调用时,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. items 等于一个 List,它的元素是函数调用时传递的参数从左到右排列。
  4. argCount 等于 items 元素的个数。
  5. 如果 len + argCount > 253-1, 抛出TypeError异常。
  6. 重复, 当 items 不为空
    1. 移除 items 的第一个元素并且 E 等于移除的这个元素。
    2. 执行 Set(OToString(len), Etrue)。
    3. len = len+1。
  7. 执行 Set(O"length"lentrue)。
  8. 返回 len

push 方法的 length 属性为 1。

注释 2

push 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

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

注释 1

callbackfn 应该是一个接收4个参数的函数。reduce 以上升的顺序遍历数组中的每个元素并且调用回调函数。

callbackfn 有4个参数: previousValue (上一次调用 callbackfn 返回的值), currentValue (当前元素的值), the currentIndex, 和被遍历的数组。 第一次调用回调的时候, previousValuecurrentValue 的值有两种情况。如果调用 reduce 时提供了一个 initialValue, 那么 previousValue 等于 initialValuecurrentValue 等于数组的第一个元素。如果没有提供 initialValue, 那么 previousValue 等于数组的第一个元素, currentValue等于第二个元素。如果数组没有元素也没有提供 initialValue 会抛出 TypeError 异常。

reduce 不直接改变调用的对象,但是对象可能被 callbackfn 的调用改变。

reduce是在第一次调用 callbackfn 的时候处理元素的范围。在调用 reduce 后再被添加到数组里的元素是不会被 callbackfn 访问。如果已经存在的元素被改变,传递给 callbackfn 的值是时 reduce 访问它的时候的值。在 reduce 调用之后访问开始和之前被删除的元素不会被访问。

reduce 方法以一个或两个参数调用,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. 如果 IsCallable(callbackfn) 等于 false, 抛出TypeError异常。
  4. 如果 len 等于 0 并且没有 initialValue, 抛出TypeError异常。
  5. k = 0。
  6. 如果出现 initialValue, 那么
    1. accumulator = initialValue
  7. 否则没有 initialValue
    1. kPresent = false
    2. 重复, 当 kPresent 等于 false 并且 k < len
      1. Pk = ToString(k)。
      2. kPresent = HasProperty(OPk)。
      3. 如果 kPresent 等于 true, 那么
        1. accumulator = Get(OPk)。
      4. k 加 1。
    3. 如果 kPresent 等于 false, 抛出TypeError异常。
  8. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kPresent = HasProperty(OPk)。
    3. 如果 kPresent 等于 true, 那么
      1. kValue = Get(OPk)。
      2. accumulator = Call(callbackfnundefined, « accumulatorkValuekO »)。
    4. k 加 1。
  9. 返回 accumulator

注释 2

reduce 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

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

注释 1

callbackfn 应该是接收4个参数的函数reduceRight 以降序遍历数组的每个元素并调用回调函数。

callbackfn 有四个参数: previousValue (上一次调用 callbackfn 的值), currentValue (当前元素的值), the currentIndex,和被遍历的元素。函数第一次调用时,previousValuecurrentValue有两种情况。如果调用 reduceRight 时提供了 initialValue , 那么 previousValue 等于 initialValuecurrentValue 等于数组的最后一个元素。如果没有提供 initialValue, 那么 previousValue 等于数组的最后一个元素,currentValue 等于倒数第二个。如果数组没有元素也没有提供 initialValue 会抛出 TypeError 异常。

reduceRight 不直接改变调用的对象,但是对象可能被 callbackfn 的调用改变。

reduceRight是在第一次调用 callbackfn 的时候处理元素的范围。在调用 reduceRight 后再被添加到数组里的元素是不会被 callbackfn 访问。如果已经存在的元素被改变,传递给 callbackfn 的值是时 reduceRight 访问它的时候的值。在 reduceRight 调用之后访问开始和之前被删除的元素不会被访问。

reduceRight 方法以一个或两个参数调用时,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. 如果 IsCallable(callbackfn) 等于 false, 抛出TypeError异常。
  4. 如果 len 等于 0 并且没有 initialValue, 抛出TypeError异常。
  5. k = len-1。
  6. 如果出现了 initialValue, 那么
    1. accumulator = initialValue
  7. 否则没有出现 initialValue
    1. kPresent = false
    2. 重复, 当 kPresent 等于 false 并且 k ≥ 0
      1. Pk = ToString(k)。
      2. kPresent = HasProperty(OPk)。
      3. 如果 kPresent 等于 true, 那么
        1. accumulator = Get(OPk)。
      4. k 减 1。
    3. 如果 kPresent 等于 false, 抛出TypeError异常。
  8. 重复, 当 k ≥ 0
    1. Pk = ToString(k)。
    2. kPresent = HasProperty(OPk)。
    3. 如果 kPresent 等于 true, 那么
      1. kValue = Get(OPk)。
      2. accumulator = Call(callbackfnundefined, « accumulatorkValuekO »)。
    4. k 减 1。
  9. 返回 accumulator

注释 2

reduceRight 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

22.1.3.21Array.prototype.reverse ( )#

注释 1

数组元素按倒序重新排列, 对象作为函数调用的结果返回。

reverse 方法调用时,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. middle = floor(len/2)。
  4. lower = 0。
  5. 重复, 当 lowermiddle
    1. upper = len - lower - 1。
    2. upperP = ToString(upper)。
    3. lowerP = ToString(lower)。
    4. lowerExists = HasProperty(OlowerP)。
    5. 如果 lowerExists 等于 true, 那么
      1. lowerValue = Get(OlowerP)。
    6. upperExists = HasProperty(OupperP)。
    7. 如果 upperExists 等于 true, 那么
      1. upperValue = Get(OupperP)。
    8. 如果 lowerExists 等于 true 并且 upperExists 等于 true, 那么
      1. 执行 Set(OlowerPupperValuetrue)。
      2. 执行 Set(OupperPlowerValuetrue)。
    9. 否则,如果 lowerExists 等于 false 并且 upperExists 等于 true, 那么
      1. 执行 Set(OlowerPupperValuetrue)。
      2. 执行 DeletePropertyOrThrow(OupperP)。
    10. 否则,如果 lowerExists 等于 true 并且 upperExists 等于 false, 那么
      1. 执行 DeletePropertyOrThrow(OlowerP)。
      2. 执行 Set(OupperPlowerValuetrue)。
    11. 否则,如果lowerExistsupperExists 同为 false
      1. 不需要任何操作。
    12. lower 加 1。
  6. 返回 O

注释 2

reverse 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

22.1.3.22Array.prototype.shift ( )#

注释 1

移除数组的第一个元素并且返回移除的这个元素。

shift 方法调用时,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. 如果 len 等于 zero, 那么
    1. 执行 Set(O"length", 0, true)。
    2. 返回 undefined
  4. first = Get(O"0")。
  5. k = 1。
  6. 重复, 当 k < len
    1. from = ToString(k)。
    2. to = ToString(k-1)。
    3. fromPresent = HasProperty(Ofrom)。
    4. 如果 fromPresent 等于 true, 那么
      1. fromVal = Get(Ofrom)。
      2. 执行 Set(OtofromValtrue)。
    5. 否则 fromPresent 等于 false
      1. 执行 DeletePropertyOrThrow(Oto)。
    6. k 加 1。
  7. 执行 DeletePropertyOrThrow(OToString(len-1))。
  8. 执行 Set(O"length"len-1, true)。
  9. 返回 first

注释 2

shift 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以转变为一个其他种类的对象来作为方法来使用。

22.1.3.23Array.prototype.slice (startend)#

注释 1

slice 方法有两个参数, startend,并且返回一个包含从 start (但不包括)到 end (或者到数组的最后一个元素,如果 end 等于 undefined). 如果 start 为负, 它被认为是 length(数组的长度)+start。 如果 end 为负, 它被认为是 length(数组的长度)+end

步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength( Get(O"length"))。
  3. relativeStart = ToInteger(start)。
  4. 如果 relativeStart < 0, 让 k = max((len + relativeStart), 0); 否则, 让 k = min(relativeStartlen)。
  5. 如果 end 等于 undefined, 让 relativeEnd = len; 否则 让 relativeEnd = ToInteger(end)。
  6. 如果 relativeEnd < 0, 让 final = max((len + relativeEnd), 0); 否则 让 final = min(relativeEndlen)。
  7. count = max(final - k, 0)。
  8. A = ArraySpeciesCreate(Ocount)。
  9. n = 0。
  10. 重复, 当 k < final
    1. Pk = ToString(k)。
    2. kPresent = HasProperty(OPk)。
    3. 如果 kPresent 等于 true, 那么
      1. kValue = Get(OPk)。
      2. 执行 CreateDataPropertyOrThrow(AToString(n), kValue)。
    4. k 加 1。
    5. n 加 1。
  11. 执行 Set(A"length"ntrue)。
  12. 返回 A

注释 2

在第11步的时候明确设置结果数组的length属性在以前的ECMAScript版本中是有必要的, 在结果数组的后面元素没有出现的情况下保证它的长度是正确的。从ES2015开始设置长度是没有必要的,结果数组是用本身的长度来初始化的而不是一个空数组,但是这是保持向后兼容性的。

注释 3

slice 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

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

注释 1

callbackfn 应该是一个函数,这个函数接收3个参数返回一个变化的Boolean值(true 或者 false)。 some 以上升的顺序遍历数组中的每个元素,为每个元素调用一次 callbackfn,直到找到某个元素的 callbackfn 返回了 true。如果这样的元素被找到,some 直接返回 true。否则, some 返回 falsecallbackfn 只在元素真实存在的时候调用;不会在数组元素丢失时调用。

如果提供了 thisArg 参数,它会在每次 callbackfn 调用时被用作 this 的值。如果没有提供,就用 undefined 来代替。

callbackfn 有三个参数:元素的值,元素的索引,和被遍历的对象。

some不直接改变调用的对象,但是对象可能被 callbackfn 的调用改变。

some是在第一次调用 callbackfn 的时候处理元素的范围。在调用 some 后再被添加到数组里的元素是不会被 callbackfn 访问。如果已经存在的元素被改变,传递给 callbackfn 的值是时 some 访问它的时候的值。在 some 调用之后访问开始和之前被删除的元素不会被访问。some表现的像数学计算中的“存在”。特殊的,对于空数组,返回false

some 方法以一个或两个参数调用时,步骤如下:

  1. O = ToObject(this value)。
  2. len = ToLength(Get(O"length"))。
  3. 如果 IsCallable(callbackfn) 等于 false, 抛出TypeError异常。
  4. 如果提供了 thisArg, 让 T = thisArg; 否则 让 T = undefined
  5. k = 0。
  6. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kPresent = HasProperty(OPk)。
    3. 如果 kPresent 等于 true, 那么
      1. kValue = Get(OPk)。
      2. testResult = ToBoolean(Call(callbackfnT, « kValuekO »))。
      3. 如果 testResult 等于 true, 返回 true
    4. k 加 1。
  7. 返回 false

注释 2

some 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

22.1.3.25Array.prototype.sort (comparefn)#

数组的元素会被排序。顺序不一定是稳定的(意味着,比较起来相等的元素不一定停留在最初的位置)。如果 comparefn 不等于 undefined, 那么它应该是一个函数,这个函数接收两个参数xy,如果x 小于 y 返回一个负值, 如果 x 等于 y 返回0, 如果 x 大于 y返回一个正值。

如上发生,初始化sort函数调用值的步骤如下:

  1. obj = ToObject(this)。
  2. len = ToLength(Get(obj"length"))。

sort方法的详述里, 对象obj, 被认为是 稀疏的 如果以下算法返回 true:

  1. 对于0≤i< len范围里的每个整数i
    1. elem = obj.[GetOwnProperty](i ))。
    2. 如果 elem 等于 undefined, 返回 true
  2. 返回 false

obj的整数索引属性值的排列顺序被固定在这个方法结束后,obj 的整数索引值的个数是小于 len的。sort 函数的结果取决于以下固定的步骤:

如果 comparefn 不等于 undefined,并且不是一个对于数组元素一致的比较函数(看下面),排列顺序是实现定义的。如果 comparefn 等于 undefined,并且SortCompare不是一个一致的比较函数,排列顺序也是实现定义的。

proto = obj.[GetPrototypeOf]. 如果 proto 不等于 null 并且 存在一个整数j满足下面所有的条件,那么排列顺序是实现定义的:

如果 obj 是稀疏的并且满足以下条件任何一个,排列顺序是实现定义的:

  • IsExtensible(obj) 等于 false
  • obj任何一个名字是一个小于len的非负整数的整数索引属性的[[Configurable]]特性是 false

如果满足以下任何一个条件,排列顺序是实现定义的:

  • 如果 obj 是一个外来对象 (包括代理外来对象), 这些对象的[[Get]], [[Set]], [[Delete]] 和 [[GetOwnProperty]] 的行为不同与普通对象的这些方法的实现。
  • 如果obj任何一个名字是一个小于len的非负整数的索引属性的[[Writable]]特性是 false
  • 如果 comparefn 等于 undefined,并且ToString对于任何传递给SortCompare作为参数的值的应用修改了obj或者任何obj 的属性链。
  • 如果 comparefn 等于 undefined 并且所有ToString对于任何传递给SortCompare作为参数的值,不产生同样的结果。

步骤如下:

  1. 执行一个与执行相关的对obj的内部方法[[Get]]和[[Set]]的调用顺序,对于DeletePropertyOrThrowHasOwnProperty抽象操作用 obj 作为第一个参数,对于 SortCompare (描述如下),这样:
    • 属性键属性对于每次[[Get]]和[[Set]]的调用, HasOwnProperty, 或者 DeletePropertyOrThrow是一个小于len的非负整数的字符串表示形式。
    • 调用SortCompare的参数是先前对[[Get]]内部方法的调用返回的值,除非根据HasOwnProperty不存在由这些先前调用访问的属性。如果SortCompare的透视参数对应于不存在的属性,则使用+ 0不调用SortCompare。如果只有第一个透视参数不存在,则使用+1。如果只有第二个透视参数不存在使用-1。
    • 如果 obj 不是稀疏的, 那么一定不能调用 DeletePropertyOrThrow 方法。
    • 如果任何一个[[Set]]调用返回false,会抛出TypeError异常。
    • 如果这些操作中任何一个返回了abrupt completion, 它会立即作为函数的返回值返回。
  2. 返回 obj

除非上面指定的排序顺序为实现定义,返回对象必须具有以下两个特性:

  • 必须有非负整数的一些数学排列π比len少,这样,对于每一个非负整数j大于len少,如果属性old[j]存在, 那么new[π(j)]的值和old[j]一样。但是如果属性old[j]不存在, 那么 new[π(j)]也不存在。
  • 那么对于任何小于len的所有的非负整数jk, 如果 SortCompare(old[j], old[k]) < 0 (看SortCompare =low), 那么 new[π(j)] < new[π(k)]

这里的符号old[j]是用来指向一个假设的结果,这个结果是执行函数时以j为参数调用obj的内部方法[[Get]]返回的;符号new[j]是用来指向一个假设的结果,这个结果是执行函数后以j为参数调用obj的内部方法[[Get]]返回的。

comparefn是一个稳定的比较函数, 对于值集S, 如果以下所有的需求对于值集S里所有的值abc (可能相同) 都满足: 符号a<CFb意味着comparefn(ab) < 0a等于CFb意味着comparefn(ab)等于0 (无论是标志); a>CFb意味着comparefn(ab) > 0

  • 如果给定明确的一对值ab作为参数调用comparefn(ab)始终返回同样的值v。此外, Type(v)是Number类型, 并且v不是NaN。这样就能确切的知道给定的aba <CF ba =CF ba >CF b中的哪一种。
  • 调用comparefn(ab)不会修改obj的属性或者任何obj原型链上的对象。
  • a =CFa (取反)
  • 如果 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)

注释 1

以上是确定comparefn去划分值集S为等价类并且等价类是全序的充分必要条件。

注释 2

sort函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

22.1.3.25.1执行期语意学: SortCompare( xy )#

SortCompare是一个抽象操作,以xy两个参数调用。它也有获取sort方法传给当前comparefn调用的参数的权限。步骤如下:

  1. 如果 xy都为undefined, 返回 +0
  2. 如果 x 等于 undefined, 返回 1。
  3. 如果 y 等于 undefined, 返回 -1。
  4. 如果参数comparefn不为undefined, 那么
    1. v = ToNumber(Call(comparefnundefined, « xy »))。
    2. 如果 v 等于 NaN, 返回 +0
    3. 返回 v
  5. xString = ToString(x)。
  6. yString = ToString(y)。
  7. xSmaller等于执行摘要关系比较 xString < yString的结果。
  8. 如果 xSmaller 等于 true, 返回 -1。
  9. ySmaller 等于执行摘要关系比较 yString < xString的结果。
  10. 如果 ySmaller 等于 true, 返回 1。
  11. 返回 +0

注释 1

因为不存在的属性值总是大于为undefined的属性值,undefined总是大于其他值,undefined总是在结果的末尾,然后是不存在的属性值。

注释 2

方法执行到第5和7步的抽象操作ToString,可能会导致SortCompare不表现成一个稳定的比较函数。

22.1.3.26Array.prototype.splice (startdeleteCount, ...items )#

注释 1

splice函数以两个或多个参数调用,startdeleteCount和一个或多个items,从数组的start下标开始的deleteCount个数组元素会被参数中的items替换。返回一个包含被删除元素(如果有)的数组。

步骤如下:

  1. O = ToObject(this)。
  2. len = ToLength(Get(O"length"))。
  3. relativeStart = ToInteger(start)。
  4. 如果 relativeStart < 0, 让 actualStart = max((len + relativeStart), 0); 否则 让 actualStart = min(relativeStartlen)。
  5. 如果真实参数个数为0, 那么
    1. insertCount = 0。
    2. actualDeleteCount = 0。
  6. 否则,如果真实参数个数为1, 那么
    1. insertCount = 0。
    2. actualDeleteCount = len - actualStart
  7. 否则,
    1. insertCount等于真实参数个数减2。
    2. dc = ToInteger(deleteCount)。
    3. actualDeleteCount = min(max(dc, 0), len - actualStart)。
  8. 如果 len+insertCount-actualDeleteCount > 253-1, 抛出TypeError异常。
  9. A = ArraySpeciesCreate(OactualDeleteCount)。
  10. k = 0。
  11. 重复, 当 k < actualDeleteCount
    1. from = ToString(actualStart+k)。
    2. fromPresent = HasProperty(Ofrom)。
    3. 如果 fromPresent 等于 true, 那么
      1. fromValue = Get(Ofrom)。
      2. 执行 CreateDataPropertyOrThrow(AToString(k), fromValue)。
    4. k 加 1。
  12. 执行 Set(A"length"actualDeleteCounttrue)。
  13. items为一个列表,元素为真实参数从左到右第三个起的所有元素。如果传递的真实参数少于3个,这个列表为空。
  14. itemCount = the number of elements in items
  15. 如果 itemCount < actualDeleteCount, 那么
    1. k = actualStart
    2. 重复, 当 k < (len - actualDeleteCount)
      1. from = ToString(k+actualDeleteCount)。
      2. to = ToString(k+itemCount)。
      3. fromPresent = HasProperty(Ofrom)。
      4. 如果 fromPresent 等于 true, 那么
        1. fromValue = Get(Ofrom)。
        2. 执行 Set(OtofromValuetrue)。
      5. 否则 fromPresent 等于 false
        1. 执行 DeletePropertyOrThrow(Oto)。
      6. k 加 1。
    3. k = len
    4. 重复, 当 k > (len - actualDeleteCount + itemCount)
      1. 执行 DeletePropertyOrThrow(OToString(k-1))。
      2. k 减 1。
  16. 否则 如果 itemCount > actualDeleteCount, 那么
    1. k = (len - actualDeleteCount)。
    2. 重复, 当 k > actualStart
      1. from = ToString(k + actualDeleteCount - 1)。
      2. to = ToString(k + itemCount - 1)。
      3. fromPresent = HasProperty(Ofrom)。
      4. 如果 fromPresent 等于 true, 那么
        1. fromValue = Get(Ofrom)。
        2. 执行 Set(OtofromValuetrue)。
      5. 否则 fromPresent 等于 false
        1. 执行 DeletePropertyOrThrow(Oto)。
      6. k 减 1。
  17. k = actualStart
  18. 重复, 当 items 不为空
    1. 删除items的第一个元素并且让 E等于这个元素的值。
    2. 执行 Set(OToString(k), Etrue)。
    3. k 加 1。
  19. 执行 Set(O"length"len - actualDeleteCount + itemCounttrue)。
  20. 返回 A

注释 2

在第19步中明确的设置结果数组的length属性在以前的ECMAScript版本中是有必要的,用来确保length属性是正确的当结果数组的随后的元素没有出现。设置length属性从ES2015开始不是必要的了,因为结果数组是用本身的长度来初始化的,而不是空数组。设置它是为了保持向后兼容性。

注释 3

splice函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

22.1.3.27Array.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )#

是一个包括ecma-402国际化API的ECMAScript实现,必须实现如ECMA-402规范申明的Array.prototype.toLocaleString方法。如果一个ECMAScript实现没有包括ECMA-402国际化API,会使用以下申明的toLocaleString方法。

注释 1

ecma-402第一版没有一个替代Array.prototype.toLocaleString 方法的申明。

这个方法的可选参数的含义定义在ECMA-402规范中; 不支持ECMA-402的实现不能使用别的位置的参数。

步骤如下:

  1. array = ToObject(this)。
  2. len = ToLength(Get(array"length"))。
  3. separator 等于适合于宿主环境的当前区域设置的列表分隔符字符串的字符串值(这是在实现定义的方式)。
  4. 如果 len 等于 zero, 返回空字符串。
  5. firstElement = Get(array"0")。
  6. 如果 firstElement 等于 undefined 或者 null, 那么
    1. R 等于空字符串。
  7. 否则,
    1. R = ToString(Invoke(firstElement"toLocaleString"))。
  8. k = 1
  9. 重复, 当 k < len
    1. S 等于 Rseparator 连接后的字符串。
    2. nextElement = Get(arrayToString(k))。
    3. 如果 nextElement 等于 undefined 或者 null, 那么
      1. R 等于空字符串。
    4. 否则,
      1. R = ToString(Invoke(nextElement"toLocaleString"))。
    5. R 等于 SR 连接后的字符串。
    6. k 加 1。
  10. 返回 R

注释 2

数组元素是用toLocaleString方法传递给字符串的,这些字符串是如此的连接,由已定义的区域设置特定方法中派生的分隔符字符串的分隔而分离的。调用这个函数的结果是类似于 toString的结果,除了这个函数的结果是特定场所。

注释 3

toLocaleString 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

22.1.3.28Array.prototype.toString ( )#

toString 方法的调用步骤如下:

  1. array = ToObject(this)。
  2. func = Get(array"join")。
  3. 如果 IsCallable(func) 为 false, 让 func 等于固有方法 %ObjProto_toString%
  4. 返回 Call(funcarray)。

注释

toString 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

22.1.3.29Array.prototype.unshift ( ...items )#

注释 1

参数添加到数组的开始,他们在数组的顺序和参数列表的顺序一致。

unshift 方法以一个或多个参数调用, item1item2等等,步骤如下:

  1. O = ToObject(this)。
  2. len = ToLength(Get(O"length"))。
  3. argCount 等于真实参数的个数。
  4. 如果 argCount > 0, 那么
    1. 如果 len+argCount > 253-1, 抛出TypeError异常。
    2. k = len
    3. 重复, 当 k > 0,
      1. from = ToString(k-1)。
      2. to = ToString(k+argCount-1)。
      3. fromPresent = HasProperty(Ofrom)。
      4. 如果 fromPresent 等于 true, 那么
        1. fromValue = Get(Ofrom)。
        2. 执行 Set(OtofromValuetrue)。
      5. 否则 fromPresent 等于 false
        1. 执行 DeletePropertyOrThrow(Oto)。
      6. k 减 1。
    4. j = 0。
    5. items 等于函数调用时从左到右的参数组成的 列表
    6. 重复, 当 items 不为空
      1. 移除items的第一个元素并且让 E 等于移除的这个元素。
      2. 执行 Set(OToString(j), Etrue)。
      3. j 加 1。
  5. 执行 Set(O"length"len+argCounttrue)。
  6. 返回 len+argCount

unshift 方法的 length 属性值为1。

注释 2

unshift 函数是特有的通用的; 它不要求this的值是一个数组对象。因此它可以被转变成其他种类的对象来作为一个函数使用。

22.1.3.30Array.prototype.values ( )#

步骤如下:

  1. O = ToObject(this value)。
  2. 返回 CreateArrayIterator(O"value")。

这个函数是固有对象 %ArrayProto_values%

22.1.3.31Array.prototype [ @@iterator ] ( )#

@@iterator属性的初始值和Array.prototype.values属性的初始值是同一个函数对象。

22.1.3.32Array.prototype [ @@unscopables ]#

@@unscopables 数据属性的初始值是通过以下步骤创建的:

  1. blackList = ObjectCreate(null)。
  2. 执行 CreateDataProperty(blackList"copyWithin"true)。
  3. 执行 CreateDataProperty(blackList"entries"true)。
  4. 执行 CreateDataProperty(blackList"fill"true)。
  5. 执行 CreateDataProperty(blackList"find"true)。
  6. 执行 CreateDataProperty(blackList"findIndex"true)。
  7. 执行 CreateDataProperty(blackList"includes"true)。
  8. 执行 CreateDataProperty(blackList"keys"true)。
  9. 执行 CreateDataProperty(blackList"values"true)。
  10. 断言: 以上的每个调用都会返回 true
  11. 返回 blackList

这个特性的属性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

NOTE

这个对象自身的属性名是不包括作为 Array.prototype 的ECMAScript 2015规范之前的属性名。这些名字都被忽略了 with 为语句结合目的保留行为的现有代码,可以使用一个名为外部范围的 with 声明其绑定的对象是一个数组对象阴影的绑定。

22.1.4数组实例的属性#

数组实例是数组外来对象,这个对象有内部方法的申明。数组实例从数组原型对象上继承属性。

数组实例有 length 属性, 和一系列可枚举的数组下标属性。

22.1.4.1length#

数组实例的 length 属性是一个数值属性,它的值在数值上总是大于每一个可配置的数组下标属性名字。

length 属性的初始特性为 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }。

注释

删除的自身数组元素减小 length 属性的值,删除的自身数组元素的下标在新的和旧的长度值之间时会有副作用。然而,不可配置的属性不能被删除。尝试去设置一个数组对象的 length 属性为一个比已存在的不可配置的数组下标中最大的数值属性名字小的值,将会导致length 的值为比那个最大属性名还大的数值。查看9.4.2.1

22.1.5数组的迭代器对象#

数组迭代器是一个对象,这代表了一个明确的重复在明确的数组实例对象上。数组迭代器对象没有具名构造器。替代的是,通过调用数组实例对象上的方法来创建迭代器。

22.1.5.1抽象操作CreateArrayIterator#

有几个数组对象返回数组迭代器。抽象操作CreateArrayIterator以参数arraykind 调用就是用来创建这样一个迭代对象,步骤如下:

  1. 断言: Type(array) 是一个对象。
  2. iterator = ObjectCreate(%ArrayIteratorPrototype%, « [[IteratedObject]], [[ArrayIteratorNextIndex]], [[ArrayIterationKind]] »)。
  3. 设置 iterator 的 [[IteratedObject]] 内部位置为 array
  4. 设置 iterator 的 [[ArrayIteratorNextIndex]] 内部位置为 0。
  5. 设置 iterator 的 [[ArrayIterationKind]] 内部位置为 kind
  6. 返回 iterator

22.1.5.2%ArrayIteratorPrototype%对象#

所有的数组迭代对象从内部对象%ArrayIteratorPrototype%中继承属性。%ArrayIteratorPrototype% 是一个普通的对象,它的 [[Prototype]] 内部位置是固有对象 %IteratorPrototype%。另外, %ArrayIteratorPrototype% 有以下特性:

22.1.5.2.1%ArrayIteratorPrototype%.next( )#

  1. O = this
  2. 如果 Type(O) 不是对象, 抛出TypeError异常。
  3. 如果 O 没有数组迭代器实例的所有内部位置(22.1.5.3), 抛出TypeError异常。
  4. a 等于 O 的内部位置 [[IteratedObject]]。
  5. 如果 a 等于 undefined, 返回 CreateIterResultObject(undefinedtrue)。
  6. index 等于 O 的内部位置[[ArrayIteratorNextIndex]]。
  7. itemKind 等于 O 的内部位置 [[ArrayIterationKind]]。
  8. 如果 a 有内部位置 [[TypedArrayName]], 那么
    1. len 等于 a 的内部位置 [[ArrayLength]]。
  9. 否则,
    1. len = ToLength(Get(a"length"))。
  10. 如果 indexlen, 那么
    1. 设置 O 的内部位置 [[IteratedObject]] 的值为 undefined
    2. 返回 CreateIterResultObject(undefinedtrue)。
  11. 设置 O 的内部位置 [[ArrayIteratorNextIndex]] 的值为 index+1。
  12. 如果 itemKind 等于 "key", 返回 CreateIterResultObject(indexfalse)。
  13. elementKey = ToString(index)。
  14. elementValue = Get(aelementKey)。
  15. 如果 itemKind 等于 "value", 让 result = elementValue
  16. 否则,
    1. 断言: itemKind 等于 "key+value"
    2. result = CreateArrayFromListindexelementValue »)。
  17. 返回 CreateIterResultObject(resultfalse)。

22.1.5.2.2%ArrayIteratorPrototype% [ @@toStringTag ]#

@@toStringTag属性的初始值为字符串"Array Iterator"

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

22.1.5.3数组迭代器实例的属性#

数组迭代器实例是继承固有对象%ArrayIteratorPrototype%属性的普通对象。数组迭代器实例初始化时会创建的内部位置列在Table 49

Table 49: 数组迭代器实例内部位置
| 内部位置 | 描述 | | [[IteratedObject]] | 数组元素被迭代的对象。 | | [[ArrayIteratorNextIndex]] | 当前迭代的下一次被检测的整数下标。 | | [[ArrayIterationKind]] | 标识迭代的每个元素返回的字符串值。可能值是: "key""value""key+value". |

22.2TypedArray对象#

TypedArray 对象提出一个基本的二进制数据缓冲区的类数组视图(24.1)。TypedArray 实例的每个元素有同样的基本二进制标量数据类型。有明确的 TypedArray 构造器,列在 Table 50的9个支持元素种类的每一个。每个构造器 Table 50 都和原型对象有相应的区别。

Table 50: The TypedArray Constructors
| 构造函数名称和本征函数 | 元素种类 | 元素大小 | 转换操作 | 描述 | 等效的C型 | | Int8Array %Int8Array% | Int8 | 1 | ToInt8 | 8位2的补符号整数 | 有符号字符 | | Uint8Array %Uint8Array% | Uint8 | 1 | ToUint8 | 8位无符号整形 | 无符号字符 | | Uint8ClampedArray %Uint8ClampedArray% | Uint8C | 1 | ToUint8Clamp | 8位 无符号整形 (卡转换) | 无符号字符 | | Int16Array %Int16Array% | Int16 | 2 | ToInt16 | 16位2的补符号整数 | short | | Uint16Array %Uint16Array% | Uint16 | 2 | ToUint16 | 16位无符号整形 | 无符号短整型 | | Int32Array %Int32Array% | Int32 | 4 | ToInt32 | 32位2的补符号整数 | 整形 | | Uint32Array %Uint32Array% | Uint32 | 4 | ToUint32 | 32位无符号整形 | 无符号整形 | | Float32Array %Float32Array% | Float32 | 4 | 32位IEEE浮点数 | 单精度浮点数 | | Float64Array %Float64Array% | Float64 | 8 | 64位IEEE浮点数 | 双精度浮点数 |

在下面的定义中,TypedArray的参照应该替换成上表中的构造器函数名。表达式“元素字节大小”指的是对应的构造器的元素大小列的值。表达式 “元素种类”指的是该行的元素种类列。

22.2.1固有对象%TypedArray%#

固有对象%TypedArray%是一个函数构造器对象,所有的 TypedArray 构造器对象继承于%TypedArray%,并且相应的原型对象共有属性被继承于所有的 TypedArray 构造器和它们的实例。固有对象 %TypedArray% 没有全局名字也不会表现的像全局对象的一个属性。

固有函数对象%TypedArray%表现的像多样的TypedArray构造器的抽象父类。因为它是一个抽象类构造器调用的时候会抛出错误。构造器 TypeArray 不会执行一个父类的构造函数。

22.2.1.1%TypedArray%()#

%TypedArray% 构造器有以下步骤:

  1. 抛出TypeError异常。

构造器函数%TypedArray%length 属性值为 0。

22.2.2固有对象%TypedArray%的属性#

%TypedArray% 的内部位置[[Prototype]]的值是固有对象%FunctionPrototype%

构造器函数%TypedArray%name属性的值为 "TypedArray"

构造器%TypedArray% 有以下属性:

22.2.2.1%TypedArray%.from ( source [ , mapfn [ , thisArg ] ] )#

from 方法以参数source和可选参数mapfnthisArg调用时,步骤如下:

  1. C = the this value。
  2. 如果 IsConstructor(C) 等于 false, 抛出TypeError异常。
  3. 如果提供了 mapfn 并且 mapfn 不等于 undefined, 那么
    1. 如果 IsCallable(mapfn) 为 false, 抛出TypeError异常。
    2. mapping = true
  4. 否则, 让 mapping = false
  5. 如果提供了 thisArg, 让 T = thisArg; 否则 让 T = undefined
  6. arrayLike = IterableToArrayLike(source)。
  7. len = ToLength(Get(arrayLike"length"))。
  8. targetObj = TypedArrayCreate(C, « len »)。
  9. k = 0。
  10. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kValue = Get(arrayLikePk)。
    3. 如果 mapping 等于 true, 那么
      1. mappedValue = Call(mapfnT, « kValuek »)。
    4. 否则, 让 mappedValue = kValue
    5. 执行 Set(targetObjPkmappedValuetrue)。
    6. k 加 1。
  11. 返回 targetObj

22.2.2.1.1执行期语意学: IterableToArrayLike( items )#

抽象操作IterableToArrayLike执行步骤如下:

  1. usingIterator = GetMethod(items, @@iterator)。
  2. 如果 usingIterator 不等于 undefined, 那么
    1. iterator = GetIterator(itemsusingIterator)。
    2. values 等于一个空 列表
    3. next = true
    4. 重复, 当 next 不等于 false
      1. next = IteratorStep(iterator)。
      2. 如果 next 不等于 false, 那么
        1. nextValue = IteratorValue(next)。
        2. nextValue 追加到 列表值得最后。
    5. 返回 CreateArrayFromList(values)。
  3. 注释: items 不是一个迭代器因此假设它已经是一个类数组。
  4. 返回 ToObject(items)。

22.2.2.2%TypedArray%.of ( ...items )#

of方法以任何个数的参数调用,步骤如下:

  1. len 等于传递给函数的实际参数的个数。
  2. items 等于传给函数的参数 列表
  3. C = this
  4. 如果 IsConstructor(C) 为 false, 抛出TypeError异常。
  5. newObj = TypedArrayCreate(C, « len »)。
  6. k = 0。
  7. 重复, 当 k < len
    1. kValue = items[k]。
    2. Pk = ToString(k)。
    3. 执行 Set(newObjPkkValuetrue)。
    4. k 加 1。
  8. 返回 newObj

注释

items 参数假设是结构良好的静止的参数值。

22.2.2.3%TypedArray%.prototype#

%TypedArray%.prototype 的初始值是固有对象%TypedArrayPrototype%

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

22.2.2.4get %TypedArray% [ @@species ]#

%TypedArray%[@@species] 是访问属性,它的设置属性是undefined。它的访问属性步骤如下:

  1. 返回this值。

这个函数的 name 属性为 "get [Symbol.species]"

注释

%TypedArrayPrototype% 方法正常的使用this对象的构造函数去创建一个衍生对象。然而,子类构造器可能通过重定义@@species属性来重载这个默认行为。

22.2.3%TypedArrayPrototype%对象的属性#

%TypedArrayPrototype%对象的内部位置[[Prototype]]的值为固有对象%ObjectPrototype%。%TypedArrayPrototype% 对象是一个普通对象。它不会有[[ViewedArrayBuffer]]或者其他的内部位置申明在TypedArray实例对象上。

22.2.3.1获取%TypedArray%.prototype.buffer#

%TypedArray%.prototype.buffer是访问函数,他的设置函数是undefined。它的获取函数步骤如下:

  1. O = this
  2. 如果 Type(O) 不是一个对象, 抛出TypeError异常。
  3. 如果 O 没有内部位置 [[ViewedArrayBuffer]], 抛出TypeError异常。
  4. buffer等于O 的内部位置[[ViewedArrayBuffer]]。
  5. 返回 buffer

22.2.3.2获取%TypedArray%.prototype.byteLength#

%TypedArray%.prototype.byteLength是访问函数,他的设置函数是undefined。它的获取函数步骤如下:

  1. O = this
  2. 如果 Type(O) 不是一个对象, 抛出TypeError异常。
  3. 如果 O 没有内部位置[[ViewedArrayBuffer]], 抛出TypeError异常。
  4. buffer等于O 的内部位置 [[ViewedArrayBuffer]]。
  5. 如果 IsDetachedBuffer(buffer) 为 true, 返回 0。
  6. size 等于 O 的内部位置 [[ByteLength]]。
  7. 返回 size

22.2.3.3获取%TypedArray%.prototype.byteOffset#

%TypedArray%.prototype.byteOffset是访问函数,他的设置函数是undefined。它的获取函数步骤如下:

  1. O = this
  2. 如果 Type(O) 不是一个对象, 抛出TypeError异常。
  3. 如果 O没有内部位置 [[ViewedArrayBuffer]], 抛出TypeError异常。
  4. buffer 等于 O 的内部位置 [[ViewedArrayBuffer]]。
  5. 如果 IsDetachedBuffer(buffer) 为 true, 返回 0。
  6. offset 等于 O 的内部位置 [[ByteOffset]]。
  7. 返回 offset

22.2.3.4%TypedArray%.prototype.constructor#

%TypedArray%.prototype.constructor 的初始值是固有对象%TypedArray%

22.2.3.5%TypedArray%.prototype.copyWithin (targetstart [ , end ] )#

%TypedArray%.prototype.copyWithin 是一个固有函数,执行和22.1.3.3定义的Array.prototype.copyWithin同样的算法,除非this对象的内部位置 [[ArrayLength]] 被访问于执行"length"的[[Get]]操作的位置并且在12步中值得真实副本必须以保留源数据的位级编码的方式进行。

这个算法可能被优化,如果知道this的值有固定的长度,并且整数下标属性是不稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变。

这个函数不是一般函数,ValidateTypedArray 在执行算法之前就提供给了this对象。如果结果是一个 突然的结束,会抛出异常而不是执行算法。

22.2.3.5.1执行期语意学: ValidateTypedArray ( O )#

O为参数调用,步骤如下:

  1. 如果 Type(O) 不是一个对象, 抛出TypeError异常。
  2. 如果 O 没有内部位置 [[TypedArrayName]], 抛出TypeError异常。
  3. 如果 O 没有内部位置 [[ViewedArrayBuffer]], 抛出TypeError异常。
  4. buffer 等于 O 的内部位置[[ViewedArrayBuffer]]。
  5. 如果 IsDetachedBuffer(buffer) 为 true, 抛出TypeError异常。
  6. 返回 buffer

22.2.3.6%TypedArray%.prototype.entries ( )#

步骤如下:

  1. O = this
  2. 执行 ValidateTypedArray(O)。
  3. 返回 CreateArrayIterator(O"key+value")。

22.2.3.7%TypedArray%.prototype.every ( callbackfn [ , thisArg ] )#

%TypedArray%.prototype.every 是一个独特的方法,实现了和Array.prototype.every22.1.3.5中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变,并且必须考虑调用callbackfn方法导致this值变得分离的可能。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.8%TypedArray%.prototype.fill (value [ , start [ , end ] ] )#

%TypedArray%.prototype.fill 是一个独特的方法,实现了和Array.prototype.fill22.1.3.6中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。 这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.9%TypedArray%.prototype.filter ( callbackfn [ , thisArg ] )#

%TypedArray%.prototype.filter的解释和所用的参数和Array.prototype.filter22.1.3.7中定义的是一样的。

filter方法以一个或两个参数参数调用,步骤如下:

  1. O = this
  2. 执行 ValidateTypedArray(O)。
  3. len 等于 O 的内部位置 [[ArrayLength]] 的值。
  4. 如果 IsCallable(callbackfn) 为 false, 抛出TypeError异常。
  5. 如果提供了 thisArg, 让 T = thisArg; 否则 让 T = undefined
  6. kept 等于新建的空的 列表
  7. k = 0。
  8. captured = 0。
  9. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kValue = Get(OPk)。
    3. selected = ToBoolean(Call(callbackfnT, « kValuekO »))。
    4. 如果 selected 等于 true, 那么
      1. 追加kValuekept的末尾。
      2. captured 加 1。
    5. k 加 1。
  10. A = TypedArraySpeciesCreate(O, « captured »)。
  11. n = 0。
  12. 对于kept的每个元素e
    1. 执行 Set(AToString(n), etrue)。
    2. n 加 1。
  13. 返回 A

这个函数不是一般的函数,this的值必须是一个对象并且有内部位置[[TypedArrayName]]。

22.2.3.10%TypedArray%.prototype.find (predicate [ , thisArg ] )#

%TypedArray%.prototype.find是一个独特的方法,实现了和Array.prototype.find22.1.3.8中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变,并且必须考虑调用predicate方法导致this值变得分离的可能。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.11%TypedArray%.prototype.findIndex ( predicate [ , thisArg ] )#

%TypedArray%.prototype.findIndex是一个独特的方法,实现了和Array.prototype.findIndex22.1.3.9中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变,并且必须考虑调用predicate方法导致this值变得分离的可能。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。 1

22.2.3.12%TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )#

%TypedArray%.prototype.forEach是一个独特的方法,实现了和Array.prototype.forEach22.1.3.10中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变,并且必须考虑调用callbackfn方法导致this值变得分离的可能。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.13%TypedArray%.prototype.indexOf (searchElement [ , fromIndex ] )#

%TypedArray%.prototype.indexOf是一个独特的方法,实现了和Array.prototype.indexOf22.1.3.12中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.14%TypedArray%.prototype.includes ( searchElement [ , fromIndex ] )#

%TypedArray%.prototype.includes是一个独特的方法,实现了和Array.prototype.includes22.1.3.11中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.15%TypedArray%.prototype.join ( separator )#

%TypedArray%.prototype.join是一个独特的方法,实现了和Array.prototype.join22.1.3.13中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.16%TypedArray%.prototype.keys ( )#

步骤如下:

  1. O = this
  2. 执行 ValidateTypedArray(O)。
  3. 返回 CreateArrayIterator(O"key")。

22.2.3.17%TypedArray%.prototype.lastIndexOf ( searchElement [ , fromIndex ] )#

%TypedArray%.prototype.lastIndexOf是一个独特的方法,实现了和Array.prototype.lastIndexOf22.1.3.15中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.18get %TypedArray%.prototype.length#

%TypedArray%.prototype.length是一个获取属性,它的设置属性的方法是undefined。它的获取函数步骤如下:

  1. O = this
  2. 如果 Type(O)不是一个对象, 抛出TypeError异常。
  3. 如果 O 没有内部位置 [[TypedArrayName]],抛出TypeError异常。
  4. 断言: O 内部位置 [[ViewedArrayBuffer]] 和 [[ArrayLength]]。
  5. buffer 等于 O 的内部位置 [[ViewedArrayBuffer]]。
  6. 如果 IsDetachedBuffer(buffer) 为 true, 返回 0。
  7. length 等于 O 的内部位置 [[ArrayLength]]。
  8. 返回 length

这个函数不是一般的函数。this必须是一个对象,并且有内部位置 [[TypedArrayName]]。

22.2.3.19%TypedArray%.prototype.map ( callbackfn [ , thisArg ] )#

%TypedArray%.prototype.map 的解释和参数的使用和Array.prototype.map22.1.3.16中定义的是一样的。

map 方法以一个或两个参数调用时,步骤如下:

  1. O = this
  2. 执行 ValidateTypedArray(O)。
  3. len 等于 O 的内部位置 [[ArrayLength]]。
  4. 如果 IsCallable(callbackfn) 为 false, 抛出TypeError异常。
  5. 如果提供了 thisArg, 让 T = thisArg; 否则 让 T = undefined
  6. A = TypedArraySpeciesCreate(O, « len »)。
  7. k = 0。
  8. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kValue = Get(OPk)。
    3. mappedValue = Call(callbackfnT, « kValuekO »)。
    4. 执行 Set(APkmappedValuetrue)。
    5. k 加 1。
  9. 返回 A

这个函数不是一般的函数。this必须是一个对象,并且有内部位置 [[TypedArrayName]]。

22.2.3.20%TypedArray%.prototype.reduce ( callbackfn [ , initialValue ] )#

%TypedArray%.prototype.reduce是一个独特的方法,实现了和Array.prototype.reduce22.1.3.19中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。 这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变,并且必须考虑调用callbackfn方法导致this值变得分离的可能。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.21%TypedArray%.prototype.reduceRight ( callbackfn [ , initialValue ] )#

%TypedArray%.prototype.reduceRight是一个独特的方法,实现了和Array.prototype.reduceRight22.1.3.20中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变,并且必须考虑调用callbackfn方法导致this值变得分离的可能。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.22%TypedArray%.prototype.reverse ( )#

%TypedArray%.prototype.reverse是一个独特的方法,实现了和Array.prototype.reverse22.1.3.21中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.23%TypedArray%.prototype.set ( overloaded [ , offset ])#

%TypedArray%.prototype.set是一个单函数,基于第一个参数的类型而重载自己的行为。

这个函数不是一般的函数。this必须是一个对象,并且有内部位置 [[TypedArrayName]]。

22.2.3.23.1%TypedArray%.prototype.set (array [ , offset ] )#

TypedArray设置多元值,从对象array读取值。可选参数offset的值标明TypedArray的被写的第一个元素的位置下标。如果省略了,它被假设为0。

  1. 断言: arrayECMAScript语言值中除了有内部位置[[TypedArrayName]]外的其他任何对象。如果是这个一个对象,应用22.2.3.23.2中的定义。
  2. target = this
  3. 如果 Type(target) 不是一个对象, 抛出TypeError异常。
  4. 如果 target 没有内部位置 [[TypedArrayName]], 抛出TypeError异常。
  5. 断言: target 有内部位置 [[ViewedArrayBuffer]]。
  6. targetOffset = ToInteger(offset)。
  7. 如果 targetOffset < 0, 抛出RangeError异常。
  8. targetBuffer 等于 target 的内部位置 [[ViewedArrayBuffer]]。
  9. 如果 IsDetachedBuffer(targetBuffer) 为 true, 抛出TypeError异常。
  10. targetLength 等于 target 的内部位置 [[ArrayLength]]。
  11. targetName 等于target 的内部位置 [[TypedArrayName]] 的字符串值。
  12. targetElementSize 等于在Table 50中声明的targetName的元素大小数值。
  13. targetType 等于在Table 50中声明的targetName的元素类型的字符串值。
  14. targetByteOffset 等于 target 的内部位置 [[ByteOffset]]。
  15. src = ToObject(array)。
  16. srcLength = ToLength(Get(src"length"))。
  17. 如果 srcLength + targetOffset > targetLength, 抛出RangeError异常。
  18. targetByteIndex = targetOffset × targetElementSize + targetByteOffset
  19. k = 0。
  20. limit = targetByteIndex + targetElementSize × srcLength
  21. 重复, 当 targetByteIndex < limit
    1. Pk = ToString(k)。
    2. kNumber = ToNumber(Get(srcPk))。
    3. 如果 IsDetachedBuffer(targetBuffer) 为 true, 抛出TypeError异常。
    4. 执行 SetValueInBuffer(targetBuffertargetByteIndextargetTypekNumber)。
    5. k = k + 1。
    6. targetByteIndex = targetByteIndex + targetElementSize
  22. 返回 undefined

22.2.3.23.2%TypedArray%.prototype.set(typedArray [ , offset ] )#

TypedArray设置多元值,从对象typedArray的参数对象读取值。可选参数offset的值标明TypedArray的被写的第一个元素的位置下标。如果省略了,它被假设为0。

  1. 断言: typedArray 有内部位置 [[TypedArrayName]]。如果没有,应用22.2.3.23.1中的定义。
  2. target = this
  3. 如果 Type(target) 不是一个对象, 抛出TypeError异常。
  4. 如果 target 没有内部位置 [[TypedArrayName]], 抛出TypeError异常。
  5. 断言: target 有内部位置 [[ViewedArrayBuffer]]。
  6. targetOffset = ToInteger(offset)。
  7. 如果 targetOffset < 0, 抛出RangeError异常。
  8. targetBuffer 等于 target 的内部位置 [[ViewedArrayBuffer]]。
  9. 如果 IsDetachedBuffer(targetBuffer) 为 true, 抛出TypeError异常。
  10. targetLength 等于 target 的内部位置 [[ArrayLength]]。
  11. srcBuffer 等于 typedArray 的内部位置 [[ViewedArrayBuffer]]。
  12. 如果 IsDetachedBuffer(srcBuffer) 为 true, 抛出TypeError异常。
  13. targetName 等于 target 的内部位置 [[TypedArrayName]]的字符串值。
  14. targetType 等于在Table 50中定义的targetName的元素类型的字符串值。
  15. targetElementSize 等于在 Table 50 中定义的 targetName的元素大小的数值。
  16. targetByteOffset等于 target 的内部位置 [[ByteOffset]]。
  17. srcName 等于 typedArray 的内部位置 [[TypedArrayName]] 的字符串值。
  18. srcType 等于在 Table 50中定义的srcName的元素类型的字符串值。
  19. srcElementSize 等于在 Table 50 中定义的 srcName 的元素大小的数值。
  20. srcLength 等于 typedArray 的内部位置 [[ArrayLength]]。
  21. srcByteOffset 等于 typedArray 的内部位置 [[ByteOffset]]。
  22. 如果 srcLength + targetOffset > targetLength, 抛出RangeError异常。
  23. 如果 SameValue(srcBuffertargetBuffer) 为 true, 那么
    1. srcBuffer = CloneArrayBuffer(targetBuffersrcByteOffset%ArrayBuffer%)。
    2. 注释: %ArrayBuffer% 是用来克隆 targetBuffer 的,因为它被认为是没有任何显著的副作用的。
    3. srcByteIndex = 0。
  24. 否则, 让 srcByteIndex = srcByteOffset
  25. targetByteIndex = targetOffset × targetElementSize + targetByteOffset
  26. limit = targetByteIndex + targetElementSize × srcLength
  27. 如果 SameValue(srcTypetargetType) 为 false, 那么
    1. 重复, 当 targetByteIndex < limit
      1. value = GetValueFromBuffer(srcBuffersrcByteIndexsrcType)。
      2. 执行 SetValueInBuffer(targetBuffertargetByteIndextargetTypevalue)。
      3. srcByteIndex = srcByteIndex + srcElementSize
      4. targetByteIndex = targetByteIndex + targetElementSize
  28. 否则,
    1. 注释: 如果 srcTypetargetType 相同,必须以保留源数据的位级编码的方式执行转移。
    2. 重复, 当 targetByteIndex < limit
      1. value = GetValueFromBuffer(srcBuffersrcByteIndex"Uint8")。
      2. 执行 SetValueInBuffer(targetBuffertargetByteIndex"Uint8"value)。
      3. srcByteIndex = srcByteIndex + 1。
      4. targetByteIndex = targetByteIndex + 1。
  29. 返回 undefined

22.2.3.24%TypedArray%.prototype.slice ( startend )#

%TypedArray%.prototype.slice的解释和参数的使用和Array.prototype.slice22.1.3.23定义的一样。步骤如下:

  1. O = this
  2. 执行 ValidateTypedArray(O)。
  3. len 等于 O 的内部位置 [[ArrayLength]]。
  4. relativeStart = ToInteger(start)。
  5. 如果 relativeStart < 0, 让 k = max((len + relativeStart), 0); 否则让 k = min(relativeStartlen)。
  6. 如果 end 等于 undefined, 让 relativeEnd = len; 否则让 relativeEnd = ToInteger(end)。
  7. 如果 relativeEnd < 0, 让 final = max((len + relativeEnd), 0); 否则让 final = min(relativeEndlen)。
  8. count = max(final - k, 0)。
  9. A = TypedArraySpeciesCreate(O, « count »)。
  10. srcName 等于 O 的内部位置 [[TypedArrayName]] 的字符串值。
  11. srcType 等于 Table 50 表中的 srcName 的元素类型的字符串值。
  12. targetName 等于 A 的内部位置 [[TypedArrayName]]。
  13. targetType 等于 Table 50 表中的 targetName 的元素类型的字符串值。
  14. 如果 SameValue(srcTypetargetType) 为 false, 那么
    1. n = 0。
    2. 重复, 当 k < final
      1. Pk = ToString(k)。
      2. kValue = Get(OPk)。
      3. 执行 Set(AToString(n), kValuetrue)。
      4. k 加 1。
      5. n 加 1。
  15. 否则 如果 count > 0, 那么
    1. srcBuffer 等于 O 的内部位置 [[ViewedArrayBuffer]]。
    2. 如果 IsDetachedBuffer(srcBuffer) 为 true, 抛出TypeError异常。
    3. targetBuffer 等于 A 的内部位置 [[ViewedArrayBuffer]]。
    4. elementSize 等于 Table 50 表中的 srcType 的元素大小的数值。
    5. 注释: 如果 srcTypetargetType 相等,必须以保留源数据的位级编码的方式执行转移。
    6. srcByteOffet 等于 O 的内部位置 [[ByteOffset]]。
    7. targetByteIndex 等于 A 的内部位置 [[ByteOffset]]。
    8. srcByteIndex = (k × elementSize) + srcByteOffet
    9. limit = targetByteIndex + count × elementSize
    10. 重复, 当 targetByteIndex < limit
      1. value = GetValueFromBuffer(srcBuffersrcByteIndex"Uint8")。
      2. 执行 SetValueInBuffer(targetBuffertargetByteIndex"Uint8"value)。
      3. srcByteIndex 加 1。
      4. targetByteIndex 加 1。
  16. 返回 A

这个函数不是一般函数,this 必须是一个包含内部位置 [[TypedArrayName]] 的对象。

22.2.3.25%TypedArray%.prototype.some ( callbackfn [ , thisArg ] )#

%TypedArray%.prototype.some 是一个独特的方法,实现了和 Array.prototype.some22.1.3.24 中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。 这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变,并且必须考虑调用callbackfn方法导致this值变得分离的可能。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

22.2.3.26%TypedArray%.prototype.sort ( comparefn )#

%TypedArray%.prototype.sort 是一个独特的方法,除了一下所述, 实现是和 Array.prototype.sort22.1.3.25 中定义的一样。%TypedArray%.prototype.sort 规范的实现是可以被优化的如果知道 this 值是一个对象,有固定长度并且整数下标属性不是稀疏的。这个算法唯一可能调用的内部方法是 [[Get]] 和 [[Set]]。

这个函数不是一般函数,this 必须是一个包含内部位置 [[TypedArrayName]] 的对象。

初始化 sort 函数环境的步骤如下。这些步骤用来替代 22.1.3.25 中的输入步骤:

  1. obj = this
  2. buffer = ValidateTypedArray(obj)。
  3. len等于 obj 的内部位置 [[ArrayLength]]。

这个为外来对象定义了排序条件的实现不会被 %TypedArray%.prototype.sort 应用。

SortCompare 的一下版本被用于 %TypedArray%.prototype.sort。 它执行数值比较而不是使用在22.1.3.25中的字符串比较。SortCompare 能访问到当前调用的 sort 方法的 comparefnbuffer 值。

当TypedArray的抽象操作SortCompare以两个参数 xy 调用,步骤如下:

  1. 断言: Type(x) 和 Type(y) 都时Number类型。
  2. 如果参数 comparefn 不为 undefined, 那么
    1. v = Call(comparefnundefined, « xy »)。
    2. 如果 IsDetachedBuffer(buffer) 为 true, 抛出TypeError异常。
    3. 如果 v 等于 NaN, 返回 +0
    4. 返回 v
  3. 如果 x and y are both NaN, 返回 +0
  4. 如果 x 等于 NaN, 返回 1。
  5. 如果 y 等于 NaN, 返回 -1。
  6. 如果 x < y, 返回 -1。
  7. 如果 x > y, 返回 1。
  8. 如果 x 等于 -0 并且 y 等于 +0, 返回 -1。
  9. 如果 x 等于 +0 并且 y 等于 -0, 返回 1。
  10. 返回 +0

注释

因为 NaN 始终比其他数值大, 当没有提供comparefnNaN 始终排在结果的末尾。

22.2.3.27%TypedArray%.prototype.subarray( beginend )#

返回一个新的对象 TypedArray,它的元素类型和这个 TypedArray 一样, 并且它的ArrayBuffer值也是和这个TypedArray的ArrayBuffer一样, 引用begin的元素,包括end。如果beginend 中任意一个为负,它指向数组末尾的下标,作为开始的反面。

  1. O = this
  2. 如果 Type(O) 不为 Object, 抛出TypeError异常。
  3. 如果 O 没有内部位置 [[TypedArrayName]], 抛出TypeError异常。
  4. 断言: O 有内部位置 [[ViewedArrayBuffer]]。
  5. buffer 等于 O 的内部位置 [[ViewedArrayBuffer]]。
  6. srcLength 等于 O 的内部位置 [[ArrayLength]]。
  7. relativeBegin = ToInteger(begin)。
  8. 如果 relativeBegin < 0, 让 beginIndex = max((srcLength + relativeBegin), 0); 否则 让 beginIndex = min(relativeBeginsrcLength)。
  9. 如果 end 等于 undefined, 让 relativeEnd = srcLength; 否则, 让 relativeEnd = ToInteger(end)。
  10. 如果 relativeEnd < 0, 让 endIndex = max((srcLength + relativeEnd), 0); 否则 让 endIndex = min(relativeEndsrcLength)。
  11. newLength = max(endIndex - beginIndex, 0)。
  12. constructorName 等于 O 的内部位置 [[TypedArrayName]] 的字符串值。
  13. elementSize 等于 Table 50 表中申明的 constructorName 的元素大小的数值。
  14. srcByteOffset 等于 O 的内部位置 [[ByteOffset]]。
  15. beginByteOffset = srcByteOffset + beginIndex × elementSize
  16. argumentsList = « bufferbeginByteOffsetnewLength »。
  17. 返回 TypedArraySpeciesCreate(OargumentsList)。

这个函数不是一般函数,this 必须是一个包含内部位置 [[TypedArrayName]] 的对象。

22.2.3.28%TypedArray%.prototype.toLocaleString ([ reserved1 [ , reserved2 ] ])#

%TypedArray%.prototype.toLocaleString 是一个独特的方法,实现了和 Array.prototype.toLocaleString22.1.3.27 中定义的一样的算法,除了this对象的内部位置 [[ArrayLength]] 的访问代替了"length"的[[Get]]。 这个算法的实现可以被优化,如果知道this的值长度固定并且整数下标属性不是稀疏的。然而,这个优化不能引起算法中明确的行为任何明显的改变。

这个函数不是一般的函数。ValidateTypedArray在执行算法前就提供了this值。如果结果是突然的结束会抛出异常,而不是执行算法。

注释

如果ECMAScript规范包括ECMA-402国际化API,这函数基于ECMA-402规范中Array.prototype.toLocaleString的算法实现。

22.2.3.29%TypedArray%.prototype.toString ( )#

%TypedArray%.prototype.toString 数据属性的初始值和定义在22.1.3.28的内建函数对象 Array.prototype.toString 方法一样。

22.2.3.30%TypedArray%.prototype.values ( )#

步骤如下:

  1. O = this
  2. 执行 ValidateTypedArray(O)。
  3. 返回 CreateArrayIterator(O"value")。

22.2.3.31%TypedArray%.prototype [ @@iterator ] ( )#

@@iterator属性的初始值和函数对象%TypedArray%.prototype.values 的属性的初始值一样。

22.2.3.32get %TypedArray%.prototype [ @@toStringTag ]#

%TypedArray%.的属性[@@toStringTag]是一个访问器属性,它的赋值器属性函数是undefined。它的访问器属性函数步骤如下:

  1. O = this
  2. 如果 Type(O) 不为 Object, 返回 undefined
  3. 如果 O 没有内部位置 [[TypedArrayName]], 返回 undefined
  4. name 等于 O 的内部位置 [[TypedArrayName]]。
  5. 断言: name 是一个字符串。
  6. 返回 name

这个属性的特性为 { [[Enumerable]]: false, [[Configurable]]: true }。

这个函数的 name 属性的初始值是"get [Symbol.toStringTag]"

22.2.4TypedArray构造器#

每个TypedArray构造器对象都是固有对象,描述它的结构体如下, 只是在用了构造器名字上与Table 50中的TypedArray不同。

固有构造器函数TypedArray是个单函数,它的行为基于参数的个数和类型重载。TypedArray调用的真实行为取决于传递给它的参数的个数和类型。

TypedArray构造器不是被设计来作为一个调用的,以这种方式调用时会抛出异常。

TypedArray构造器是设计来给子类继承的。他们可能被用来作为类定义的extends语句后的值。想要继承TypedArray申明的行为的子类构造器必须包含一个super的调用来创建并初始化一个有内部状态的子类实例, 这样来支持%TypedArray%.prototype上内建的方法。

TypedArray构造器函数的length属性的值为3。

22.2.4.1TypedArray ( )#

这个描述仅在TypedArray函数没有参数调用时生效。

  1. 如果NewTarget 为 undefined, 抛出TypeError异常。
  2. constructorName 等于Table 50表中声明的 TypedArray 构造器的构造器名字的字符串值。
  3. 返回 AllocateTypedArray(constructorName, NewTarget, "%<var>TypedArray</var>Prototype%", 0)。

22.2.4.2TypedArray ( length )#

这个描述仅在TypedArray函数以至少一个参数并且第一个参数不是对象的时候生效。

TypedArraylength为参数调用,步骤如下:

  1. 断言: Type(length) 不是对象。
  2. 如果NewTarget 等于 undefined, 抛出TypeError异常。
  3. 如果 length 等于 undefined, 抛出TypeError异常。
  4. numberLength = ToNumber(length)。
  5. elementLength = ToLength(numberLength)。
  6. 如果 SameValueZero(numberLengthelementLength) 为 false, 抛出RangeError异常。
  7. constructorName 等于 Table 50 表中声明的 TypedArray 构造器的构造器名字的字符串值。
  8. 返回 AllocateTypedArray(constructorName, NewTarget, "%<var>TypedArray</var>Prototype%"elementLength)。

22.2.4.2.1执行期语意学: AllocateTypedArray (constructorNamenewTargetdefaultProto [ , length ])#

抽象操作AllocateTypedArray以参数constructorNamenewTargetdefaultProto 和 可选参数 length 调用来验证和创建一个TypedArray构造器的实例。constructorName 是必需的来作为Table 50中的TypedArray构造器的名字。如果length参数传递了一个ArrayBuffer,这个长度也会被分配并且关联到新的TypedArray实例。 AllocateTypedArray提供了通用语义,被用在所有的TypedArray重载集合。AllocateTypedArray调用步骤如下:

  1. proto = GetPrototypeFromConstructor(newTargetdefaultProto)。
  2. obj = IntegerIndexedObjectCreate(proto, « [[ViewedArrayBuffer]], [[TypedArrayName]], [[ByteLength]], [[ByteOffset]], [[ArrayLength]] »)。
  3. 断言: obj的内部位置[[ViewedArrayBuffer]] 等于 undefined
  4. 设置 obj 的内部位置 [[TypedArrayName]] 为 constructorName
  5. 如果没有传递 length, 那么
    1. 设置 obj 的内部位置 [[ByteLength]] 为 0。
    2. 设置 obj 的内部位置 [[ByteOffset]] 为 0。
    3. 设置 obj 的内部位置 [[ArrayLength]] 为 0。
  6. 否则,
    1. 执行 AllocateTypedArrayBuffer(objlength)。
  7. 返回 obj

22.2.4.2.2执行期语意学: AllocateTypedArrayBuffer ( Olength )#

抽象操作AllocateTypedArrayBuffer以参数Olength 调用分配并且将ArrayBuffer关联到TypedArray实例 O 上。它的步骤如下:

  1. 断言: O 是一个对象并且有内部位置 [[ViewedArrayBuffer]]。
  2. 断言: O 的内部位置 [[ViewedArrayBuffer]] 等于 undefined
  3. 断言: length ≥ 0。
  4. constructorName 等于 O 的内部位置 [[TypedArrayName]] 的字符串值。
  5. elementSize 等于 Table 50 表中的 constructorName 的元素大小的数值。
  6. byteLength = elementSize × length
  7. data = AllocateArrayBuffer(%ArrayBuffer%byteLength)。
  8. 设置 O 的内部位置 [[ViewedArrayBuffer]] 为 data
  9. 设置 O 的内部位置 [[ByteLength]]为 byteLength
  10. 设置 O 的内部位置 [[ByteOffset]] 为 0。
  11. 设置 O 的内部位置 [[ArrayLength]] 为 length
  12. 返回 O

22.2.4.3TypedArray ( typedArray )#

这个描述仅在TypedArray函数以至少一个参数调用并且第一个参数是一个有内部位置[[TypedArrayName]]的对象时生效。

TypedArray以参数typedArray调用时步骤如下:

  1. 断言: Type(typedArray) 是一个对象并且 typedArray 有内部位置 [[TypedArrayName]]。
  2. 如果 NewTarget 为 undefined, 抛出TypeError异常。
  3. constructorName 等于 Table 50 表中定义的 TypedArray 构造器的构造器名字的字符串值。
  4. O = AllocateTypedArray(constructorName, NewTarget, "%<var>TypedArray</var>Prototype%")。
  5. srcArray = typedArray
  6. srcData 等于 srcArray 的内部位置 [[ViewedArrayBuffer]]。
  7. 如果 IsDetachedBuffer(srcData) 为 true, 抛出TypeError异常。
  8. constructorName 等于 O 的内部位置 [[TypedArrayName]] 的字符串值。
  9. elementType 等于 Table 50 表中的 constructorName 的元素类型的字符串值。
  10. elementLength 等于 srcArray 的内部位置 [[ArrayLength]] 的值。
  11. srcName 等于srcArray 的内部位置 [[TypedArrayName]] 的字符串值。
  12. srcType 等于 Table 50 表中的 srcName 的元素类型的字符串值。
  13. srcElementSize 等于 Table 50 表中的 srcName 的元素大小值。
  14. srcByteOffset 等于 srcArray 的内部位置 [[ByteOffset]] 的值。
  15. elementSize 等于 Table 50 表中的 constructorName 的元素大小值。
  16. byteLength = elementSize × elementLength
  17. 如果 SameValue(elementTypesrcType) 为 true, 那么
    1. data = CloneArrayBuffer(srcDatasrcByteOffset)。
  18. 否则,
    1. bufferConstructor = SpeciesConstructor(srcData%ArrayBuffer%)。
    2. data = AllocateArrayBuffer(bufferConstructorbyteLength)。
    3. 如果 IsDetachedBuffer(srcData) 为 true, 抛出TypeError异常。
    4. srcByteIndex = srcByteOffset
    5. targetByteIndex = 0。
    6. count = elementLength
    7. 重复, 当 count > 0
      1. value = GetValueFromBuffer(srcDatasrcByteIndexsrcType)。
      2. 执行 SetValueInBuffer(datatargetByteIndexelementTypevalue)。
      3. 设置 srcByteIndex to srcByteIndex + srcElementSize
      4. 设置 targetByteIndex to targetByteIndex + elementSize
      5. count 减 1。
  19. 设置 O 的内部位置 [[ViewedArrayBuffer]] 为 data
  20. 设置 O 的内部位置 [[ByteLength]] 为 byteLength
  21. 设置 O 的内部位置 [[ByteOffset]] 为 0。
  22. 设置 O 的内部位置 [[ArrayLength]] 为 elementLength
  23. 返回 O

22.2.4.4TypedArray ( object )#

这个描述仅在TypedArray函数以最少一个参数调用并且第一个参数的类型为没有内部位置[[TypedArrayName]] 或 [[ArrayBufferData]]的对象。

TypedArray以参数object调用,步骤如下:

  1. 断言: Type(object) 为对象,并且 object 没有内部位置 [[TypedArrayName]] 或 [[ArrayBufferData]]。
  2. 如果NewTarget 为 undefined, 抛出TypeError异常。
  3. constructorName 等于 Table 50 表中申明的 TypedArray 构造器的构造器名字的字符串值。
  4. O = AllocateTypedArray(constructorName, NewTarget, "%<var>TypedArray</var>Prototype%")。
  5. arrayLike = IterableToArrayLike(object)。
  6. len = ToLength(Get(arrayLike"length"))。
  7. 执行 AllocateTypedArrayBuffer(Olen)。
  8. k = 0。
  9. 重复, 当 k < len
    1. Pk = ToString(k)。
    2. kValue = Get(arrayLikePk)。
    3. 执行 Set(OPkkValuetrue)。
    4. k 加 1。
  10. 返回 O

22.2.4.5TypedArray ( buffer [ , byteOffset [ , length ] ] )#

这个描述只在 TypedArray 函数以最少一个参数调用并且第一个参数是有内部位置 [[ArrayBufferData]] 的对象时生效。

TypedArray 以参数 bufferbyteOffset, 和 length调用,步骤如下:

  1. 断言: Type(buffer) 为对象,并且buffer 有内部位置 [[ArrayBufferData]]。
  2. 如果 NewTarget 为 undefined, 抛出TypeError异常。
  3. constructorName 等于 Table 50 表中定义的 TypedArray 构造器的构造器名字的字符串值。
  4. O = AllocateTypedArray(constructorName, NewTarget, "%<var>TypedArray</var>Prototype%")。
  5. constructorName 等于 O 的内部位置 [[TypedArrayName]] 的字符串值。
  6. elementSize 等于 Table 50 表中的 constructorName 的原始大小的数值。
  7. offset = ToInteger(byteOffset)。
  8. 如果 offset < 0, 抛出RangeError异常。
  9. 如果 offset 等于 -0, 让 offset = +0
  10. 如果 offset elementSize ≠ 0, 抛出RangeError异常。
  11. 如果 IsDetachedBuffer(buffer) 为 true, 抛出TypeError异常。
  12. bufferByteLength 等于 buffer 的内部位置 [[ArrayBufferByteLength]]。
  13. 如果 length 等于 undefined, 那么
    1. 如果 bufferByteLength elementSize ≠ 0, 抛出RangeError异常。
    2. newByteLength = bufferByteLength - offset
    3. 如果 newByteLength < 0, 抛出RangeError异常。
  14. 否则,
    1. newLength = ToLength(length)。
    2. newByteLength = newLength × elementSize
    3. 如果 offset+newByteLength > bufferByteLength, 抛出RangeError异常。
  15. 设置 O 的内部位置 [[ViewedArrayBuffer]] 为 buffer
  16. 设置 O 的内部位置 [[ByteLength]] 为 newByteLength
  17. 设置 O 的内部位置 [[ByteOffset]] 为 offset
  18. 设置 O 的内部位置 [[ArrayLength]] 为 newByteLength / elementSize
  19. 返回 O

22.2.4.6TypedArrayCreate ( constructorargumentList )#

抽象操作 TypedArrayCreate 以参数 constructorargumentList 调用通过使用构造器函数来声明新的TypedArray对象的创建。 步骤如下:

  1. newTypedArray = Construct(constructorargumentList)。
  2. 执行 ValidateTypedArray(newTypedArray)。
  3. 如果 argumentList 是一个单个数字的 列表, 那么
    1. 如果 newTypedArray 的内部位置 [[ArrayLength]] 的值 小于 argumentList[0], 抛出TypeError异常。
  4. 返回 newTypedArray

22.2.4.7TypedArraySpeciesCreate ( exemplarargumentList )#

抽象操作TypedArraySpeciesCreate以参数 exemplarargumentList 调用通过使用从exemplar派生的构造器函数来声明新的TypedArray对象的创建。步骤如下:

  1. 断言: exemplar 为一个有内部位置 [[TypedArrayName]] 的对象。
  2. defaultConstructor 为固有对象,Table 50 表中第一个列的 exemplar 的内部位置 [[TypedArrayName]]。
  3. constructor = SpeciesConstructor(exemplardefaultConstructor)。
  4. 返回 TypedArrayCreate(constructorargumentList)。

22.2.5TypedArray的属性构造器#

每个TypedArray构造器的内部位置 [[Prototype]]都是固有对象%TypedArray%

每个有name属性的TypedArray构造器的值都是 Table 50表中声明的构造器名字的字符串值。

每个 TypedArray 构造器都有以下属性:

22.2.5.1TypedArray.BYTES_PER_ELEMENT#

TypedArray.BYTES_PER_ELEMENT 的值是Table 50 表中申明的 TypedArray 的元素大小的数字。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

22.2.5.2TypedArray.prototype#

TypedArray.prototype 的初始值是(22.2.6)表中相应的TypedArray的固有原型对象。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

22.2.6Properties of TypedArray Prototype Objects#

TypedArray原型对象上的内部位置[[Prototype]]是固有对象%TypedArrayPrototype%TypedArray 原型对象是一个普通对象。它没有[[ViewedArrayBuffer]] 或者其他内部位置申明在 TypedArray 实例对象上。

22.2.6.1TypedArray.prototype.BYTES_PER_ELEMENT#

<var>TypedArray</var>.prototype.BYTES_PER_ELEMENT的值是 Table 50 表中申明的 TypedArray 的元素大小的数值。

这个属性的特性为 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

22.2.6.2TypedArray.prototype.constructor#

<var>TypedArray</var>.prototype.constructor的初始值是相应的固有对象 %TypedArray%。

22.2.7TypedArray实例的属性#

TypedArray实例是整数下标的外来对象。每个TypedArray实例从相应的TypedArray原型对象上继承属性。每个TypedArray实例有以下内部位置:[[TypedArrayName]], [[ViewedArrayBuffer]], [[ByteLength]], [[ByteOffset]], 和 [[ArrayLength]]。