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, "%Array.prototype%").
5. 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, "%Array.prototype%").
5. Let array be ! ArrayCreate(0, proto).
6. If Type(len) is not Number, then
   1. Perform ! CreateDataPropertyOrThrow(array, "0", len).
   2. Let intLen be 1.
7. Else,
   1. Let intLen be ToUint32(len).
   2. If intLen ≠ len, throw a RangeError exception.
8. Perform ! Set(array, "length", intLen, true).
9. 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, "%Array.prototype%").
5. Let array be ? ArrayCreate(numberOfArgs, proto).
6. Let k be 0.
7. Let items be a zero-origined List containing the argument items in order.
8. Repeat, while k < numberOfArgs
   1. Let Pk be ! ToString(k).
   2. Let itemK be items[k].
   3. Perform ! CreateDataPropertyOrThrow(array, Pk, itemK).
   4. Set k to k + 1.
9. Assert: The value of array's "length" property is numberOfArgs.
10. 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. If IsCallable(mapfn) is false, throw a TypeError exception.
   2. Let mapping be true.
4. Let usingIterator be ? GetMethod(items, @@iterator).
5. If usingIterator is not undefined, then
   1. If IsConstructor(C) is true, then
      1. Let A be ? Construct(C).
   2. Else,
      1. Let A be ! ArrayCreate(0).
   3. Let iteratorRecord be ? GetIterator(items, sync, usingIterator).
   4. Let k be 0.
   5. Repeat,
      1. If k ≥ 2⁵³ - 1, then
         1. Let error be ThrowCompletion(a newly created TypeError object).
         2. Return ? IteratorClose(iteratorRecord, error).
      2. Let Pk be ! ToString(k).
      3. Let next be ? IteratorStep(iteratorRecord).
      4. If next is false, then
         1. Perform ? Set(A, "length", k, true).
         2. Return A.
      5. Let nextValue be ? IteratorValue(next).
      6. If mapping is true, then
         1. Let mappedValue be Call(mapfn, thisArg, « nextValue, k »).
         2. If mappedValue is an abrupt completion, return ? IteratorClose(iteratorRecord, mappedValue).
         3. Set mappedValue to mappedValue.[[Value]].
      7. Else, let mappedValue be nextValue.
      8. Let defineStatus be CreateDataPropertyOrThrow(A, Pk, mappedValue).
      9. If defineStatus is an abrupt completion, return ? IteratorClose(iteratorRecord, defineStatus).
      10. Set k to k + 1.
6. NOTE: items is not an Iterable so assume it is an array-like object.
7. Let arrayLike be ! ToObject(items).
8. Let len be ? LengthOfArrayLike(arrayLike).
9. If IsConstructor(C) is true, then
   1. Let A be ? Construct(C, « len »).
10. Else,
    1. Let A be ? ArrayCreate(len).
11. Let k be 0.
12. Repeat, while k < len
    1. Let Pk be ! ToString(k).
    2. Let kValue be ? Get(arrayLike, Pk).
    3. If mapping is true, then
       1. Let mappedValue be ? Call(mapfn, thisArg, « kValue, k »).
    4. Else, let mappedValue be kValue.
    5. Perform ? CreateDataPropertyOrThrow(A, Pk, mappedValue).
    6. Set k to k + 1.
13. Perform ? Set(A, "length", len, true).
14. Return A.

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. Let A be ? Construct(C, « len »).
5. Else,
   1. Let A be ? ArrayCreate(len).
6. Let k be 0.
7. Repeat, while k < len
   1. Let kValue be items[k].
   2. Let Pk be ! ToString(k).
   3. Perform ? CreateDataPropertyOrThrow(A, Pk, kValue).
   4. Set k to k + 1.
8. Perform ? Set(A, "length", len, true).
9. Return A.

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 %Array.prototype%, the intrinsic Array prototype object.

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. Let A be ? ArraySpeciesCreate(O, 0).
3. Let n be 0.
4. 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.
5. Repeat, while items is not empty
   1. Remove the first element from items and let E be the value of the element.
   2. Let spreadable be ? IsConcatSpreadable(E).
   3. If spreadable is true, then
      1. Let k be 0.
      2. Let len be ? LengthOfArrayLike(E).
      3. If n + len > 2⁵³ - 1, throw a TypeError exception.
      4. Repeat, while k < len
         1. Let P be ! ToString(k).
         2. Let exists be ? HasProperty(E, P).
         3. If exists is true, then
            1. Let subElement be ? Get(E, P).
            2. Perform ? CreateDataPropertyOrThrow(A, ! ToString(n), subElement).
         4. Set n to n + 1.
         5. Set k to k + 1.
   4. Else,
      1. NOTE: E is added as a single item rather than spread.
      2. If n ≥ 2⁵³ - 1, throw a TypeError exception.
      3. Perform ? CreateDataPropertyOrThrow(A, ! ToString(n), E).
      4. Set n to n + 1.
6. Perform ? Set(A, "length", n, true).
7. Return A.

The "length" property of the concat method is 1.

Note 1

The explicit setting of the "length" property in step 6 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 %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. Let len be ? LengthOfArrayLike(O).
3. Let relativeTarget be ? ToInteger(target).
4. If relativeTarget < 0, let to be max((len + relativeTarget), 0); else let to be min(relativeTarget, len).
5. Let relativeStart be ? ToInteger(start).
6. If relativeStart < 0, let from be max((len + relativeStart), 0); else let from be min(relativeStart, len).
7. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
8. If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
9. Let count be min(final - from, len - to).
10. If from < to and to < from + count, then
    1. Let direction be -1.
    2. Set from to from + count - 1.
    3. Set to to to + count - 1.
