This description applies if and only if the Array constructor is called with no arguments.

1. Let numberOfArgs be the number of arguments passed to this function call.
2. Assert: numberOfArgs = 0.
3. If NewTarget is undefined, let newTarget be the active function object, else let newTarget be NewTarget.
4. Let proto be GetPrototypeFromConstructor(newTarget, "%ArrayPrototype%").
5. ReturnIfAbrupt(proto).
6. Return ArrayCreate(0, proto).

This description applies if and only if the Array constructor is called with exactly one argument.

1. Let numberOfArgs be the number of arguments passed to this function call.
2. Assert: numberOfArgs = 1.
3. If NewTarget is undefined, let newTarget be the active function object, else let newTarget be NewTarget.
4. Let proto be GetPrototypeFromConstructor(newTarget, "%ArrayPrototype%").
5. ReturnIfAbrupt(proto).
6. Let array be ArrayCreate(0, proto).
7. If Type(len) is not Number, then
   1. 1. Let defineStatus be CreateDataProperty(array, "0", len).
      2. Assert: defineStatus is true.
      3. Let intLen be 1.
8. Else,
   1. 1. Let intLen be ToUint32(len).
      2. If intLen ≠ len, throw a RangeError exception.
9. Let setStatus be Set(array, "length", intLen, true).
10. Assert: setStatus is not an abrupt completion.
11. Return array.

This description applies if and only if the Array constructor is called with at least two arguments.

When the Array function is called the following steps are taken:

1. Let numberOfArgs be the number of arguments passed to this function call.
2. Assert: numberOfArgs ≥ 2.
3. If NewTarget is undefined, let newTarget be the active function object, else let newTarget be NewTarget.
4. Let proto be GetPrototypeFromConstructor(newTarget, "%ArrayPrototype%").
5. ReturnIfAbrupt(proto).
6. Let array be ArrayCreate(numberOfArgs, proto).
7. ReturnIfAbrupt(array).
8. Let k be 0.
9. Let items be a zero-origined List containing the argument items in order.
10. Repeat, while k < numberOfArgs
    1. 1. Let Pk be ToString(k).
       2. Let itemK be items[k].
       3. Let defineStatus be CreateDataProperty(array, Pk, itemK).
       4. Assert: defineStatus is true.
       5. Increase k by 1.
11. Assert: the value of array's length property is numberOfArgs.
12. Return array.

When the from method is called with argument items and optional arguments mapfn and thisArg the following steps are taken:

1. Let C be the this value.
2. If mapfn is undefined, let mapping be false.
3. else
   1. 1. If IsCallable(mapfn) is false, throw a TypeError exception.
      2. If thisArg was supplied, let T be thisArg; else let T be undefined.
      3. Let mapping be true
4. Let usingIterator be GetMethod(items, @@iterator).
5. ReturnIfAbrupt(usingIterator).
6. If usingIterator is not undefined, then
   1. 1. If IsConstructor(C) is true, then
         1. 1. Let A be Construct(C).
      2. Else,
         1. 1. Let A be ArrayCreate(0).
      3. ReturnIfAbrupt(A).
      4. Let iterator be GetIterator(items, usingIterator).
      5. ReturnIfAbrupt(iterator).
      6. Let k be 0.
      7. Repeat
         1. 1. Let Pk be ToString(k).
            2. Let next be IteratorStep(iterator).
            3. ReturnIfAbrupt(next).
            4. If next is false, then
               1. 1. Let setStatus be Set(A, "length", k, true).
                  2. ReturnIfAbrupt(setStatus).
                  3. Return A.
            5. Let nextValue be IteratorValue(next).
            6. ReturnIfAbrupt(nextValue).
            7. If mapping is true, then
               1. 1. Let mappedValue be Call(mapfn, T, «nextValue, k»).
                  2. If mappedValue is an abrupt completion, return IteratorClose(iterator, mappedValue).
                  3. Let mappedValue be mappedValue.[[value]].
            8. Else, let mappedValue be nextValue.
            9. Let defineStatus be CreateDataPropertyOrThrow(A, Pk, mappedValue).
            10. If defineStatus is an abrupt completion, return IteratorClose(iterator, defineStatus).
            11. Increase k by 1.
7. Assert: items is not an Iterable so assume it is an array-like object.
8. Let arrayLike be ToObject(items).
9. ReturnIfAbrupt(arrayLike).
10. Let len be ToLength(Get(arrayLike, "length")).
11. ReturnIfAbrupt(len).
12. If IsConstructor(C) is true, then
    1. 1. Let A be Construct(C, «len»).
13. Else,
    1. 1. Let A be ArrayCreate(len).
14. ReturnIfAbrupt(A).
15. Let k be 0.
16. Repeat, while k < len
    1. 1. Let Pk be ToString(k).
       2. Let kValue be Get(arrayLike, Pk).
       3. ReturnIfAbrupt(kValue).
       4. If mapping is true, then
          1. 1. Let mappedValue be Call(mapfn, T, «kValue, k»).
             2. ReturnIfAbrupt(mappedValue).
       5. Else, let mappedValue be kValue.
       6. Let defineStatus be CreateDataPropertyOrThrow(A, Pk, mappedValue).
       7. ReturnIfAbrupt(defineStatus).
       8. Increase k by 1.
17. Let setStatus be Set(A, "length", len, true).
18. ReturnIfAbrupt(setStatus).
19. Return A.

The length property of the from method is 1.

Note

The from function is an intentionally generic factory method; it does not require that its this value be the Array constructor. Therefore it can be transferred to or inherited by any other constructors that may be called with a single numeric argument.

The isArray function takes one argument arg, and performs the following steps:

1. Return IsArray(arg).

When the of method is called with any number of arguments, the following steps are taken:

1. Let len be the actual number of arguments passed to this function.
2. Let items be the List of arguments passed to this function.
3. Let C be the this value.
4. If IsConstructor(C) is true, then
   1. 1. Let A be Construct(C, «len»).
5. Else,
   1. 1. Let A be ArrayCreate(len).
6. ReturnIfAbrupt(A).
7. Let k be 0.
8. Repeat, while k < len
   1. 1. Let kValue be items[k].
      2. Let Pk be ToString(k).
      3. Let defineStatus be CreateDataPropertyOrThrow(A,Pk, kValue).
      4. ReturnIfAbrupt(defineStatus).
      5. Increase k by 1.
9. Let setStatus be Set(A, "length", len, true).
10. ReturnIfAbrupt(setStatus).
11. Return A.

The length property of the of method is 0.

Note 1

The items argument is assumed to be a well-formed rest argument value.

Note 2

The of function is an intentionally generic factory method; it does not require that its this value be the Array constructor. Therefore it can be transferred to or inherited by other constructors that may be called with a single numeric argument.

The value of Array.prototype is %ArrayPrototype%, the intrinsic Array prototype object (22.1.3).

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

Array[@@species] is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps:

1. Return the this value.

The value of the name property of this function is "get [Symbol.species]".

Note

Array prototype methods normally use their this object's constructor to create a derived object. However, a subclass constructor may over-ride that default behaviour by redefining its @@species property.

When the concat method is called with zero or more arguments, it returns an array containing the array elements of the object followed by the array elements of each argument in order.

The following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let A be ArraySpeciesCreate(O, 0).
4. ReturnIfAbrupt(A).
5. Let n be 0.
6. Let items be a List whose first element is O and whose subsequent elements are, in left to right order, the arguments that were passed to this function invocation.
7. Repeat, while items is not empty
   1. 1. Remove the first element from items and let E be the value of the element.
      2. Let spreadable be IsConcatSpreadable(E).
      3. ReturnIfAbrupt(spreadable).
      4. If spreadable is true, then
         1. 1. Let k be 0.
            2. Let len be ToLength(Get(E, "length")).
            3. ReturnIfAbrupt(len).
            4. If n + len > 2⁵³-1, throw a TypeError exception.
            5. Repeat, while k < len
               1. 1. Let P be ToString(k).
                  2. Let exists be HasProperty(E, P).
                  3. ReturnIfAbrupt(exists).
                  4. If exists is true, then
                     1. 1. Let subElement be Get(E, P).
                        2. ReturnIfAbrupt(subElement).
                        3. Let status be CreateDataPropertyOrThrow (A, ToString(n), subElement).
                        4. ReturnIfAbrupt(status).
                  5. Increase n by 1.
                  6. Increase k by 1.
      5. Else E is added as a single item rather than spread,
         1. 1. If n≥2⁵³-1, throw a TypeError exception.
            2. Let status be CreateDataPropertyOrThrow (A, ToString(n), E).
            3. ReturnIfAbrupt(status).
            4. Increase n by 1.
