Array Methods

Each member below is tagged with the ECMAScript edition that standardized it: (ES3), (ES5), or (ES6). Methods that need a polyfill link to Polyfills.

Status legend

Icon	Meaning
✅ Works	Available and behaves as expected
⚠️ Partial	Available but with a documented caveat or bug
❌ Missing	Not available — use the workaround / polyfill

Members

Member	ES	Status	Notes
`push(...items)`	ES3	✅ Works
`pop()`	ES3	✅ Works
`shift()`	ES3	✅ Works
`unshift(...items)`	ES3	✅ Works
`concat(...arrays)`	ES3	✅ Works
`join(separator)`	ES3	✅ Works
`reverse()`	ES3	✅ Works
`length`	ES3	✅ Works
`toLocaleString()`	ES3	✅ Works
`slice(start, end)`	ES3	⚠️ Partial	Negative indices unreliable — see Polyfills
`sort(compareFn)`	ES3	⚠️ Partial	Comparator behavior unreliable — see Polyfills
`splice(start, deleteCount, ...items)`	ES3	⚠️ Partial	Delete form works; insert form (3rd+ arg) ignores `start`/`deleteCount` — see Polyfills
`indexOf(searchValue, fromIndex)`	ES5	❌ Missing	See Polyfills
`lastIndexOf(searchValue, fromIndex)`	ES5	⚠️ Partial	Broken — always returns -1; see Polyfills
`forEach(fn)`	ES5	❌ Missing	Use a `for` loop or the polyfill
`map(fn)`	ES5	❌ Missing	Use a `for` loop or the polyfill
`filter(fn)`	ES5	❌ Missing	Use a `for` loop or the polyfill
`reduce(fn, initial)`	ES5	❌ Missing	Use a `for` loop or the polyfill
`reduceRight(fn, initial)`	ES5	❌ Missing	Use a `for` loop or the polyfill
`some(fn)`	ES5	❌ Missing	Use a `for` loop or the polyfill
`every(fn)`	ES5	❌ Missing	Use a `for` loop or the polyfill
`find(fn)`	ES6	❌ Missing	Use a `for` loop or the polyfill
`findIndex(fn)`	ES6	❌ Missing	Use a `for` loop or the polyfill
`includes(searchValue)`	ES6	❌ Missing	Use `indexOf(x) !== -1` or the polyfill
`fill(value, start, end)`	ES6	❌ Missing	See Polyfills
`copyWithin(target, start, count)`	ES6	❌ Missing	See Polyfills
`entries()`	ES6	❌ Missing	See Polyfills
`keys()`	ES6	❌ Missing	Use a standard index `for` loop
`values()`	ES6	❌ Missing	Use a standard index `for` loop
`at(index)`	ES6	❌ Missing	Use `arr[i]` (and `arr[arr.length + i]` for negative `i`)
`flat(depth)`	ES6	❌ Missing	Concatenate nested arrays manually in a loop
`flatMap(fn)`	ES6	❌ Missing	Build the result with a `for` loop and `push`
`findLast(fn)`	ES6	❌ Missing	Iterate from the end with a `for` loop
`Array.isArray(value)`	ES5	❌ Missing	See Polyfills
`Array.of(...items)`	ES6	❌ Missing	See Polyfills
`Array.from(source)`	ES6	❌ Missing	Build the array with a `for` loop over the source

push

(ES3) — ✅ Works. Appends one or more items to the end of the array and returns the new length.

var arr = [1, 2, 3];
arr.push(4);   // [1, 2, 3, 4]

pop

(ES3) — ✅ Works. Removes and returns the last item.

var arr = [1, 2, 3];
var last = arr.pop();   // 3, arr = [1, 2]

shift

(ES3) — ✅ Works. Removes and returns the first item.

var arr = [1, 2, 3];
var first = arr.shift();   // 1, arr = [2, 3]

unshift

(ES3) — ✅ Works. Prepends one or more items and returns the new length.

var arr = [1, 2, 3];
arr.unshift(0);   // arr = [0, 1, 2, 3]

concat

(ES3) — ✅ Works. Returns a new array combining the array with the given arrays/values.

var combined = [1, 2].concat([3, 4]);   // [1, 2, 3, 4]

join

(ES3) — ✅ Works. Joins all elements into a string using the given separator.

["Hello", "World"].join(", ");   // "Hello, World"

reverse

(ES3) — ✅ Works. Reverses the array in place.

var arr = [1, 2, 3];
arr.reverse();   // [3, 2, 1]

length

(ES3) — ✅ Works. The number of elements in the array.

[1, 2, 3].length;   // 3

toLocaleString

(ES3) — ✅ Works. Returns a locale-specific string representation.

[1, 2, 3].toLocaleString();   // "1,2,3"

slice

(ES3) — ⚠️ Partial. Returns a shallow copy of a portion of the array. Negative indices are unreliable in SFMC; apply the polyfill for full ES5 behavior.

var arr = [0, 1, 2, 3, 4];
arr.slice(1, 3);   // [1, 2]
arr.slice();       // copy of arr
// arr.slice(-2) — negative indices unreliable; use the polyfill

sort

(ES3) — ⚠️ Partial. Sorts in place. The comparator behavior is unreliable in SFMC; apply the polyfill for predictable results.

var arr = [3, 1, 4, 1, 5];
arr.sort(function (a, b) { return a - b; });   // ascending

splice

(ES3) — ⚠️ Partial. Signature: splice(start[, deleteCount[, item1[, ...itemN]]]).

The delete-only form — splice(start) and splice(start, deleteCount) — works correctly. The bug surfaces only when you insert items: as soon as a third argument is passed, the engine ignores start and deleteCount and overwrites from the left. Apply the polyfill from Polyfills if you use the insert form.

// Delete-only form works natively:
var arr = ["a", "b", "c", "d"];
arr.splice(1, 1);   // ["a", "c", "d"]
arr.splice(2);      // ["a", "c"]

// Insert form REQUIRES the polyfill:
var arr2 = ["a", "b", "c", "d"];
arr2.splice(1, 1, "X");        // ["a", "X", "c", "d"]
arr2.splice(1, 0, "B", "C");   // insert without removing

indexOf

(ES5) — ❌ Missing. Not available in SFMC. Apply the polyfill, or scan with a for loop.

function indexOf(arr, value) {
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] === value) { return i; }
    }
    return -1;
}

lastIndexOf

(ES5) — ⚠️ Partial. Present but broken — always returns -1. Apply the polyfill, or scan from the end with a for loop.

function lastIndexOf(arr, value) {
    for (var i = arr.length - 1; i >= 0; i--) {
        if (arr[i] === value) { return i; }
    }
    return -1;
}