11. Else,
    1. Let direction be 1.
12. Repeat, while count > 0
    1. Let fromKey be ! ToString(from).
    2. Let toKey be ! ToString(to).
    3. Let fromPresent be ? HasProperty(O, fromKey).
    4. If fromPresent is true, then
       1. Let fromVal be ? Get(O, fromKey).
       2. Perform ? Set(O, toKey, fromVal, true).
    5. Else,
       1. Assert: fromPresent is false.
       2. Perform ? DeletePropertyOrThrow(O, toKey).
    6. Set from to from + direction.
    7. Set to to to + direction.
    8. Set count to count - 1.
13. Return O.

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. Return CreateArrayIterator(O, key+value).

This function is the %ArrayProto_entries% intrinsic object.

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. Let len be ? LengthOfArrayLike(O).
3. If IsCallable(callbackfn) is false, throw a TypeError exception.
4. Let k be 0.
5. Repeat, while k < len
   1. Let Pk be ! ToString(k).
   2. Let kPresent be ? HasProperty(O, Pk).
   3. If kPresent is true, then
      1. Let kValue be ? Get(O, Pk).
      2. Let testResult be ! ToBoolean(? Call(callbackfn, thisArg, « kValue, k, O »)).
      3. If testResult is false, return false.
   4. Set k to k + 1.
6. Return true.

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. Let len be ? LengthOfArrayLike(O).
3. Let relativeStart be ? ToInteger(start).
4. If relativeStart < 0, let k be max((len + relativeStart), 0); else let k be min(relativeStart, len).
5. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
6. If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
7. Repeat, while k < final
   1. Let Pk be ! ToString(k).
   2. Perform ? Set(O, Pk, value, true).
   3. Set k to k + 1.
8. Return O.

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. Let len be ? LengthOfArrayLike(O).
3. If IsCallable(callbackfn) is false, throw a TypeError exception.
4. Let A be ? ArraySpeciesCreate(O, 0).
5. Let k be 0.
6. Let to be 0.
7. Repeat, while k < len
   1. Let Pk be ! ToString(k).
   2. Let kPresent be ? HasProperty(O, Pk).
   3. If kPresent is true, then
      1. Let kValue be ? Get(O, Pk).
      2. Let selected be ! ToBoolean(? Call(callbackfn, thisArg, « kValue, k, O »)).
      3. If selected is true, then
         1. Perform ? CreateDataPropertyOrThrow(A, ! ToString(to), kValue).
         2. Set to to to + 1.
   4. Set k to k + 1.
8. Return A.

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 predicate. Elements that are appended to the array after the call to find begins will not be visited by predicate. 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. Let len be ? LengthOfArrayLike(O).
3. If IsCallable(predicate) is false, throw a TypeError exception.
4. Let k be 0.
5. Repeat, while k < len
   1. Let Pk be ! ToString(k).
   2. Let kValue be ? Get(O, Pk).
   3. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, k, O »)).
   4. If testResult is true, return kValue.
   5. Set k to k + 1.
6. Return undefined.

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 predicate. Elements that are appended to the array after the call to findIndex begins will not be visited by predicate. 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. Let len be ? LengthOfArrayLike(O).
3. If IsCallable(predicate) is false, throw a TypeError exception.
4. Let k be 0.
5. Repeat, while k < len
   1. Let Pk be ! ToString(k).
   2. Let kValue be ? Get(O, Pk).
   3. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, k, O »)).
   4. If testResult is true, return k.
   5. Set k to k + 1.
6. Return -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.

When the flat method is called with zero or one arguments, the following steps are taken:

1. Let O be ? ToObject(this value).
2. Let sourceLen be ? LengthOfArrayLike(O).
3. Let depthNum be 1.
4. If depth is not undefined, then
   1. Set depthNum to ? ToInteger(depth).
5. Let A be ? ArraySpeciesCreate(O, 0).
6. Perform ? FlattenIntoArray(A, O, sourceLen, 0, depthNum).
7. Return A.

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

1. Let O be ? ToObject(this value).
2. Let sourceLen be ? LengthOfArrayLike(O).
3. If ! IsCallable(mapperFunction) is false, throw a TypeError exception.
4. Let A be ? ArraySpeciesCreate(O, 0).
5. Perform ? FlattenIntoArray(A, O, sourceLen, 0, 1, mapperFunction, thisArg).
6. Return A.

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. Let len be ? LengthOfArrayLike(O).
3. If IsCallable(callbackfn) is false, throw a TypeError exception.
4. Let k be 0.
5. Repeat, while k < len
   1. Let Pk be ! ToString(k).
   2. Let kPresent be ? HasProperty(O, Pk).
   3. If kPresent is true, then
      1. Let kValue be ? Get(O, Pk).
      2. Perform ? Call(callbackfn, thisArg, « kValue, k, O »).
   4. Set k to k + 1.
6. Return undefined.

This function is the %ArrayProto_forEach% intrinsic object.

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

includes compares searchElement to the elements of the array, in ascending order, using the SameValueZero algorithm, and if found at any position, returns true; otherwise, false 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, false 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 includes method is called, the following steps are taken:

1. Let O be ? ToObject(this value).
2. Let len be ? LengthOfArrayLike(O).
3. If len is 0, return false.
4. Let n be ? ToInteger(fromIndex).
5. Assert: If fromIndex is undefined, then n is 0.
6. If n ≥ 0, then
   1. Let k be n.
7. Else,
   1. Let k be len + n.
   2. If k < 0, set k to 0.
8. Repeat, while k < len
   1. Let elementK be the result of ? Get(O, ! ToString(k)).
   2. If SameValueZero(searchElement, elementK) is true, return true.
   3. Set k to k + 1.