8. Let setStatus be Set(A, "length", n, true).
9. ReturnIfAbrupt(setStatus).
10. Return A.

The length property of the concat method is 1.

Note 1

The explicit setting of the length property in step 8 is necessary to ensure that its value is correct in situations where the trailing elements of the result Array are not present.

Note 2

The concat function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

The initial value of Array.prototype.constructor is the intrinsic object %Array%.

The copyWithin method takes up to three arguments target, start and end.

Note 1

The end argument is optional with the length of the this object as its default value. If target is negative, it is treated as length+target where length is the length of the array. If start is negative, it is treated as length+start. If end is negative, it is treated as length+end.

The following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. Let relativeTarget be ToInteger(target).
6. ReturnIfAbrupt(relativeTarget).
7. If relativeTarget < 0, let to be max((len + relativeTarget),0); else let to be min(relativeTarget, len).
8. Let relativeStart be ToInteger(start).
9. ReturnIfAbrupt(relativeStart).
10. If relativeStart < 0, let from be max((len + relativeStart),0); else let from be min(relativeStart, len).
11. If end is undefined, let relativeEnd be len; else let relativeEnd be ToInteger(end).
12. ReturnIfAbrupt(relativeEnd).
13. If relativeEnd < 0, let final be max((len + relativeEnd),0); else let final be min(relativeEnd, len).
14. Let count be min(final-from, len-to).
15. If from<to and to<from+count
    1. 1. Let direction be -1.
       2. Let from be from + count -1.
       3. Let to be to + count -1.
16. Else,
    1. 1. Let direction = 1.
17. Repeat, while count > 0
    1. 1. Let fromKey be ToString(from).
       2. Let toKey be ToString(to).
       3. Let fromPresent be HasProperty(O, fromKey).
       4. ReturnIfAbrupt(fromPresent).
       5. If fromPresent is true, then
          1. 1. Let fromVal be Get(O, fromKey).
             2. ReturnIfAbrupt(fromVal).
             3. Let setStatus be Set(O, toKey, fromVal, true).
             4. ReturnIfAbrupt(setStatus).
       6. Else fromPresent is false,
          1. 1. Let deleteStatus be DeletePropertyOrThrow(O, toKey).
             2. ReturnIfAbrupt(deleteStatus).
       7. Let from be from + direction.
       8. Let to be to + direction.
       9. Let count be count - 1.
18. Return O.

The length property of the copyWithin method is 2.

Note 2

The copyWithin function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

The following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Return CreateArrayIterator(O, "key+value").

Note 1

callbackfn should be a function that accepts three arguments and returns a value that is coercible to the Boolean value true or false. every calls callbackfn once for each element present in the array, in ascending order, until it finds one where callbackfn returns false. If such an element is found, every immediately returns false. Otherwise, if callbackfn returned true for all elements, every will return true. callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.

every does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by every is set before the first call to callbackfn. Elements which are appended to the array after the call to every begins will not be visited by callbackfn. If existing elements of the array are changed, their value as passed to callbackfn will be the value at the time every visits them; elements that are deleted after the call to every begins and before being visited are not visited. every acts like the "for all" quantifier in mathematics. In particular, for an empty array, it returns true.

When the every method is called with one or two arguments, the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If IsCallable(callbackfn) is false, throw a TypeError exception.
6. If thisArg was supplied, let T be thisArg; else let T be undefined.
7. Let k be 0.
8. Repeat, while k < len
   1. 1. Let Pk be ToString(k).
      2. Let kPresent be HasProperty(O, Pk).
      3. ReturnIfAbrupt(kPresent).
      4. If kPresent is true, then
         1. 1. Let kValue be Get(O, Pk).
            2. ReturnIfAbrupt(kValue).
            3. Let testResult be ToBoolean(Call(callbackfn, T, «kValue, k, O»)).
            4. ReturnIfAbrupt(testResult).
            5. If testResult is false, return false.
      5. Increase k by 1.
9. Return true.

The length property of the every method is 1.

Note 2

The every function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

The fill method takes up to three arguments value, start and end.

Note 1

The start and end arguments are optional with default values of 0 and the length of the this object. If start is negative, it is treated as length+start where length is the length of the array. If end is negative, it is treated as length+end.

The following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. Let relativeStart be ToInteger(start).
6. ReturnIfAbrupt(relativeStart).
7. If relativeStart < 0, let k be max((len + relativeStart),0); else let k be min(relativeStart, len).
8. If end is undefined, let relativeEnd be len; else let relativeEnd be ToInteger(end).
9. ReturnIfAbrupt(relativeEnd).
10. If relativeEnd < 0, let final be max((len + relativeEnd),0); else let final be min(relativeEnd, len).
11. Repeat, while k < final
    1. 1. Let Pk be ToString(k).
       2. Let setStatus be Set(O, Pk, value, true).
       3. ReturnIfAbrupt(setStatus).
       4. Increase k by 1.
12. Return O.

The length property of the fill method is 1.

Note 2

The fill function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

callbackfn should be a function that accepts three arguments and returns a value that is coercible to the Boolean value true or false. filter calls callbackfn once for each element in the array, in ascending order, and constructs a new array of all the values for which callbackfn returns true. callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.

filter does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by filter is set before the first call to callbackfn. Elements which are appended to the array after the call to filter begins will not be visited by callbackfn. If existing elements of the array are changed their value as passed to callbackfn will be the value at the time filter visits them; elements that are deleted after the call to filter begins and before being visited are not visited.

When the filter method is called with one or two arguments, the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If IsCallable(callbackfn) is false, throw a TypeError exception.
6. If thisArg was supplied, let T be thisArg; else let T be undefined.
7. Let A be ArraySpeciesCreate(O, 0).
8. ReturnIfAbrupt(A).
9. Let k be 0.
10. Let to be 0.
11. Repeat, while k < len
    1. 1. Let Pk be ToString(k).
       2. Let kPresent be HasProperty(O, Pk).
       3. ReturnIfAbrupt(kPresent).
       4. If kPresent is true, then
          1. 1. Let kValue be Get(O, Pk).
             2. ReturnIfAbrupt(kValue).
             3. Let selected be ToBoolean(Call(callbackfn, T, «kValue, k, O»)).
             4. ReturnIfAbrupt(selected).
             5. If selected is true, then
                1. 1. Let status be CreateDataPropertyOrThrow (A, ToString(to), kValue).
                   2. ReturnIfAbrupt(status).
                   3. Increase to by 1.
       5. Increase k by 1.
12. Return A.

The length property of the filter method is 1.

Note 2

The filter function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

The find method is called with one or two arguments, predicate and thisArg.

Note 1

predicate should be a function that accepts three arguments and returns a value that is coercible to a Boolean value. find calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, find immediately returns that element value. Otherwise, find returns undefined.

If a thisArg parameter is provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.

predicate is called with three arguments: the value of the element, the index of the element, and the object being traversed.

find does not directly mutate the object on which it is called but the object may be mutated by the calls to predicate.

The range of elements processed by find is set before the first call to callbackfn. Elements that are appended to the array after the call to find begins will not be visited by callbackfn. If existing elements of the array are changed, their value as passed to predicate will be the value at the time that find visits them.

When the find method is called, the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If IsCallable(predicate) is false, throw a TypeError exception.
6. If thisArg was supplied, let T be thisArg; else let T be undefined.
7. Let k be 0.
8. Repeat, while k < len
   1. 1. Let Pk be ToString(k).
      2. Let kValue be Get(O, Pk).
      3. ReturnIfAbrupt(kValue).
      4. Let testResult be ToBoolean(Call(predicate, T, «kValue, k, O»)).
      5. ReturnIfAbrupt(testResult).
      6. If testResult is true, return kValue.
      7. Increase k by 1.
9. Return undefined.

The length property of the find method is 1.

Note 2

The find function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

predicate should be a function that accepts three arguments and returns a value that is coercible to the Boolean value true or false. findIndex calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, findIndex immediately returns the index of that element value. Otherwise, findIndex returns -1.

If a thisArg parameter is provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.

predicate is called with three arguments: the value of the element, the index of the element, and the object being traversed.

findIndex does not directly mutate the object on which it is called but the object may be mutated by the calls to predicate.

The range of elements processed by findIndex is set before the first call to callbackfn. Elements that are appended to the array after the call to findIndex begins will not be visited by callbackfn. If existing elements of the array are changed, their value as passed to predicate will be the value at the time that findIndex visits them.

