JavaScript Array & String Methods

Add one or more elements to the end of an array

const a = [1,2,3]; a.push(4, 5); // a = [1,2,3,4,5]

Returns: New length of the array

Remove and return the last element

const a = [1,2,3]; a.pop(); // returns 3, a = [1,2]

Returns: Removed element (or undefined)

Remove and return the first element

const a = [1,2,3]; a.shift(); // returns 1, a = [2,3]

Returns: Removed element (or undefined)

Add one or more elements to the start of an array

const a = [1,2,3]; a.unshift(0); // a = [0,1,2,3]

Returns: New length of the array

Add/remove elements at a given index. splice(start, deleteCount, ...items)

a.splice(1, 2); // remove 2 at index 1
a.splice(1, 0, 'x'); // insert 'x'
a.splice(1, 1, 'y'); // replace at index 1

Returns: Array of removed elements

Sort array in place. Without comparator uses lexicographic order

arr.sort(); // lexicographic
arr.sort((a,b) => a - b); // numeric asc
arr.sort((a,b) => b - a); // numeric desc
arr.sort((a,b) => a.name.localeCompare(b.name));

Returns: The sorted array (same reference)

Reverse the array in place

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

Returns: The reversed array (same reference)

Fill all or a range of elements with a static value

[1,2,3,4].fill(0); // [0,0,0,0]
[1,2,3,4].fill(0, 1, 3); // [1,0,0,4]

Returns: The modified array (same reference)

Copy part of the array to another location within the same array

[1,2,3,4,5].copyWithin(0, 3); // [4,5,3,4,5]

Returns: The modified array (same reference)

Extract a portion of the array without modifying the original

[1,2,3,4].slice(1, 3); // [2,3]
[1,2,3].slice(-2); // [2,3]
[1,2,3].slice(); // shallow copy

Returns: New array with extracted elements

Merge two or more arrays into a new array

[1,2].concat([3,4], [5]); // [1,2,3,4,5]

Returns: New merged array

Flatten nested arrays up to the given depth (default 1). Use Infinity to flatten fully

[[1,2],[3,[4]]].flat(); // [1,2,3,[4]]
[[[1]]].flat(Infinity); // [1]

Returns: New flattened array

Map each element then flatten one level — equivalent to .map().flat(1)

[1,2,3].flatMap(x => [x, x*2]); // [1,2,2,4,3,6]
[[1],[2]].flatMap(x => x); // [1,2]

Returns: New array (mapped and flattened one level)

Create a new array by transforming each element with a callback

[1,2,3].map(x => x * 2); // [2,4,6]
[1,2,3].map((x,i) => i); // [0,1,2]

Returns: New array with same length

Create a new array with only elements that pass the predicate

[1,2,3,4].filter(x => x > 2); // [3,4]
arr.filter(Boolean); // remove falsy values

Returns: New (possibly shorter) array

Reduce array to a single value by accumulating a result

[1,2,3].reduce((acc,x) => acc + x, 0); // 6
arr.reduce((acc,x) => ({...acc,[x.id]:x}), {}); // to map

Returns: Accumulated value (any type)

Like reduce but iterates from right to left

[[1],[2],[3]].reduceRight((acc,x) => acc.concat(x), []); // [3,2,1]

Returns: Accumulated value (any type)

Create an array from any iterable or array-like object

Array.from('hello'); // ['h','e','l','l','o']
Array.from({length:5},(_,i)=>i); // [0,1,2,3,4]
Array.from(new Set([1,1,2])); // [1,2]

Returns: New array

Create a new array from the given arguments

Array.of(7); // [7]  (vs Array(7) which creates 7 empty slots)

Returns: New array

Spread syntax to merge or shallow-copy arrays

[...a, ...b]; // merge
[...arr]; // shallow copy
[0, ...arr, 99]; // prepend/append

Returns: New array

Return the first element that satisfies the predicate

[1,2,3,4].find(x => x > 2); // 3
arr.find(x => x.id === 5); // first match

Returns: First matching element or undefined

Return the index of the first element that satisfies the predicate

[1,2,3,4].findIndex(x => x > 2); // 2
arr.findIndex(x => x.id === 5); // -1 if not found

Returns: Index number or -1

Return the last element that satisfies the predicate (ES2023)

[1,2,3,4].findLast(x => x < 3); // 2

Returns: Last matching element or undefined

Return the index of the last matching element (ES2023)

[1,2,3,4].findLastIndex(x => x < 3); // 1

Returns: Index number or -1

Return true if at least one element passes the predicate

[1,2,3].some(x => x > 2); // true
arr.some(x => x.active); // any active?

Returns: Boolean

Return true if all elements pass the predicate

[2,4,6].every(x => x % 2 === 0); // true
arr.every(x => x.valid);

Returns: Boolean

Check if the array contains a value (uses SameValueZero — works for NaN)

[1,2,3].includes(2); // true
[1,NaN].includes(NaN); // true

Returns: Boolean

Return the first index of a value, or -1. Uses strict equality

[1,2,3,2].indexOf(2); // 1
[1,2,3].indexOf(9); // -1

Returns: Index number or -1

Return the last index of a value, or -1

[1,2,3,2].lastIndexOf(2); // 3

Returns: Index number or -1

Iterate over elements and call a function. Does not return a value

arr.forEach((item, index) => console.log(index, item));

Returns: undefined