9. Return false.

Note 2

The includes 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 3

The includes method intentionally differs from the similar indexOf method in two ways. First, it uses the SameValueZero algorithm, instead of Strict Equality Comparison, allowing it to detect NaN array elements. Second, it does not skip missing array elements, instead treating them as undefined.

Note 1

indexOf compares searchElement to the elements of the array, in ascending order, using the Strict Equality Comparison algorithm, 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. Let len be ? LengthOfArrayLike(O).
3. If len is 0, return -1.
4. Let n be ? ToInteger(fromIndex).
5. Assert: If fromIndex is undefined, then n is 0.
6. If n ≥ len, return -1.
7. If n ≥ 0, then
   1. Let k be n.
8. Else,
   1. Let k be len + n.
   2. If k < 0, set k to 0.
9. Repeat, while k < len
   1. Let kPresent be ? HasProperty(O, ! ToString(k)).
   2. If kPresent is true, then
      1. Let elementK be ? Get(O, ! ToString(k)).
      2. Let same be the result of performing Strict Equality Comparison searchElement === elementK.
      3. If same is true, return k.
   3. Set k to k + 1.
10. Return -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. Let len be ? LengthOfArrayLike(O).
3. If separator is undefined, let sep be the single-element String ",".
4. Else, let sep be ? ToString(separator).
5. Let R be the empty String.
6. Let k be 0.
7. Repeat, while k < len
   1. If k > 0, set R to the string-concatenation of 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. Set R to the string-concatenation of R and next.
   5. Set k to k + 1.
8. Return R.

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. Return CreateArrayIterator(O, key).

This function is the %ArrayProto_keys% intrinsic object.

Note 1

lastIndexOf compares searchElement to the elements of the array in descending order using the Strict Equality Comparison algorithm, 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. Let len be ? LengthOfArrayLike(O).
3. If len is 0, return -1.
4. If fromIndex is present, let n be ? ToInteger(fromIndex); else let n be len - 1.
5. If n ≥ 0, then
   1. Let k be min(n, len - 1).
6. Else,
   1. Let k be len + n.
7. Repeat, while k ≥ 0
   1. Let kPresent be ? HasProperty(O, ! ToString(k)).
   2. If kPresent is true, then
      1. Let elementK be ? Get(O, ! ToString(k)).
      2. Let same be the result of performing Strict Equality Comparison searchElement === elementK.
      3. If same is true, return k.
   3. Set k to k - 1.
8. Return -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. Let len be ? LengthOfArrayLike(O).
3. If IsCallable(callbackfn) is false, throw a TypeError exception.
4. Let A be ? ArraySpeciesCreate(O, len).
5. Let k be 0.
6. Repeat, while k < len
   1. Let Pk be ! ToString(k).
   2. Let kPresent be ? HasProperty(O, Pk).
   3. If kPresent is true, then
      1. Let kValue be ? Get(O, Pk).
      2. Let mappedValue be ? Call(callbackfn, thisArg, « kValue, k, O »).
      3. Perform ? CreateDataPropertyOrThrow(A, Pk, mappedValue).
   4. Set k to k + 1.
7. Return A.

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. Let len be ? LengthOfArrayLike(O).
3. If len is zero, then
   1. Perform ? Set(O, "length", 0, true).
   2. Return undefined.
4. Else,
   1. Assert: len > 0.
   2. Let newLen be len - 1.
   3. Let index be ! ToString(newLen).
   4. Let element be ? Get(O, index).
   5. Perform ? DeletePropertyOrThrow(O, index).
   6. Perform ? Set(O, "length", newLen, true).
   7. 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. Let len be ? LengthOfArrayLike(O).
3. Let items be a List whose elements are, in left to right order, the arguments that were passed to this function invocation.
4. Let argCount be the number of elements in items.
5. If len + argCount > 2⁵³ - 1, throw a TypeError exception.
6. Repeat, while items is not empty
   1. Remove the first element from items and let E be the value of the element.
   2. Perform ? Set(O, ! ToString(len), E, true).
   3. Set len to len + 1.
7. Perform ? Set(O, "length", len, true).
8. 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 after the first 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 supplied 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 supplied, 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. Let len be ? LengthOfArrayLike(O).
3. If IsCallable(callbackfn) is false, throw a TypeError exception.
4. If len is 0 and initialValue is not present, throw a TypeError exception.
5. Let k be 0.
6. Let accumulator be undefined.
7. If initialValue is present, then
   1. Set accumulator to initialValue.
8. Else,
   1. Let kPresent be false.
   2. Repeat, while kPresent is false and k < len
      1. Let Pk be ! ToString(k).
      2. Set kPresent to ? HasProperty(O, Pk).
      3. If kPresent is true, then
         1. Set accumulator to ? Get(O, Pk).
      4. Set k to k + 1.
   3. If kPresent is false, throw a TypeError exception.
9. Repeat, while k < len
   1. Let Pk be ! ToString(k).
   2. Let kPresent be ? HasProperty(O, Pk).
   3. If kPresent is true, then
      1. Let kValue be ? Get(O, Pk).
      2. Set accumulator to ? Call(callbackfn, undefined, « accumulator, kValue, k, O »).
   4. Set k to k + 1.
10. Return accumulator.

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 after the first 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 supplied 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 supplied, 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. Let len be ? LengthOfArrayLike(O).
3. If IsCallable(callbackfn) is false, throw a TypeError exception.
4. If len is 0 and initialValue is not present, throw a TypeError exception.
5. Let k be len - 1.
6. Let accumulator be undefined.
7. If initialValue is present, then
   1. Set accumulator to initialValue.