When the findIndex method is called with one or two arguments, the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If IsCallable(predicate) is false, throw a TypeError exception.
6. If thisArg was supplied, let T be thisArg; else let T be undefined.
7. Let k be 0.
8. Repeat, while k < len
   1. 1. Let Pk be ToString(k).
      2. Let kValue be Get(O, Pk).
      3. ReturnIfAbrupt(kValue).
      4. Let testResult be ToBoolean(Call(predicate, T, «kValue, k, O»)).
      5. ReturnIfAbrupt(testResult).
      6. If testResult is true, return k.
      7. Increase k by 1.
9. Return -1.

The length property of the findIndex method is 1.

Note 2

The findIndex function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

callbackfn should be a function that accepts three arguments. forEach calls callbackfn once for each element present in the array, in ascending order. callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.

forEach does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

When the forEach method is called with one or two arguments, the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If IsCallable(callbackfn) is false, throw a TypeError exception.
6. If thisArg was supplied, let T be thisArg; else let T be undefined.
7. Let k be 0.
8. Repeat, while k < len
   1. 1. Let Pk be ToString(k).
      2. Let kPresent be HasProperty(O, Pk).
      3. ReturnIfAbrupt(kPresent).
      4. If kPresent is true, then
         1. 1. Let kValue be Get(O, Pk).
            2. ReturnIfAbrupt(kValue).
            3. Let funcResult be Call(callbackfn, T, «kValue, k, O»).
            4. ReturnIfAbrupt(funcResult).
      5. Increase k by 1.
9. Return undefined.

The length property of the forEach method is 1.

Note 2

The forEach function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

indexOf compares searchElement to the elements of the array, in ascending order, using the Strict Equality Comparison algorithm (7.2.13), and if found at one or more indices, returns the smallest such index; otherwise, -1 is returned.

The optional second argument fromIndex defaults to 0 (i.e. the whole array is searched). If it is greater than or equal to the length of the array, -1 is returned, i.e. the array will not be searched. If it is negative, it is used as the offset from the end of the array to compute fromIndex. If the computed index is less than 0, the whole array will be searched.

When the indexOf method is called with one or two arguments, the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If len is 0, return -1.
6. If argument fromIndex was passed let n be ToInteger(fromIndex); else let n be 0.
7. ReturnIfAbrupt(n).
8. If n ≥ len, return -1.
9. If n ≥ 0, then
   1. 1. Let k be n.
10. Else n<0,
    1. 1. Let k be len - abs(n).
       2. If k < 0, let k be 0.
11. Repeat, while k<len
    1. 1. Let kPresent be HasProperty(O, ToString(k)).
       2. ReturnIfAbrupt(kPresent).
       3. If kPresent is true, then
          1. 1. Let elementK be Get(O, ToString(k)).
             2. ReturnIfAbrupt(elementK).
             3. Let same be the result of performing Strict Equality Comparison searchElement === elementK.
             4. If same is true, return k.
       4. Increase k by 1.
12. Return -1.

The length property of the indexOf method is 1.

Note 2

The indexOf function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

The elements of the array are converted to Strings, and these Strings are then concatenated, separated by occurrences of the separator. If no separator is provided, a single comma is used as the separator.

The join method takes one argument, separator, and performs the following steps:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If separator is undefined, let separator be the single-element String ",".
6. Let sep be ToString(separator).
7. ReturnIfAbrupt(sep).
8. If len is zero, return the empty String.
9. Let element0 be Get(O, "0").
10. If element0 is undefined or null, let R be the empty String; otherwise, let R be ToString(element0).
11. ReturnIfAbrupt(R).
12. Let k be 1.
13. Repeat, while k < len
    1. 1. Let S be the String value produced by concatenating R and sep.
       2. Let element be Get(O, ToString(k)).
       3. If element is undefined or null, let next be the empty String; otherwise, let next be ToString(element).
       4. ReturnIfAbrupt(next).
       5. Let R be a String value produced by concatenating S and next.
       6. Increase k by 1.
14. Return R.

The length property of the join method is 1.

Note 2

The join function is intentionally generic; it does not require that its this value be an Array object. Therefore, it can be transferred to other kinds of objects for use as a method.

The following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Return CreateArrayIterator(O, "key").

Note 1

lastIndexOf compares searchElement to the elements of the array in descending order using the Strict Equality Comparison algorithm (7.2.13), and if found at one or more indices, returns the largest such index; otherwise, -1 is returned.

The optional second argument fromIndex defaults to the array's length minus one (i.e. the whole array is searched). If it is greater than or equal to the length of the array, the whole array will be searched. If it is negative, it is used as the offset from the end of the array to compute fromIndex. If the computed index is less than 0, -1 is returned.

When the lastIndexOf method is called with one or two arguments, the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If len is 0, return -1.
6. If argument fromIndex was passed let n be ToInteger(fromIndex); else let n be len-1.
7. ReturnIfAbrupt(n).
8. If n ≥ 0, let k be min(n, len - 1).
9. Else n < 0,
   1. 1. Let k be len - abs(n).
10. Repeat, while k≥ 0
    1. 1. Let kPresent be HasProperty(O, ToString(k)).
       2. ReturnIfAbrupt(kPresent).
       3. If kPresent is true, then
          1. 1. Let elementK be Get(O, ToString(k)).
             2. ReturnIfAbrupt(elementK).
             3. Let same be the result of performing Strict Equality Comparison searchElement === elementK.
             4. If same is true, return k.
       4. Decrease k by 1.
11. Return -1.

The length property of the lastIndexOf method is 1.

Note 2

The lastIndexOf function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

callbackfn should be a function that accepts three arguments. map calls callbackfn once for each element in the array, in ascending order, and constructs a new Array from the results. callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.

map does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by map is set before the first call to callbackfn. Elements which are appended to the array after the call to map begins will not be visited by callbackfn. If existing elements of the array are changed, their value as passed to callbackfn will be the value at the time map visits them; elements that are deleted after the call to map begins and before being visited are not visited.

When the map method is called with one or two arguments, the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If IsCallable(callbackfn) is false, throw a TypeError exception.
6. If thisArg was supplied, let T be thisArg; else let T be undefined.
7. Let A be ArraySpeciesCreate(O, len).
8. ReturnIfAbrupt(A).
9. Let k be 0.
10. Repeat, while k < len
    1. 1. Let Pk be ToString(k).
       2. Let kPresent be HasProperty(O, Pk).
       3. ReturnIfAbrupt(kPresent).
       4. If kPresent is true, then
          1. 1. Let kValue be Get(O, Pk).
             2. ReturnIfAbrupt(kValue).
             3. Let mappedValue be Call(callbackfn, T, «kValue, k, O»).
             4. ReturnIfAbrupt(mappedValue).
             5. Let status be CreateDataPropertyOrThrow (A, Pk, mappedValue).
             6. ReturnIfAbrupt(status).
       5. Increase k by 1.
11. Return A.

The length property of the map method is 1.

Note 2

The map function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

The last element of the array is removed from the array and returned.

When the pop method is called the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If len is zero,
   1. 1. Let setStatus be Set(O, "length", 0, true).
      2. ReturnIfAbrupt(setStatus).
      3. Return undefined.
6. Else len > 0,
   1. 1. Let newLen be len-1.
      2. Let indx be ToString(newLen).
      3. Let element be Get(O, indx).
      4. ReturnIfAbrupt(element).
      5. Let deleteStatus be DeletePropertyOrThrow(O, indx).
      6. ReturnIfAbrupt(deleteStatus).
      7. Let setStatus be Set(O, "length", newLen, true).
      8. ReturnIfAbrupt(setStatus).
      9. Return element.

Note 2

The pop function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

The arguments are appended to the end of the array, in the order in which they appear. The new length of the array is returned as the result of the call.

When the push method is called with zero or more arguments the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. Let items be a List whose elements are, in left to right order, the arguments that were passed to this function invocation.
6. Let argCount be the number of elements in items.
7. If len + argCount > 2⁵³-1, throw a TypeError exception.
8. Repeat, while items is not empty
   1. 1. Remove the first element from items and let E be the value of the element.
      2. Let setStatus be Set(O, ToString(len), E, true).
      3. ReturnIfAbrupt(setStatus).
      4. Let len be len+1.
9. Let setStatus be Set(O, "length", len, true).
10. ReturnIfAbrupt(setStatus).
11. Return len.

The length property of the push method is 1.

Note 2

The push function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

callbackfn should be a function that takes four arguments. reduce calls the callback, as a function, once for each element present in the array, in ascending order.

callbackfn is called with four arguments: the previousValue (value from the previous call to callbackfn), the currentValue (value of the current element), the currentIndex, and the object being traversed. The first time that callback is called, the previousValue and currentValue can be one of two values. If an initialValue was provided in the call to reduce, then previousValue will be equal to initialValue and currentValue will be equal to the first value in the array. If no initialValue was provided, then previousValue will be equal to the first value in the array and currentValue will be equal to the second. It is a TypeError if the array contains no elements and initialValue is not provided.