Access element by index — supports negative indices (ES2022)

[1,2,3].at(-1); // 3 (last)
[1,2,3].at(0); // 1

Returns: Element or undefined

Join all elements into a string with a separator

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

Returns: String

Non-mutating versions of sort, reverse, and splice-replace (ES2023)

arr.toSorted((a,b) => a - b); // sorted, original unchanged
arr.toReversed(); // reversed copy
arr.with(1, 99); // copy with index 1 replaced by 99

Returns: New array

Return the first index of a substring, or -1

"hello world".indexOf("world"); // 6

Returns: Index number or -1

Check if the string contains a substring

"hello".includes("ell"); // true

Returns: Boolean

Check if the string starts with the given prefix

"hello".startsWith("he"); // true

Returns: Boolean

Check if the string ends with the given suffix

"hello".endsWith("lo"); // true

Returns: Boolean

Extract a portion of the string. Supports negative indices

"hello".slice(1, 3); // "el"
"hello".slice(-3); // "llo"

Returns: New string

Like slice but does not support negative indices

"hello".substring(1, 3); // "el"

Returns: New string

Convert the string to upper or lower case

"Hello".toUpperCase(); // "HELLO"
"Hello".toLowerCase(); // "hello"

Returns: New string

Remove whitespace from both ends, start only, or end only

"  hi  ".trim(); // "hi"
"  hi  ".trimStart(); // "hi  "

Returns: New string

Replace first match (string) or all matches (regex with /g flag)

"aabaa".replace("a", "x"); // "xabaa"
"aabaa".replace(/a/g, "x"); // "xxbxx"

Returns: New string

Replace all occurrences of a string (ES2021). For regex, /g flag required

"aabaa".replaceAll("a", "x"); // "xxbxx"

Returns: New string

Split a string into an array by a separator

"a,b,c".split(","); // ["a","b","c"]
"hi".split(""); // ["h","i"]
"a b c".split(" ", 2); // ["a","b"]

Returns: Array of strings

Pad the start of a string to a target length

"42".padStart(5, "0"); // "00042"

Returns: New string

Pad the end of a string to a target length

"hi".padEnd(6, "."); // "hi...."

Returns: New string

Return a string repeated the given number of times

"ab".repeat(3); // "ababab"

Returns: New string

Match against a regular expression. With /g returns all matches

"test 123 foo 456".match(/\d+/g); // ["123","456"]

Returns: Array or null

Returns iterator of all match objects (requires /g flag). ES2020

for (const m of "a1b2".matchAll(/(\w)(\d)/g)) console.log(m[1], m[2]);

Returns: Iterator of match objects

Access character by index — supports negative indices (ES2022)

"hello".at(-1); // "o"

Returns: Character or undefined

Compare two strings in locale-aware order for sorting

["banana","apple","cherry"].sort((a,b) => a.localeCompare(b));

Returns: -1, 0, or 1

Return an array of the object's own enumerable property keys

Object.keys({a:1,b:2}); // ["a","b"]

Returns: Array of strings

Return an array of the object's own enumerable property values

Object.values({a:1,b:2}); // [1,2]

Returns: Array

Return an array of [key, value] pairs

Object.entries({a:1,b:2}); // [["a",1],["b",2]]

Returns: Array of [key, value] pairs

Convert an array of [key, value] pairs (or a Map) back to an object

Object.fromEntries([["a",1],["b",2]]); // {a:1,b:2}
Object.fromEntries(map);

Returns: New object

Shallow-merge one or more source objects into the target. Mutates target

Object.assign({}, obj1, obj2); // safe merge into new obj

Returns: The target object

Make an object immutable — no add/delete/modify. Shallow only

const o = Object.freeze({x:1});
o.x = 99; // silently ignored (strict: throws)

Returns: The frozen object

Check if an object has a given own property. Safer than hasOwnProperty (ES2022)

Object.hasOwn({a:1}, "a"); // true
Object.hasOwn({a:1}, "toString"); // false

Returns: Boolean

Spread operator to shallow-merge objects into a new object

const merged = {...defaults, ...overrides};

Returns: New object

Object destructuring with defaults and rest properties

const {name, age=18} = user;
const {x: aliasX} = obj; // rename on destructure

Returns: Bound variables

Access nested properties safely — returns undefined instead of throwing if any step is null/undefined (ES2020)

user?.address?.city
arr?.[0]
fn?.() // call only if fn is a function

Returns: Value or undefined

Return right-hand side only when left is null or undefined (not falsy). ES2020

const port = config.port ?? 3000; // 0 is kept!
x ??= "default"; // assign if null/undefined (ES2021)

Returns: Left or right value

Logical assignment operators (ES2021)

x ||= 'default'; // assign if falsy
x &&= newVal; // assign if truthy
x ??= 0; // assign if null/undefined

Returns: Assigned value

Wait for all promises to settle (resolve or reject). Never rejects (ES2020)

const results = await Promise.allSettled([p1, p2]);
results[0].status; // 'fulfilled' | 'rejected'

Returns: Array of {status, value/reason}

Resolve with the first fulfilled promise. Rejects only if all reject (ES2021)

const first = await Promise.any([fast(), slow()]);

Returns: First resolved value

Deep clone an object natively — handles nested objects, Arrays, Map, Set, Date, etc. (ES2022)

const copy = structuredClone(obj);
// Functions are NOT cloned

Returns: Deep clone