8. Else,
   1. Let kPresent be false.
   2. Repeat, while kPresent is false and k ≥ 0
      1. Let Pk be ! ToString(k).
      2. Set kPresent to ? HasProperty(O, Pk).
      3. If kPresent is true, then
         1. Set accumulator to ? Get(O, Pk).
      4. Set k to k - 1.
   3. If kPresent is false, throw a TypeError exception.
9. Repeat, while k ≥ 0
   1. Let Pk be ! ToString(k).
   2. Let kPresent be ? HasProperty(O, Pk).
   3. If kPresent is true, then
      1. Let kValue be ? Get(O, Pk).
      2. Set accumulator to ? Call(callbackfn, undefined, « accumulator, kValue, k, O »).
   4. Set k to k - 1.
10. Return accumulator.

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. Let len be ? LengthOfArrayLike(O).
3. Let middle be floor(len / 2).
4. Let lower be 0.
5. Repeat, while lower ≠ middle
   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. If lowerExists is true, then
      1. Let lowerValue be ? Get(O, lowerP).
   6. Let upperExists be ? HasProperty(O, upperP).
   7. If upperExists is true, then
      1. Let upperValue be ? Get(O, upperP).
   8. If lowerExists is true and upperExists is true, then
      1. Perform ? Set(O, lowerP, upperValue, true).
      2. Perform ? Set(O, upperP, lowerValue, true).
   9. Else if lowerExists is false and upperExists is true, then
      1. Perform ? Set(O, lowerP, upperValue, true).
      2. Perform ? DeletePropertyOrThrow(O, upperP).
   10. Else if lowerExists is true and upperExists is false, then
       1. Perform ? DeletePropertyOrThrow(O, lowerP).
       2. Perform ? Set(O, upperP, lowerValue, true).
   11. Else,
       1. Assert: lowerExists and upperExists are both false.
       2. No action is required.
   12. Set lower to lower + 1.
6. 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. Let len be ? LengthOfArrayLike(O).
3. If len is zero, then
   1. Perform ? Set(O, "length", 0, true).
   2. Return undefined.
4. Let first be ? Get(O, "0").
5. Let k be 1.
6. Repeat, while k < len
   1. Let from be ! ToString(k).
   2. Let to be ! ToString(k - 1).
   3. Let fromPresent be ? HasProperty(O, from).
   4. If fromPresent is true, then
      1. Let fromVal be ? Get(O, from).
      2. Perform ? Set(O, to, fromVal, true).
   5. Else,
      1. Assert: fromPresent is false.
      2. Perform ? DeletePropertyOrThrow(O, to).
   6. Set k to k + 1.
7. Perform ? DeletePropertyOrThrow(O, ! ToString(len - 1)).
8. Perform ? Set(O, "length", len - 1, true).
9. 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. Let len be ? LengthOfArrayLike(O).
3. Let relativeStart be ? ToInteger(start).
4. If relativeStart < 0, let k be max((len + relativeStart), 0); else let k be min(relativeStart, len).
5. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
6. If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
7. Let count be max(final - k, 0).
8. Let A be ? ArraySpeciesCreate(O, count).
9. Let n be 0.
10. Repeat, while k < final
    1. Let Pk be ! ToString(k).
    2. Let kPresent be ? HasProperty(O, Pk).
    3. If kPresent is true, then
       1. Let kValue be ? Get(O, Pk).
       2. Perform ? CreateDataPropertyOrThrow(A, ! ToString(n), kValue).
    4. Set k to k + 1.
    5. Set n to n + 1.
11. Perform ? Set(A, "length", n, true).
12. Return A.

Note 2

The explicit setting of the "length" property of the result Array in step 11 was necessary in previous editions of ECMAScript to ensure that its length was correct in situations where the trailing elements of the result Array were not present. Setting "length" became unnecessary starting in ES2015 when the result Array was initialized to its proper length rather than an empty Array but is carried forward to preserve backward compatibility.

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. Let len be ? LengthOfArrayLike(O).
3. If IsCallable(callbackfn) is false, throw a TypeError exception.
4. Let k be 0.
5. Repeat, while k < len
   1. Let Pk be ! ToString(k).
   2. Let kPresent be ? HasProperty(O, Pk).
   3. If kPresent is true, then
      1. Let kValue be ? Get(O, Pk).
      2. Let testResult be ! ToBoolean(? Call(callbackfn, thisArg, « kValue, k, O »)).
      3. If testResult is true, return true.
   4. Set k to k + 1.