reduce does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by reduce is set before the first call to callbackfn. Elements that are appended to the array after the call to reduce begins will not be visited by callbackfn. If existing elements of the array are changed, their value as passed to callbackfn will be the value at the time reduce visits them; elements that are deleted after the call to reduce begins and before being visited are not visited.

When the reduce method is called with one or two arguments, the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If IsCallable(callbackfn) is false, throw a TypeError exception.
6. If len is 0 and initialValue is not present, throw a TypeError exception.
7. Let k be 0.
8. If initialValue is present, then
   1. 1. Set accumulator to initialValue.
9. Else initialValue is not present,
   1. 1. Let kPresent be false.
      2. Repeat, while kPresent is false and k < len
         1. 1. Let Pk be ToString(k).
            2. Let kPresent be HasProperty(O, Pk).
            3. ReturnIfAbrupt(kPresent).
            4. If kPresent is true, then
               1. 1. Let accumulator be Get(O, Pk).
                  2. ReturnIfAbrupt(accumulator).
            5. Increase k by 1.
      3. If kPresent is false, throw a TypeError exception.
10. Repeat, while k < len
    1. 1. Let Pk be ToString(k).
       2. Let kPresent be HasProperty(O, Pk).
       3. ReturnIfAbrupt(kPresent).
       4. If kPresent is true, then
          1. 1. Let kValue be Get(O, Pk).
             2. ReturnIfAbrupt(kValue).
             3. Let accumulator be Call(callbackfn, undefined, «accumulator, kValue, k, O»).
             4. ReturnIfAbrupt(accumulator).
       5. Increase k by 1.
11. Return accumulator.

The length property of the reduce method is 1.

Note 2

The reduce function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

callbackfn should be a function that takes four arguments. reduceRight calls the callback, as a function, once for each element present in the array, in descending order.

callbackfn is called with four arguments: the previousValue (value from the previous call to callbackfn), the currentValue (value of the current element), the currentIndex, and the object being traversed. The first time the function is called, the previousValue and currentValue can be one of two values. If an initialValue was provided in the call to reduceRight, then previousValue will be equal to initialValue and currentValue will be equal to the last value in the array. If no initialValue was provided, then previousValue will be equal to the last value in the array and currentValue will be equal to the second-to-last value. It is a TypeError if the array contains no elements and initialValue is not provided.

reduceRight does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by reduceRight is set before the first call to callbackfn. Elements that are appended to the array after the call to reduceRight begins will not be visited by callbackfn. If existing elements of the array are changed by callbackfn, their value as passed to callbackfn will be the value at the time reduceRight visits them; elements that are deleted after the call to reduceRight begins and before being visited are not visited.

When the reduceRight method is called with one or two arguments, the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If IsCallable(callbackfn) is false, throw a TypeError exception.
6. If len is 0 and initialValue is not present, throw a TypeError exception.
7. Let k be len-1.
8. If initialValue is present, then
   1. 1. Set accumulator to initialValue.
9. Else initialValue is not present,
   1. 1. Let kPresent be false.
      2. Repeat, while kPresent is false and k ≥ 0
         1. 1. Let Pk be ToString(k).
            2. Let kPresent be HasProperty(O, Pk).
            3. ReturnIfAbrupt(kPresent).
            4. If kPresent is true, then
               1. 1. Let accumulator be Get(O, Pk).
                  2. ReturnIfAbrupt(accumulator).
            5. Decrease k by 1.
      3. If kPresent is false, throw a TypeError exception.
10. Repeat, while k ≥ 0
    1. 1. Let Pk be ToString(k).
       2. Let kPresent be HasProperty(O, Pk).
       3. ReturnIfAbrupt(kPresent).
       4. If kPresent is true, then
          1. 1. Let kValue be Get(O, Pk).
             2. ReturnIfAbrupt(kValue).
             3. Let accumulator be Call(callbackfn, undefined, «accumulator, kValue, k, »).
             4. ReturnIfAbrupt(accumulator).
       5. Decrease k by 1.
11. Return accumulator.

The length property of the reduceRight method is 1.

Note 2

The reduceRight function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

The elements of the array are rearranged so as to reverse their order. The object is returned as the result of the call.

When the reverse method is called the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. Let middle be floor(len/2).
6. Let lower be 0.
7. Repeat, while lower ≠ middle
   1. 1. Let upper be len- lower -1.
      2. Let upperP be ToString(upper).
      3. Let lowerP be ToString(lower).
      4. Let lowerExists be HasProperty(O, lowerP).
      5. ReturnIfAbrupt(lowerExists).
      6. If lowerExists is true, then
         1. 1. Let lowerValue be Get(O, lowerP).
            2. ReturnIfAbrupt(lowerValue).
      7. Let upperExists be HasProperty(O, upperP).
      8. ReturnIfAbrupt(upperExists).
      9. If upperExists is true, then
         1. 1. Let upperValue be Get(O, upperP).
            2. ReturnIfAbrupt(upperValue).
      10. If lowerExists is true and upperExists is true, then
          1. 1. Let setStatus be Set(O, lowerP, upperValue, true).
             2. ReturnIfAbrupt(setStatus).
             3. Let setStatus be Set(O, upperP, lowerValue, true).
             4. ReturnIfAbrupt(setStatus).
      11. Else if lowerExists is false and upperExists is true, then
          1. 1. Let setStatus be Set(O, lowerP, upperValue, true).
             2. ReturnIfAbrupt(setStatus).
             3. Let deleteStatus be DeletePropertyOrThrow (O, upperP).
             4. ReturnIfAbrupt(deleteStatus).
      12. Else if lowerExists is true and upperExists is false, then
          1. 1. Let deleteStatus be DeletePropertyOrThrow (O, lowerP).
             2. ReturnIfAbrupt(deleteStatus).
             3. Let setStatus be Set(O, upperP, lowerValue, true).
             4. ReturnIfAbrupt(setStatus).
      13. Else both lowerExists and upperExists are false,
          1. 1. No action is required.
      14. Increase lower by 1.
8. Return O .

Note 2

The reverse function is intentionally generic; it does not require that its this value be an Array object. Therefore, it can be transferred to other kinds of objects for use as a method.

Note 1

The first element of the array is removed from the array and returned.

When the shift method is called the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If len is zero, then
   1. 1. Let setStatus be Set(O, "length", 0, true).
      2. ReturnIfAbrupt(setStatus).
      3. Return undefined.
6. Let first be Get(O, "0").
7. ReturnIfAbrupt(first).
8. Let k be 1.
9. Repeat, while k < len
   1. 1. Let from be ToString(k).
      2. Let to be ToString(k-1).
      3. Let fromPresent be HasProperty(O, from).
      4. ReturnIfAbrupt(fromPresent).
      5. If fromPresent is true, then
         1. 1. Let fromVal be Get(O, from).
            2. ReturnIfAbrupt(fromVal).
            3. Let setStatus be Set(O, to, fromVal, true).
            4. ReturnIfAbrupt(setStatus).
      6. Else fromPresent is false,
         1. 1. Let deleteStatus be DeletePropertyOrThrow(O, to).
            2. ReturnIfAbrupt(deleteStatus).
      7. Increase k by 1.
10. Let deleteStatus be DeletePropertyOrThrow(O, ToString(len-1)).
11. ReturnIfAbrupt(deleteStatus).
12. Let setStatus be Set(O, "length", len-1, true).
13. ReturnIfAbrupt(setStatus).
14. Return first.

Note 2

The shift function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

The slice method takes two arguments, start and end, and returns an array containing the elements of the array from element start up to, but not including, element end (or through the end of the array if end is undefined). If start is negative, it is treated as length+start where length is the length of the array. If end is negative, it is treated as length+end where length is the length of the array.

The following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. Let relativeStart be ToInteger(start).
6. ReturnIfAbrupt(relativeStart).
7. If relativeStart < 0, let k be max((len + relativeStart),0); else let k be min(relativeStart, len).
8. If end is undefined, let relativeEnd be len; else let relativeEnd be ToInteger(end).
9. ReturnIfAbrupt(relativeEnd).
10. If relativeEnd < 0, let final be max((len + relativeEnd),0); else let final be min(relativeEnd, len).
11. Let count be max(final - k, 0).
12. Let A be ArraySpeciesCreate(O, count).
13. ReturnIfAbrupt(A).
14. Let n be 0.
15. Repeat, while k < final
    1. 1. Let Pk be ToString(k).
       2. Let kPresent be HasProperty(O, Pk).
       3. ReturnIfAbrupt(kPresent).
       4. If kPresent is true, then
          1. 1. Let kValue be Get(O, Pk).
             2. ReturnIfAbrupt(kValue).
             3. Let status be CreateDataPropertyOrThrow(A, ToString(n), kValue ).
             4. ReturnIfAbrupt(status).
       5. Increase k by 1.
       6. Increase n by 1.