6. Return false.

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 must be stable (that is, elements that compare equal must 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. If comparefn is not undefined and IsCallable(comparefn) is false, throw a TypeError exception.
2. Let obj be ? ToObject(this value).
3. Let len be ? LengthOfArrayLike(obj).

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, do
   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 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 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, Set, 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 Throw argument for every call to Set is true.
   • The arguments for calls to SortCompare are values returned by a previous call to the Get abstract operation, unless the properties accessed by those previous calls did not exist according to HasOwnProperty. If both prospective arguments to SortCompare correspond to non-existent properties, use +0 instead of calling SortCompare. If only the first prospective argument is non-existent use +1. If only the second prospective argument is non-existent use -1.
   • If obj is not sparse then DeletePropertyOrThrow must not be called.
   • 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 Get(obj, j) before this function is executed, and the notation new[j] to refer to the hypothetical result of calling Get(obj, 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. Let len be ? LengthOfArrayLike(O).
3. Let relativeStart be ? ToInteger(start).
4. If relativeStart < 0, let actualStart be max((len + relativeStart), 0); else let actualStart be min(relativeStart, len).
5. If the number of actual arguments is 0, then
   1. Let insertCount be 0.
   2. Let actualDeleteCount be 0.
6. Else if the number of actual arguments is 1, then
   1. Let insertCount be 0.
   2. Let actualDeleteCount be len - actualStart.
7. Else,
   1. Let insertCount be the number of actual arguments minus 2.
   2. Let dc be ? ToInteger(deleteCount).
   3. Let actualDeleteCount be min(max(dc, 0), len - actualStart).
8. If len + insertCount - actualDeleteCount > 2⁵³ - 1, throw a TypeError exception.
9. Let A be ? ArraySpeciesCreate(O, actualDeleteCount).
10. Let k be 0.
11. Repeat, while k < actualDeleteCount
    1. Let from be ! ToString(actualStart + k).
    2. Let fromPresent be ? HasProperty(O, from).
    3. If fromPresent is true, then
       1. Let fromValue be ? Get(O, from).
       2. Perform ? CreateDataPropertyOrThrow(A, ! ToString(k), fromValue).
    4. Set k to k + 1.
12. Perform ? Set(A, "length", actualDeleteCount, true).
13. 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.
14. Let itemCount be the number of elements in items.
15. If itemCount < actualDeleteCount, then
    1. Set k to actualStart.
    2. Repeat, while k < (len - actualDeleteCount)
       1. Let from be ! ToString(k + actualDeleteCount).
       2. Let to be ! ToString(k + itemCount).
       3. Let fromPresent be ? HasProperty(O, from).
       4. If fromPresent is true, then
          1. Let fromValue be ? Get(O, from).
          2. Perform ? Set(O, to, fromValue, true).
       5. Else,
          1. Assert: fromPresent is false.
          2. Perform ? DeletePropertyOrThrow(O, to).
       6. Set k to k + 1.
    3. Set k to len.
    4. Repeat, while k > (len - actualDeleteCount + itemCount)
       1. Perform ? DeletePropertyOrThrow(O, ! ToString(k - 1)).
       2. Set k to k - 1.
16. Else if itemCount > actualDeleteCount, then
    1. Set k to (len - actualDeleteCount).
    2. Repeat, while k > actualStart
       1. Let from be ! ToString(k + actualDeleteCount - 1).
       2. Let to be ! ToString(k + itemCount - 1).
       3. Let fromPresent be ? HasProperty(O, from).
       4. If fromPresent is true, then
          1. Let fromValue be ? Get(O, from).
          2. Perform ? Set(O, to, fromValue, true).
       5. Else,
          1. Assert: fromPresent is false.
          2. Perform ? DeletePropertyOrThrow(O, to).
       6. Set k to k - 1.
17. Set k to actualStart.
18. Repeat, while items is not empty
    1. Remove the first element from items and let E be the value of that element.
    2. Perform ? Set(O, ! ToString(k), E, true).
    3. Set k to k + 1.
19. Perform ? Set(O, "length", len - actualDeleteCount + itemCount, true).
20. Return A.

Note 2

The explicit setting of the "length" property of the result Array in step 19 was necessary in previous editions of ECMAScript to ensure that its length was correct in situations where the trailing elements of the result Array were not present. Setting "length" became unnecessary starting in ES2015 when the result Array was initialized to its proper length rather than an empty Array but is carried forward to preserve backward compatibility.

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. Let len be ? LengthOfArrayLike(array).
3. 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).
4. Let R be the empty String.
5. Let k be 0.
6. Repeat, while k < len
   1. If k > 0, then
      1. Set R to the string-concatenation of R and separator.
   2. Let nextElement be ? Get(array, ! ToString(k)).
   3. If nextElement is not undefined or null, then
      1. Let S be ? ToString(? Invoke(nextElement, "toLocaleString")).
      2. Set R to the string-concatenation of R and S.
   4. Set k to k + 1.
7. 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. Let func be ? Get(array, "join").
3. If IsCallable(func) is false, set func to the intrinsic function %Object.prototype.toString%.
4. 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. Let len be ? LengthOfArrayLike(O).
3. Let argCount be the number of actual arguments.
4. If argCount > 0, then
   1. If len + argCount > 2⁵³ - 1, throw a TypeError exception.
   2. Let k be len.
   3. Repeat, while k > 0,
      1. Let from be ! ToString(k - 1).
      2. Let to be ! ToString(k + argCount - 1).
      3. Let fromPresent be ? HasProperty(O, from).
      4. If fromPresent is true, then
         1. Let fromValue be ? Get(O, from).
         2. Perform ? Set(O, to, fromValue, true).
      5. Else,
         1. Assert: fromPresent is false.
         2. Perform ? DeletePropertyOrThrow(O, to).
      6. Set k to k - 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. Remove the first element from items and let E be the value of that element.
      2. Perform ? Set(O, ! ToString(j), E, true).
      3. Set j to j + 1.
5. Perform ? Set(O, "length", len + argCount, true).
6. 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. 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 unscopableList be OrdinaryObjectCreate(null).
2. Perform ! CreateDataPropertyOrThrow(unscopableList, "copyWithin", true).
3. Perform ! CreateDataPropertyOrThrow(unscopableList, "entries", true).
4. Perform ! CreateDataPropertyOrThrow(unscopableList, "fill", true).
5. Perform ! CreateDataPropertyOrThrow(unscopableList, "find", true).
6. Perform ! CreateDataPropertyOrThrow(unscopableList, "findIndex", true).
7. Perform ! CreateDataPropertyOrThrow(unscopableList, "flat", true).
8. Perform ! CreateDataPropertyOrThrow(unscopableList, "flatMap", true).
9. Perform ! CreateDataPropertyOrThrow(unscopableList, "includes", true).
10. Perform ! CreateDataPropertyOrThrow(unscopableList, "keys", true).
11. Perform ! CreateDataPropertyOrThrow(unscopableList, "values", true).
12. Return unscopableList.

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. Assert: kind is key+value, key, or value.
3. Let iterator be OrdinaryObjectCreate(%ArrayIteratorPrototype%, « [[IteratedArrayLike]], [[ArrayLikeNextIndex]], [[ArrayLikeIterationKind]] »).
4. Set iterator.[[IteratedArrayLike]] to array.
5. Set iterator.[[ArrayLikeNextIndex]] to 0.
6. Set iterator.[[ArrayLikeIterationKind]] to kind.
7. Return iterator.

The %ArrayIteratorPrototype% object:

• has properties that are inherited by all Array Iterator Objects.
• is an ordinary object.
• has a [[Prototype]] internal slot whose value is %IteratorPrototype%.
• 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 60.

Internal Slot	Description
[[IteratedArrayLike]]	The array-like object that is being iterated.
[[ArrayLikeNextIndex]]	The integer index of the next element to be examined by this iterator.
[[ArrayLikeIterationKind]]	A String value that identifies what is returned for each element of the iteration. The possible values are: key, value, key+value.

The %TypedArray% constructor performs the following steps:

1. Throw a TypeError exception.

The "length" property of the %TypedArray% constructor function is 0.

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 is undefined, let mapping be false.
4. Else,
   1. If IsCallable(mapfn) is false, throw a TypeError exception.
   2. Let mapping be true.
5. Let usingIterator be ? GetMethod(source, @@iterator).
6. If usingIterator is not undefined, then
   1. Let values be ? IterableToList(source, usingIterator).
   2. Let len be the number of elements in values.
   3. Let targetObj be ? TypedArrayCreate(C, « len »).
   4. Let k be 0.
   5. Repeat, while k < len
      1. Let Pk be ! ToString(k).
      2. Let kValue be the first element of values and remove that element from values.
      3. If mapping is true, then
         1. Let mappedValue be ? Call(mapfn, thisArg, « kValue, k »).
      4. Else, let mappedValue be kValue.
      5. Perform ? Set(targetObj, Pk, mappedValue, true).
      6. Set k to k + 1.
   6. Assert: values is now an empty List.
   7. Return targetObj.
7. NOTE: source is not an Iterable so assume it is already an array-like object.
8. Let arrayLike be ! ToObject(source).
9. Let len be ? LengthOfArrayLike(arrayLike).
10. Let targetObj be ? TypedArrayCreate(C, « len »).
11. Let k be 0.
12. Repeat, while k < len
    1. Let Pk be ! ToString(k).
    2. Let kValue be ? Get(arrayLike, Pk).
    3. If mapping is true, then
       1. Let mappedValue be ? Call(mapfn, thisArg, « kValue, k »).
    4. Else, let mappedValue be kValue.
    5. Perform ? Set(targetObj, Pk, mappedValue, true).
    6. Set k to k + 1.
13. Return targetObj.

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 ? TypedArrayCreate(C, « len »).
6. Let k be 0.
7. Repeat, while k < len
   1. Let kValue be items[k].
   2. Let Pk be ! ToString(k).
   3. Perform ? Set(newObj, Pk, kValue, true).
   4. Set k to k + 1.
8. Return newObj.

Note

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

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

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

%TypedArray.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.

%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. Perform ? RequireInternalSlot(O, [[TypedArrayName]]).
3. Assert: O has a [[ViewedArrayBuffer]] internal slot.
4. Let buffer be O.[[ViewedArrayBuffer]].
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. Perform ? RequireInternalSlot(O, [[TypedArrayName]]).
3. Assert: O has a [[ViewedArrayBuffer]] internal slot.
4. Let buffer be O.[[ViewedArrayBuffer]].
5. If IsDetachedBuffer(buffer) is true, return 0.
6. Let size be O.[[ByteLength]].
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. Perform ? RequireInternalSlot(O, [[TypedArrayName]]).
3. Assert: O has a [[ViewedArrayBuffer]] internal slot.
4. Let buffer be O.[[ViewedArrayBuffer]].
5. If IsDetachedBuffer(buffer) is true, return 0.
6. Let offset be O.[[ByteOffset]].
7. Return offset.

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

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

The following steps are taken:

1. Let O be the this value.
2. Perform ? ValidateTypedArray(O).
3. Let len be O.[[ArrayLength]].
4. Let relativeTarget be ? ToInteger(target).
5. If relativeTarget < 0, let to be max((len + relativeTarget), 0); else let to be min(relativeTarget, len).
6. Let relativeStart be ? ToInteger(start).
7. If relativeStart < 0, let from be max((len + relativeStart), 0); else let from be min(relativeStart, len).
8. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
9. If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
10. Let count be min(final - from, len - to).
11. If count > 0, then
    1. NOTE: The copying must be performed in a manner that preserves the bit-level encoding of the source data.
    2. Let buffer be O.[[ViewedArrayBuffer]].
    3. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
    4. Let typedArrayName be the String value of O.[[TypedArrayName]].
    5. Let elementSize be the Element Size value specified in Table 61 for typedArrayName.
    6. Let byteOffset be O.[[ByteOffset]].
    7. Let toByteIndex be to × elementSize + byteOffset.
    8. Let fromByteIndex be from × elementSize + byteOffset.
    9. Let countBytes be count × elementSize.
    10. If fromByteIndex < toByteIndex and toByteIndex < fromByteIndex + countBytes, then
        1. Let direction be -1.
        2. Set fromByteIndex to fromByteIndex + countBytes - 1.
        3. Set toByteIndex to toByteIndex + countBytes - 1.
    11. Else,
        1. Let direction be 1.
    12. Repeat, while countBytes > 0
        1. Let value be GetValueFromBuffer(buffer, fromByteIndex, Uint8, true, Unordered).
        2. Perform SetValueInBuffer(buffer, toByteIndex, Uint8, value, true, Unordered).
        3. Set fromByteIndex to fromByteIndex + direction.
        4. Set toByteIndex to toByteIndex + direction.
        5. Set countBytes to countBytes - 1.
12. Return O.

The following steps are taken:

1. Let O be the this value.
2. Perform ? ValidateTypedArray(O).
3. 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 interpretation and use of the arguments of %TypedArray%.prototype.fill are the same as for Array.prototype.fill as defined in 22.1.3.6.

The following steps are taken:

1. Let O be the this value.
2. Perform ? ValidateTypedArray(O).
3. Let len be O.[[ArrayLength]].
4. If O.[[ContentType]] is BigInt, set value to ? ToBigInt(value).
5. Otherwise, set value to ? ToNumber(value).
6. Let relativeStart be ? ToInteger(start).
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. If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
10. If IsDetachedBuffer(O.[[ViewedArrayBuffer]]) is true, throw a TypeError exception.
11. Repeat, while k < final
    1. Let Pk be ! ToString(k).
    2. Perform ! Set(O, Pk, value, true).
    3. Set k to k + 1.
12. Return O.

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. Perform ? ValidateTypedArray(O).
3. Let len be O.[[ArrayLength]].
4. If IsCallable(callbackfn) is false, throw a TypeError exception.
5. Let kept be a new empty List.
6. Let k be 0.
7. Let captured be 0.
8. Repeat, while k < len
   1. Let Pk be ! ToString(k).
   2. Let kValue be ? Get(O, Pk).
   3. Let selected be ! ToBoolean(? Call(callbackfn, thisArg, « kValue, k, O »)).
   4. If selected is true, then
      1. Append kValue to the end of kept.
      2. Set captured to captured + 1.
   5. Set k to k + 1.
9. Let A be ? TypedArraySpeciesCreate(O, « captured »).
10. Let n be 0.
11. For each element e of kept, do
    1. Perform ! Set(A, ! ToString(n), e, true).
    2. Set n to n + 1.
12. Return A.

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

%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.

%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.

%TypedArray%.prototype.forEach is a distinct function that implements the same algorithm as Array.prototype.forEach 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 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.

%TypedArray%.prototype.includes is a distinct function that implements the same algorithm as Array.prototype.includes as defined in 22.1.3.13 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.indexOf is a distinct function that implements the same algorithm as Array.prototype.indexOf 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.

%TypedArray%.prototype.join is a distinct function that implements the same algorithm as Array.prototype.join as defined in 22.1.3.15 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. Perform ? ValidateTypedArray(O).
3. 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.17 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.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. Perform ? RequireInternalSlot(O, [[TypedArrayName]]).
3. Assert: O has [[ViewedArrayBuffer]] and [[ArrayLength]] internal slots.
4. Let buffer be O.[[ViewedArrayBuffer]].
5. If IsDetachedBuffer(buffer) is true, return 0.
6. Let length be O.[[ArrayLength]].
7. 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.18.

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

1. Let O be the this value.
2. Perform ? ValidateTypedArray(O).
3. Let len be O.[[ArrayLength]].
4. If IsCallable(callbackfn) is false, throw a TypeError exception.
5. Let A be ? TypedArraySpeciesCreate(O, « len »).
6. Let k be 0.
7. Repeat, while k < len
   1. Let Pk be ! ToString(k).
   2. Let kValue be ? Get(O, Pk).
   3. Let mappedValue be ? Call(callbackfn, thisArg, « kValue, k, O »).
   4. Perform ? Set(A, Pk, mappedValue, true).
   5. Set k to k + 1.
8. Return A.

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

%TypedArray%.prototype.reduce is a distinct function that implements the same algorithm as Array.prototype.reduce as defined in 22.1.3.21 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.

%TypedArray%.prototype.reduceRight is a distinct function that implements the same algorithm as Array.prototype.reduceRight as defined in 22.1.3.22 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.

%TypedArray%.prototype.reverse is a distinct function that implements the same algorithm as Array.prototype.reverse as defined in 22.1.3.23 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 interpretation and use of the arguments of %TypedArray%.prototype.slice are the same as for Array.prototype.slice as defined in 22.1.3.25. The following steps are taken:

1. Let O be the this value.
2. Perform ? ValidateTypedArray(O).
3. Let len be O.[[ArrayLength]].
4. Let relativeStart be ? ToInteger(start).
5. If relativeStart < 0, let k be max((len + relativeStart), 0); else let k be min(relativeStart, len).
6. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
7. If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
8. Let count be max(final - k, 0).
9. Let A be ? TypedArraySpeciesCreate(O, « count »).
10. Let srcName be the String value of O.[[TypedArrayName]].
11. Let srcType be the Element Type value in Table 61 for srcName.
12. Let targetName be the String value of A.[[TypedArrayName]].
13. Let targetType be the Element Type value in Table 61 for targetName.
14. If srcType is different from targetType, then
    1. Let n be 0.
    2. Repeat, while k < final
       1. Let Pk be ! ToString(k).
       2. Let kValue be ? Get(O, Pk).
       3. Perform ! Set(A, ! ToString(n), kValue, true).
       4. Set k to k + 1.
       5. Set n to n + 1.
15. Else if count > 0, then
    1. Let srcBuffer be O.[[ViewedArrayBuffer]].
    2. If IsDetachedBuffer(srcBuffer) is true, throw a TypeError exception.
    3. Let targetBuffer be A.[[ViewedArrayBuffer]].
    4. Let elementSize be the Element Size value specified in Table 61 for Element Type srcType.
    5. NOTE: If srcType and targetType are the same, the transfer must be performed in a manner that preserves the bit-level encoding of the source data.
    6. Let srcByteOffet be O.[[ByteOffset]].
    7. Let targetByteIndex be A.[[ByteOffset]].
    8. Let srcByteIndex be (k × elementSize) + srcByteOffet.
    9. Let limit be targetByteIndex + count × elementSize.
    10. Repeat, while targetByteIndex < limit
        1. Let value be GetValueFromBuffer(srcBuffer, srcByteIndex, Uint8, true, Unordered).
        2. Perform SetValueInBuffer(targetBuffer, targetByteIndex, Uint8, value, true, Unordered).
        3. Set srcByteIndex to srcByteIndex + 1.
        4. Set targetByteIndex to targetByteIndex + 1.
16. Return A.

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

%TypedArray%.prototype.some is a distinct function that implements the same algorithm as Array.prototype.some as defined in 22.1.3.26 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.

%TypedArray%.prototype.sort is a distinct function that, except as described below, implements the same requirements as those of Array.prototype.sort as defined in 22.1.3.27. The implementation of the %TypedArray%.prototype.sort specification 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. The only internal methods of the this object that the algorithm may call are [[Get]] and [[Set]].

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

Upon entry, the following steps are performed to initialize evaluation of the sort function. These steps are used instead of the entry steps in 22.1.3.27:

1. If comparefn is not undefined and IsCallable(comparefn) is false, throw a TypeError exception.
2. Let obj be the this value.
3. Let buffer be ? ValidateTypedArray(obj).
4. Let len be obj.[[ArrayLength]].

The implementation-defined sort order condition for exotic objects is not applied by %TypedArray%.prototype.sort.

The following version of SortCompare is used by %TypedArray%.prototype.sort. It performs a numeric comparison rather than the string comparison used in 22.1.3.27. SortCompare has access to the comparefn and buffer values of the current invocation of the sort method.

When the TypedArray SortCompare abstract operation is called with two arguments x and y, the following steps are taken:

1. Assert: Both Type(x) and Type(y) are Number or both are BigInt.
2. If comparefn is not undefined, then
   1. Let v be ? ToNumber(? Call(comparefn, undefined, « x, y »)).
   2. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
   3. If v is NaN, return +0.
   4. Return v.
3. If x and y are both NaN, return +0.
4. If x is NaN, return 1.
5. If y is NaN, return -1.
6. If x < y, return -1.
7. If x > y, return 1.
8. If x is -0 and y is +0, return -1.
9. If x is +0 and y is -0, return 1.
10. Return +0.

Note

Because NaN always compares greater than any other value, NaN property values always sort to the end of the result when comparefn is not provided.

Returns a new TypedArray object whose element type is the same as this TypedArray and whose ArrayBuffer is the same as the ArrayBuffer of this TypedArray, referencing the elements at begin, inclusive, up to end, exclusive. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning.

1. Let O be the this value.
2. Perform ? RequireInternalSlot(O, [[TypedArrayName]]).
3. Assert: O has a [[ViewedArrayBuffer]] internal slot.
4. Let buffer be O.[[ViewedArrayBuffer]].
5. Let srcLength be O.[[ArrayLength]].
6. Let relativeBegin be ? ToInteger(begin).
7. If relativeBegin < 0, let beginIndex be max((srcLength + relativeBegin), 0); else let beginIndex be min(relativeBegin, srcLength).
8. If end is undefined, let relativeEnd be srcLength; else let relativeEnd be ? ToInteger(end).
9. If relativeEnd < 0, let endIndex be max((srcLength + relativeEnd), 0); else let endIndex be min(relativeEnd, srcLength).
10. Let newLength be max(endIndex - beginIndex, 0).
11. Let constructorName be the String value of O.[[TypedArrayName]].
12. Let elementSize be the Element Size value specified in Table 61 for constructorName.
13. Let srcByteOffset be O.[[ByteOffset]].
14. Let beginByteOffset be srcByteOffset + beginIndex × elementSize.
15. Let argumentsList be « buffer, beginByteOffset, newLength ».
16. Return ? TypedArraySpeciesCreate(O, argumentsList).

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

%TypedArray%.prototype.toLocaleString is a distinct function that implements the same algorithm as Array.prototype.toLocaleString as defined in 22.1.3.29 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.

Note

If the ECMAScript implementation includes the ECMA-402 Internationalization API this function is based upon the algorithm for Array.prototype.toLocaleString that is in the ECMA-402 specification.

The initial value of the %TypedArray%.prototype.toString data property is the same built-in function object as the Array.prototype.toString method defined in 22.1.3.30.

The following steps are taken:

1. Let O be the this value.
2. Perform ? ValidateTypedArray(O).
3. Return CreateArrayIterator(O, value).

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

%TypedArray%.prototype[@@toStringTag] 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, return undefined.
3. If O does not have a [[TypedArrayName]] internal slot, return undefined.
4. Let name be O.[[TypedArrayName]].
5. Assert: Type(name) is String.
6. Return name.

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

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

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

1. If NewTarget is undefined, throw a TypeError exception.
2. Let constructorName be the String value of the Constructor Name value specified in Table 61 for this TypedArray constructor.
3. Return ? AllocateTypedArray(constructorName, NewTarget, "%TypedArray.prototype%", 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. Let elementLength be ? ToIndex(length).
4. Let constructorName be the String value of the Constructor Name value specified in Table 61 for this TypedArray constructor.
5. Return ? AllocateTypedArray(constructorName, NewTarget, "%TypedArray.prototype%", elementLength).