16. Let setStatus be Set(A, "length", n, true).
17. ReturnIfAbrupt(setStatus).
18. Return A.

The length property of the slice method is 2.

Note 2

The explicit setting of the length property of the result Array in step 16 is necessary to ensure that its value is correct in situations where the trailing elements of the result Array are not present.

Note 3

The slice function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

callbackfn should be a function that accepts three arguments and returns a value that is coercible to the Boolean value true or false. some calls callbackfn once for each element present in the array, in ascending order, until it finds one where callbackfn returns true. If such an element is found, some immediately returns true. Otherwise, some returns false. callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.

some does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by some is set before the first call to callbackfn. Elements that are appended to the array after the call to some begins will not be visited by callbackfn. If existing elements of the array are changed, their value as passed to callbackfn will be the value at the time that some visits them; elements that are deleted after the call to some begins and before being visited are not visited. some acts like the "exists" quantifier in mathematics. In particular, for an empty array, it returns false.

When the some method is called with one or two arguments, the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. If IsCallable(callbackfn) is false, throw a TypeError exception.
6. If thisArg was supplied, let T be thisArg; else let T be undefined.
7. Let k be 0.
8. Repeat, while k < len
   1. 1. Let Pk be ToString(k).
      2. Let kPresent be HasProperty(O, Pk).
      3. ReturnIfAbrupt(kPresent).
      4. If kPresent is true, then
         1. 1. Let kValue be Get(O, Pk).
            2. ReturnIfAbrupt(kValue).
            3. Let testResult be ToBoolean(Call(callbackfn, T, «kValue, k, and O»)).
            4. ReturnIfAbrupt(testResult).
            5. If testResult is true, return true.
      5. Increase k by 1.
9. Return false.

The length property of the some method is 1.

Note 2

The some function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

The elements of this array are sorted. The sort is not necessarily stable (that is, elements that compare equal do not necessarily remain in their original order). If comparefn is not undefined, it should be a function that accepts two arguments x and y and returns a negative value if x < y, zero if x = y, or a positive value if x > y.

Upon entry, the following steps are performed to initialize evaluation of the sort function:

1. Let obj be ToObject(this value).
2. Let len be ToLength(Get(obj, "length")).
3. ReturnIfAbrupt(len).

Within this specification of the sort method, an object, obj, is said to be sparse if the following algorithm returns true:

1. For each integer i in the range 0≤i< len
   1. 1. Let elem be obj.[[GetOwnProperty]](ToString(i)).
      2. If elem is undefined, return true.
2. Return false.

The sort order is the ordering, after completion of this function, of the integer indexed property values of obj whose integer indexes are less than len. The result of the sort function is then determined as follows:

If comparefn is not undefined and is not a consistent comparison function for the elements of this array (see below), the sort order is implementation-defined. The sort order is also implementation-defined if comparefn is undefined and SortCompare (22.1.3.24.1) does not act as a consistent comparison function.

Let proto be obj.[[GetPrototypeOf]](). If proto is not null and there exists an integer j such that all of the conditions below are satisfied then the sort order is implementation-defined:

• obj is sparse
• 0 ≤ j < len
• HasProperty(proto, ToString(j)) is true.

The sort order is also implementation defined if obj is sparse and any of the following conditions are true:

• IsExtensible(obj) is false.
• Any integer index property of obj whose name is a nonnegative integer less than len is a data property whose [[Configurable]] attribute is false.

The sort order is also implementation defined if any of the following conditions are true:

• If obj is an exotic object (including Proxy exotic objects) whose behaviour for [[Get]], [[Set]], [[Delete]], and [[GetOwnProperty]] is not the ordinary object implementation of these internal methods.
• If any index index property of obj whose name is a nonnegative integer less than len is an accessor property or is a data property whose [[Writable]] attribute is false.
• If comparefn is undefined and the application of ToString to any value passed as an argument to SortCompare modifies obj or any object on obj's prototype chain.
• If comparefn is undefined and all applications of ToString, to any specific value passed as an argument to SortCompare, do not produce the same result.

The following steps are taken:

1. Perform an implementation-dependent sequence of calls to the [[Get]] and [[Set]] internal methods of obj, to the DeletePropertyOrThrow and HasOwnProperty abstract operation with obj as the first argument, and to SortCompare (described below), such that:
   • • The property key argument for each call to [[Get]], [[Set]], HasOwnProperty, or DeletePropertyOrThrow is the string representation of a nonnegative integer less than len.
     • The arguments for calls to SortCompare are values returned by a previous call to the [[Get]] internal method, unless the properties accessed by those previous calls did not exist according to HasOwnProperty. If both perspective arguments to SortCompare correspond to non-existent properties, use +0 instead of calling SortCompare. If only the first perspective argument is non-existent use +1. If only the second perspective argument is non-existent use -1.
     • If obj is not sparse then DeletePropertyOrThrow must not be called.
     • If any [[Set]] call returns false a TypeError exception is thrown.
     • If an abrupt completion is returned from any of these operations, it is immediately returned as the value of this function.
2. Return obj.

Unless the sort order is specified above to be implementation-defined, the returned object must have the following two characteristics:

• There must be some mathematical permutation π of the nonnegative integers less than len, such that for every nonnegative integer j less than len, if property old[j] existed, then new[π(j)] is exactly the same value as old[j]. But if property old[j] did not exist, then new[π(j)] does not exist.
• Then for all nonnegative integers j and k, each less than len, if SortCompare(old[j], old[k]) < 0 (see SortCompare below), then new[π(j)] < new[π(k)].

Here the notation old[j] is used to refer to the hypothetical result of calling the [[Get]] internal method of obj with argument j before this function is executed, and the notation new[j] to refer to the hypothetical result of calling the [[Get]] internal method of obj with argument j after this function has been executed.

A function comparefn is a consistent comparison function for a set of values S if all of the requirements below are met for all values a, b, and c (possibly the same value) in the set S: The notation a <_CF b means comparefn(a,b) < 0; a =_CF b means comparefn(a,b) = 0 (of either sign); and a >_CF b means comparefn(a,b) > 0.

• Calling comparefn(a,b) always returns the same value v when given a specific pair of values a and b as its two arguments. Furthermore, Type(v) is Number, and v is not NaN. Note that this implies that exactly one of a <_CF b, a =_CF b, and a >_CF b will be true for a given pair of a and b.
• Calling comparefn(a,b) does not modify obj or any object on obj's prototype chain.
• a =_CF a (reflexivity)
• If a =_CF b, then b =_CF a (symmetry)
• If a =_CF b and b =_CF c, then a =_CF c (transitivity of =_CF)
• If a <_CF b and b <_CF c, then a <_CF c (transitivity of <_CF)
• If a >_CF b and b >_CF c, then a >_CF c (transitivity of >_CF)

Note 1

The above conditions are necessary and sufficient to ensure that comparefn divides the set S into equivalence classes and that these equivalence classes are totally ordered.

Note 2

The sort function is intentionally generic; it does not require that its this value be an Array object. Therefore, it can be transferred to other kinds of objects for use as a method.

Note 1

When the splice method is called with two or more arguments start, deleteCount and zero or more items, the deleteCount elements of the array starting at integer index start are replaced by the arguments items. An Array object containing the deleted elements (if any) is returned.

The following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. Let relativeStart be ToInteger(start).
6. ReturnIfAbrupt(relativeStart).
7. If relativeStart < 0, let actualStart be max((len + relativeStart),0); else let actualStart be min(relativeStart, len).
8. If the number of actual arguments is 0, then
   1. 1. Let insertCount be 0.
      2. Let actualDeleteCount be 0.
9. Else if the number of actual arguments is 1, then
   1. 1. Let insertCount be 0.
      2. Let actualDeleteCount be len - actualStart.
10. Else,
    1. 1. Let insertCount be the number of actual arguments minus 2.
       2. Let dc be ToInteger(deleteCount).
       3. ReturnIfAbrupt(dc).
       4. Let actualDeleteCount be min(max(dc,0), len - actualStart).
11. If len+insertCount-actualDeleteCount > 2⁵³-1, throw a TypeError exception.
12. Let A be ArraySpeciesCreate(O, actualDeleteCount).
13. ReturnIfAbrupt(A).
14. Let k be 0.
15. Repeat, while k < actualDeleteCount
    1. 1. Let from be ToString(actualStart+k).
       2. Let fromPresent be HasProperty(O, from).
       3. ReturnIfAbrupt(fromPresent).
       4. If fromPresent is true, then
          1. 1. Let fromValue be Get(O, from).
             2. ReturnIfAbrupt(fromValue).
             3. Let status be CreateDataPropertyOrThrow(A, ToString(k), fromValue).
             4. ReturnIfAbrupt(status).
       5. Increment k by 1.
16. Let setStatus be Set(A, "length", actualDeleteCount, true).
17. ReturnIfAbrupt(setStatus).
18. Let items be a List whose elements are, in left to right order, the portion of the actual argument list starting with the third argument. The list is empty if fewer than three arguments were passed.
19. Let itemCount be the number of elements in items.
20. If itemCount < actualDeleteCount, then
    1. 1. Let k be actualStart.
       2. Repeat, while k < (len - actualDeleteCount)
          1. 1. Let from be ToString(k+actualDeleteCount).
             2. Let to be ToString(k+itemCount).
             3. Let fromPresent be HasProperty(O, from).
             4. ReturnIfAbrupt(fromPresent).
             5. If fromPresent is true, then
                1. 1. Let fromValue be Get(O, from).
                   2. ReturnIfAbrupt(fromValue).
                   3. Let setStatus be Set(O, to, fromValue, true).
                   4. ReturnIfAbrupt(setStatus).
             6. Else fromPresent is false,
                1. 1. Let deleteStatus be DeletePropertyOrThrow(O, to).
                   2. ReturnIfAbrupt(deleteStatus).
             7. Increase k by 1.
       3. Let k be len.
       4. Repeat, while k > (len - actualDeleteCount + itemCount)
          1. 1. Let deleteStatus be DeletePropertyOrThrow(O, ToString(k-1)).
             2. ReturnIfAbrupt(deleteStatus).
             3. Decrease k by 1.
21. Else if itemCount > actualDeleteCount, then
    1. 1. Let k be (len - actualDeleteCount).
       2. Repeat, while k > actualStart
          1. 1. Let from be ToString(k + actualDeleteCount - 1).
             2. Let to be ToString(k + itemCount - 1)
             3. Let fromPresent be HasProperty(O, from).
             4. ReturnIfAbrupt(fromPresent).
             5. If fromPresent is true, then
                1. 1. Let fromValue be Get(O, from).
                   2. ReturnIfAbrupt(fromValue).
                   3. Let setStatus be Set(O, to, fromValue, true).
                   4. ReturnIfAbrupt(setStatus).
             6. Else fromPresent is false,
                1. 1. Let deleteStatus be DeletePropertyOrThrow(O, to).
                   2. ReturnIfAbrupt(deleteStatus).
             7. Decrease k by 1.
22. Let k be actualStart.
23. Repeat, while items is not empty
    1. 1. Remove the first element from items and let E be the value of that element.
       2. Let setStatus be Set(O, ToString(k), E, true).
       3. ReturnIfAbrupt(setStatus).
       4. Increase k by 1.
24. Let setStatus be Set(O, "length", len - actualDeleteCount + itemCount, true).
25. ReturnIfAbrupt(setStatus).
26. Return A.

The length property of the splice method is 2.

Note 2

The explicit setting of the length property of the result Array in step 24 is necessary to ensure that its value is correct in situations where its trailing elements are not present.

Note 3

The splice function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement the Array.prototype.toLocaleString method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of the toLocaleString method is used.

Note 1

The first edition of ECMA-402 did not include a replacement specification for the Array.prototype.toLocaleString method.

The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.

The following steps are taken:

1. Let array be ToObject(this value).
2. ReturnIfAbrupt(array).
3. Let len be ToLength(Get(array, "length")).
4. ReturnIfAbrupt(len).
5. Let separator be the String value for the list-separator String appropriate for the host environment's current locale (this is derived in an implementation-defined way).
6. If len is zero, return the empty String.
7. Let firstElement be Get(array, "0").
8. ReturnIfAbrupt(firstElement).
9. If firstElement is undefined or null, then
   1. 1. Let R be the empty String.
10. Else
    1. 1. Let R be ToString(Invoke(firstElement, "toLocaleString")).
       2. ReturnIfAbrupt(R).
11. Let k be 1.
12. Repeat, while k < len
    1. 1. Let S be a String value produced by concatenating R and separator.
       2. Let nextElement be Get(array, ToString(k)).
       3. ReturnIfAbrupt(nextElement).
       4. If nextElement is undefined or null, then
          1. 1. Let R be the empty String.
       5. Else
          1. 1. Let R be ToString(Invoke(nextElement, "toLocaleString")).
             2. ReturnIfAbrupt(R).
       6. Let R be a String value produced by concatenating S and R.
       7. Increase k by 1.
13. Return R.

Note 2

The elements of the array are converted to Strings using their toLocaleString methods, and these Strings are then concatenated, separated by occurrences of a separator String that has been derived in an implementation-defined locale-specific way. The result of calling this function is intended to be analogous to the result of toString, except that the result of this function is intended to be locale-specific.

Note 3

The toLocaleString function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

When the toString method is called, the following steps are taken:

1. Let array be ToObject(this value).
2. ReturnIfAbrupt(array).
3. Let func be Get(array, "join").
4. ReturnIfAbrupt(func).
5. If IsCallable(func) is false, let func be the intrinsic function %ObjProto_toString% (19.1.3.6).
6. Return Call(func, array).

Note

The toString function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Note 1

The arguments are prepended to the start of the array, such that their order within the array is the same as the order in which they appear in the argument list.

When the unshift method is called with zero or more arguments item1, item2, etc., the following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Let len be ToLength(Get(O, "length")).
4. ReturnIfAbrupt(len).
5. Let argCount be the number of actual arguments.
6. If argCount > 0, then
   1. 1. If len+ argCount > 2⁵³-1, throw a TypeError exception.
      2. Let k be len.
      3. Repeat, while k > 0,
         1. 1. Let from be ToString(k-1).
            2. Let to be ToString(k+argCount -1).
            3. Let fromPresent be HasProperty(O, from).
            4. ReturnIfAbrupt(fromPresent).
            5. If fromPresent is true, then
               1. 1. Let fromValue be Get(O, from).
                  2. ReturnIfAbrupt(fromValue).
                  3. Let setStatus be Set(O, to, fromValue, true).
                  4. ReturnIfAbrupt(setStatus).
            6. Else fromPresent is false,
               1. 1. Let deleteStatus be DeletePropertyOrThrow(O, to).
                  2. ReturnIfAbrupt(deleteStatus).
            7. Decrease k by 1.
      4. Let j be 0.
      5. Let items be a List whose elements are, in left to right order, the arguments that were passed to this function invocation.
      6. Repeat, while items is not empty
         1. 1. Remove the first element from items and let E be the value of that element.
            2. Let setStatus be Set(O, ToString(j), E, true).
            3. ReturnIfAbrupt(setStatus).
            4. Increase j by 1.
7. Let setStatus be Set(O, "length", len+argCount, true).
8. ReturnIfAbrupt(setStatus).
9. Return len+argCount.

The length property of the unshift method is 1.

Note 2

The unshift function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

The following steps are taken:

1. Let O be ToObject(this value).
2. ReturnIfAbrupt(O).
3. Return CreateArrayIterator(O, "value").

This function is the %ArrayProto_values% intrinsic object.

The initial value of the @@iterator property is the same function object as the initial value of the Array.prototype.values property.

The initial value of the @@unscopables data property is an object created by the following steps:

1. Let blackList be ObjectCreate(null).
2. Perform CreateDataProperty(blackList, "copyWithin", true).
3. Perform CreateDataProperty(blackList, "entries", true).
4. Perform CreateDataProperty(blackList, "fill", true).
5. Perform CreateDataProperty(blackList, "find", true).
6. Perform CreateDataProperty(blackList, "findIndex", true).
7. Perform CreateDataProperty(blackList, "keys", true).
8. Perform CreateDataProperty(blackList, "values", true).
9. Assert: Each of the above calls will return true.
10. Return blackList.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

Note

The own property names of this object are property names that were not included as standard properties of Array.prototype prior to the ECMAScript 2015 specification. These names are ignored for with statement binding purposes in order to preserve the behaviour of existing code that might use one of these names as a binding in an outer scope that is shadowed by a with statement whose binding object is an Array object.

The length property of an Array instance is a data property whose value is always numerically greater than the name of every configurable own property whose name is an array index.

The length property initially has the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.

Note

Reducing the value of the length property has the side-effect of deleting own array elements whose array index is between the old and new length values. However, non-configurable properties can not be deleted. Attempting to set the length property of an Array object to a value that is numerically less than or equal to the largest numeric own property name of an existing non-configurable array indexed property of the array will result in the length being set to a numeric value that is one greater than that non-configurable numeric own property name. See 9.4.2.1.

Several methods of Array objects return Iterator objects. The abstract operation CreateArrayIterator with arguments array and kind is used to create such iterator objects. It performs the following steps:

1. Assert: Type(array) is Object.
2. Let iterator be ObjectCreate(%ArrayIteratorPrototype%, «[[IteratedObject]], [[ArrayIteratorNextIndex]], [[ArrayIterationKind]]»).
3. Set iterator's [[IteratedObject]] internal slot to array.
4. Set iterator's [[ArrayIteratorNextIndex]] internal slot to 0.
5. Set iterator's [[ArrayIterationKind]] internal slot to kind.
6. Return iterator.

All Array Iterator Objects inherit properties from the %ArrayIteratorPrototype% intrinsic object. The %ArrayIteratorPrototype% object is an ordinary object and its [[Prototype]] internal slot is the %IteratorPrototype% intrinsic object (25.1.2). In addition, %ArrayIteratorPrototype% has the following properties:

Array Iterator instances are ordinary objects that inherit properties from the %ArrayIteratorPrototype% intrinsic object. Array Iterator instances are initially created with the internal slots listed in Table 48.

Internal Slot	Description
[[IteratedObject]]	The object whose array elements are being iterated.
[[ArrayIteratorNextIndex]]	The integer index of the next integer index to be examined by this iteration.
[[ArrayIterationKind]]	A String value that identifies what is returned for each element of the iteration. The possible values are: "key", "value", "key+value".

This description applies only if the %TypedArray% function is called with no arguments.

1. If NewTarget is undefined, throw a TypeError exception.
2. Return AllocateTypedArray(NewTarget, 0).

This description applies only if the %TypedArray% function is called with at least one argument and the Type of the first argument is not Object.

%TypedArray% called with argument length performs the following steps:

1. Assert: Type(length) is not Object.
2. If NewTarget is undefined, throw a TypeError exception.
3. If length is undefined, throw a TypeError exception.
4. Let numberLength be ToNumber(length).
5. Let elementLength be ToLength(numberLength).
6. ReturnIfAbrupt(elementLength).
7. If SameValueZero(numberLength, elementLength) is false, throw a RangeError exception.
8. Return AllocateTypedArray(NewTarget, elementLength).

This description applies only if the %TypedArray% function is called with at least one argument and the Type of the first argument is Object and that object has a [[TypedArrayName]] internal slot.

%TypedArray% called with argument typedArray performs the following steps:

1. Assert: Type(typedArray) is Object and typedArray has a [[TypedArrayName]] internal slot.
2. If NewTarget is undefined, throw a TypeError exception.
3. Let O be AllocateTypedArray(NewTarget).
4. ReturnIfAbrupt(O).
5. Let srcArray be typedArray.
6. Let srcData be the value of srcArray's [[ViewedArrayBuffer]] internal slot.
7. If IsDetachedBuffer(srcData) is true, throw a TypeError exception.
8. Let constructorName be the String value of O's [[TypedArrayName]] internal slot.
9. Let elementType be the String value of the Element Type value in Table 49 for constructorName.
10. Let elementLength be the value of srcArray's [[ArrayLength]] internal slot.
11. Let srcName be the String value of srcArray's [[TypedArrayName]] internal slot.
12. Let srcType be the String value of the Element Type value in Table 49 for srcName.
13. Let srcElementSize be the Element Size value in Table 49 for srcName.
14. Let srcByteOffset be the value of srcArray's [[ByteOffset]] internal slot.
15. Let elementSize be the Element Size value in Table 49 for constructorName.
16. Let byteLength be elementSize × elementLength.
17. If SameValue(elementType,srcType) is true, then
    1. 1. Let data be CloneArrayBuffer(srcData, srcByteOffset).
       2. ReturnIfAbrupt(data).
18. Else,
    1. 1. Let bufferConstructor be SpeciesConstructor(srcData, %ArrayBuffer%).
       2. ReturnIfAbrupt(bufferConstructor).
       3. Let data be AllocateArrayBuffer(bufferConstructor, byteLength).
       4. ReturnIfAbrupt(data).
       5. If IsDetachedBuffer(srcData) is true, throw a TypeError exception.
       6. Let srcByteIndex be srcByteOffset.
       7. Let targetByteIndex be 0.
       8. Let count be elementLength.
       9. Repeat, while count >0
          1. 1. Let value be GetValueFromBuffer(srcData, srcByteIndex, srcType).
             2. Perform SetValueInBuffer(data, targetByteIndex, elementType, value).
             3. Set srcByteIndex to srcByteIndex + srcElementSize.
             4. Set targetByteIndex to targetByteIndex + elementSize.
             5. Decrement count by 1.
19. Set O's [[ViewedArrayBuffer]] internal slot to data.
20. Set O's [[ByteLength]] internal slot to byteLength.
21. Set O's [[ByteOffset]] internal slot to 0.
22. Set O's [[ArrayLength]] internal slot to elementLength.
23. Return O.

This description applies only if the %TypedArray% function is called with at least one argument and the Type of the first argument is Object and that object does not have either a [[TypedArrayName]] or an [[ArrayBufferData]] internal slot.

%TypedArray% called with argument object performs the following steps:

1. Assert: Type(object) is Object and object does not have either a [[TypedArrayName]] or an [[ArrayBufferData]] internal slot.
2. If NewTarget is undefined, throw a TypeError exception.
3. Return TypedArrayFrom(NewTarget, object, undefined, undefined).

This description applies only if the %TypedArray% function is called with at least one argument and the Type of the first argument is Object and that object has an [[ArrayBufferData]] internal slot.

%TypedArray% called with arguments buffer, byteOffset, and length performs the following steps:

1. Assert: Type(buffer) is Object and buffer has an [[ArrayBufferData]] internal slot.
2. If NewTarget is undefined, throw a TypeError exception.
3. Let O be AllocateTypedArray(NewTarget).
4. ReturnIfAbrupt(O).
5. Let constructorName be the String value of O's [[TypedArrayName]] internal slot.
6. Let elementSize be the Number value of the Element Size value in Table 49 for constructorName.
7. Let offset be ToInteger(byteOffset).
8. ReturnIfAbrupt(offset).
9. If offset < 0, throw a RangeError exception.
10. If offset modulo elementSize ≠ 0, throw a RangeError exception.
11. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
12. Let bufferByteLength be the value of buffer's [[ArrayBufferByteLength]] internal slot.
13. If length is undefined, then
    1. 1. If bufferByteLength modulo elementSize ≠ 0, throw a RangeError exception.
       2. Let newByteLength be bufferByteLength - offset.
       3. If newByteLength < 0, throw a RangeError exception.
14. Else,
    1. 1. Let newLength be ToLength(length).
       2. ReturnIfAbrupt(newLength).
       3. Let newByteLength be newLength × elementSize.
       4. If offset+newByteLength > bufferByteLength, throw a RangeError exception.
15. Set O's [[ViewedArrayBuffer]] internal slot to buffer.
16. Set O's [[ByteLength]] internal slot to newByteLength.
17. Set O's [[ByteOffset]] internal slot to offset.
18. Set O's [[ArrayLength]] internal slot to newByteLength / elementSize .
19. Return O.

When the from method is called with argument source, and optional arguments mapfn and thisArg, the following steps are taken:

1. Let C be the this value.
2. If IsConstructor(C) is false, throw a TypeError exception.
3. If mapfn was supplied, let f be mapfn; otherwise let f be undefined.
4. If f is not undefined, then
   1. 1. If IsCallable(f) is false, throw a TypeError exception.
5. If thisArg was supplied, let t be thisArg; else let t be undefined.
6. Return TypedArrayFrom(C, source, f, t).

The length property of the from method is 1.

When the of method is called with any number of arguments, the following steps are taken:

1. Let len be the actual number of arguments passed to this function.
2. Let items be the List of arguments passed to this function.
3. Let C be the this value.
4. If IsConstructor(C) is false, throw a TypeError exception.
5. Let newObj be AllocateTypedArray(C, len).
6. ReturnIfAbrupt(newObj).
7. Let k be 0.
8. Repeat, while k < len
   1. 1. Let kValue be items[k].
      2. Let Pk be ToString(k).
      3. Let status be Set(newObj, Pk, kValue, true).
      4. ReturnIfAbrupt(status).
      5. Increase k by 1.
9. Return newObj.

The length property of the of method is 0.

Note

The items argument is assumed to be a well-formed rest argument value.

The initial value of %TypedArray%.prototype is the %TypedArrayPrototype% intrinsic object (22.2.3).

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

%TypedArray%[@@species] is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps:

1. Return the this value.

The value of the name property of this function is "get [Symbol.species]".

Note

%TypedArrayPrototype% methods normally use their this object's constructor to create a derived object. However, a subclass constructor may over-ride that default behaviour by redefining its @@species property.

%TypedArray%.prototype.buffer is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps:

1. Let O be the this value.
2. If Type(O) is not Object, throw a TypeError exception.
3. If O does not have a [[ViewedArrayBuffer]] internal slot, throw a TypeError exception.
4. Let buffer be the value of O's [[ViewedArrayBuffer]] internal slot.
5. Return buffer.

%TypedArray%.prototype.byteLength is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps:

1. Let O be the this value.
2. If Type(O) is not Object, throw a TypeError exception.
3. If O does not have a [[ViewedArrayBuffer]] internal slot, throw a TypeError exception.
4. Let buffer be the value of O's [[ViewedArrayBuffer]] internal slot.
5. If IsDetachedBuffer(buffer) is true, return 0.
6. Let size be the value of O's [[ByteLength]] internal slot.
7. Return size.

%TypedArray%.prototype.byteOffset is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps:

1. Let O be the this value.
2. If Type(O) is not Object, throw a TypeError exception.
3. If O does not have a [[ViewedArrayBuffer]] internal slot, throw a TypeError exception.
4. Let buffer be the value of O's [[ViewedArrayBuffer]] internal slot.
5. If IsDetachedBuffer(buffer) is true, return 0.
6. Let offset be the value of O's [[ByteOffset]] internal slot.
7. Return offset.

The initial value of %TypedArray%.prototype.constructor is the %TypedArray% intrinsic object.

%TypedArray%.prototype.copyWithin is a distinct function that implements the same algorithm as Array.prototype.copyWithin as defined in 22.1.3.3 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length" and the actual copying of values in step 17 must be performed in a manner that preserves the bit-level encoding of the source data

The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

The length property of the copyWithin method is 2.

The following steps are taken:

1. Let O be the this value.
2. Let valid be ValidateTypedArray(O).
3. ReturnIfAbrupt(valid).
4. Return CreateArrayIterator(O, "key+value").

%TypedArray%.prototype.every is a distinct function that implements the same algorithm as Array.prototype.every as defined in 22.1.3.5 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length". The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to callbackfn may cause the this value to become detached.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

The length property of the every method is 1.

%TypedArray%.prototype.fill is a distinct function that implements the same algorithm as Array.prototype.fill as defined in 22.1.3.6 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length". The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

The length property of the fill method is 1.

The interpretation and use of the arguments of %TypedArray%.prototype.filter are the same as for Array.prototype.filter as defined in 22.1.3.7.

When the filter method is called with one or two arguments, the following steps are taken:

1. Let O be the this value.
2. Let valid be ValidateTypedArray(O).
3. ReturnIfAbrupt(valid).
4. Let len be the value of O's [[ArrayLength]] internal slot.
5. If IsCallable(callbackfn) is false, throw a TypeError exception.
6. If thisArg was supplied, let T be thisArg; else let T be undefined.
7. Let defaultConstructor be the intrinsic object listed in column one of Table 49 for the value of O's [[TypedArrayName]] internal slot.
8. Let C be SpeciesConstructor(O, defaultConstructor).
9. ReturnIfAbrupt(C).
10. Let kept be a new empty List.
11. Let k be 0.
12. Let captured be 0.
13. Repeat, while k < len
    1. 1. Let Pk be ToString(k).
       2. Let kValue be Get(O, Pk).
       3. ReturnIfAbrupt(kValue).
       4. Let selected be ToBoolean(Call(callbackfn, T, «kValue, k, O»)).
       5. ReturnIfAbrupt(selected).
       6. If selected is true, then
          1. 1. Append kValue to the end of kept.
             2. Increase captured by 1.
       7. Increase k by 1.
14. Let A be AllocateTypedArray(C, captured).
15. ReturnIfAbrupt(A).
16. Let n be 0.
17. For each element e of kept
    1. 1. Let status be Set(A, ToString(n), e, true ).
       2. ReturnIfAbrupt(status).
       3. Increment n by 1.
18. Return A.

This function is not generic. The this value must be an object with a [[TypedArrayName]] internal slot.

The length property of the filter method is 1.

%TypedArray%.prototype.find is a distinct function that implements the same algorithm as Array.prototype.find as defined in 22.1.3.8 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length". The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to predicate may cause the this value to become detached.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

The length property of the find method is 1.

%TypedArray%.prototype.findIndex is a distinct function that implements the same algorithm as Array.prototype.findIndex as defined in 22.1.3.9 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length". The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to predicate may cause the this value to become detached.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

The length property of the findIndex method is 1.

%TypedArray%.prototype.forEach is a distinct function that implements the same algorithm as Array.prototype.forEach as defined in 22.1.3.10 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length". The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to callbackfn may cause the this value to become detached.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

The length property of the forEach method is 1.

%TypedArray%.prototype.indexOf is a distinct function that implements the same algorithm as Array.prototype.indexOf as defined in 22.1.3.11 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length". The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

The length property of the indexOf method is 1.

%TypedArray%.prototype.join is a distinct function that implements the same algorithm as Array.prototype.join as defined in 22.1.3.12 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length". The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

The following steps are taken:

1. Let O be the this value.
2. Let valid be ValidateTypedArray(O).
3. ReturnIfAbrupt(valid).
4. Return CreateArrayIterator(O, "key").

%TypedArray%.prototype.lastIndexOf is a distinct function that implements the same algorithm as Array.prototype.lastIndexOf as defined in 22.1.3.14 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length". The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

The length property of the lastIndexOf method is 1.

%TypedArray%.prototype.length is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps:

1. Let O be the this value.
2. If Type(O) is not Object, throw a TypeError exception.
3. If O does not have a [[TypedArrayName]] internal slot, throw a TypeError exception.
4. Assert: O has [[ViewedArrayBuffer]] and [[ArrayLength]] internal slots.
5. Let buffer be the value of O's [[ViewedArrayBuffer]] internal slot.
6. If IsDetachedBuffer(buffer) is true, return 0.
7. Let length be the value of O's [[ArrayLength]] internal slot.
8. Return length.

This function is not generic. The this value must be an object with a [[TypedArrayName]] internal slot.

The interpretation and use of the arguments of %TypedArray%.prototype.map are the same as for Array.prototype.map as defined in 22.1.3.15.

When the map method is called with one or two arguments, the following steps are taken:

1. Let O be the this value.
2. Let valid be ValidateTypedArray(O).
3. ReturnIfAbrupt(valid).
4. Let len be the value of O's [[ArrayLength]] internal slot.
5. If IsCallable(callbackfn) is false, throw a TypeError exception.
6. If thisArg was supplied, let T be thisArg; else let T be undefined.
7. Let defaultConstructor be the intrinsic object listed in column one of Table 49 for the value of O's [[TypedArrayName]] internal slot.
8. Let C be SpeciesConstructor(O, defaultConstructor).
9. ReturnIfAbrupt(C).
10. Let A be AllocateTypedArray(C, len).
11. ReturnIfAbrupt(A).
12. Let k be 0.
13. Repeat, while k < len
    1. 1. Let Pk be ToString(k).
       2. Let kValue be Get(O, Pk).
       3. ReturnIfAbrupt(kValue).
       4. Let mappedValue be Call(callbackfn, T, «kValue, k, O»).
       5. ReturnIfAbrupt(mappedValue).
       6. Let status be Set(A, Pk, mappedValue, true ).
       7. ReturnIfAbrupt(status).
       8. Increase k by 1.
14. Return A.

This function is not generic. The this value must be an object with a [[TypedArrayName]] internal slot.

The length property of the map method is 1.

%TypedArray%.prototype.reduce is a distinct function that implements the same algorithm as Array.prototype.reduce as defined in 22.1.3.18 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length". The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to callbackfn may cause the this value to become detached.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

The length property of the reduce method is 1.

%TypedArray%.prototype.reduceRight is a distinct function that implements the same algorithm as Array.prototype.reduceRight as defined in 22.1.3.19 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length". The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm and must take into account the possibility that calls to callbackfn may cause the this value to become detached.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

The length property of the reduceRight method is 1.

%TypedArray%.prototype.reverse is a distinct function that implements the same algorithm as Array.prototype.reverse as defined in 22.1.3.20 except that the this object's [[ArrayLength]] internal slot is accessed in place of performing a [[Get]] of "length". The implementation of the algorithm may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the algorithm.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the algorithm. If its result is an abrupt completion that exception is thrown instead of evaluating the algorithm.

%TypedArray%.prototype.set is a single function whose behaviour is overloaded based upon the type of its first argument.

This function is not generic. The this value must be an object with a [[TypedArrayName]] internal slot.

The length property of the set method is 1.