Arrays & Collections

map returns a new array of the same length by transforming each element. filter returns a new array keeping only elements whose callback returns truthy. reduce folds all elements into a single accumulated value via a reducer and a seed. forEach just runs a callback for each element and returns undefined — it is used for side effects, not for building a result.

slice(start, end) is non-mutating: it returns a new shallow copy of the selected range and leaves the original array untouched. splice(start, deleteCount, ...items) mutates the original in place — it removes, inserts, or replaces elements there — and returns an array of the removed elements. So slice is for reading a subset, splice is for editing the array itself.

By default sort converts each element to a string and compares them by UTF-16 code units, so [10, 2, 1] becomes [1, 10, 2] — lexicographic, not numeric. To sort numbers correctly you pass a compareFn (a, b) => a - b: a negative result puts a first, positive puts b first, zero keeps order. sort also mutates the array in place and returns it.

some returns true if at least one element passes the predicate; every returns true only if all do (and true for an empty array). find returns the first element that passes, or undefined; findIndex returns its index, or -1. reduce folds the array into one accumulated value. some, every, and find short-circuit as soon as the result is decided.

Versus a plain object, a Map accepts any value as a key (not just strings and symbols), guarantees insertion order, exposes size, is directly iterable, and has no prototype keys to collide with. An object is simpler, JSON-serializable, and fine for fixed string keys. Versus a Set: a Map stores key→value pairs, while a Set stores only unique standalone values with no associated value — so Set is for membership tests, Map for lookups.

Mutating methods change the array in place: push, pop, shift, unshift, splice, sort, reverse, and fill. Non-mutating methods return a new array and leave the original untouched: map, filter, slice, concat, and the ES2023 copying methods toSorted, toReversed, toSpliced, and with. Mutating methods often return something else — push returns the new length, pop the removed element — while non-mutating ones return the new array.

Prefer methods that return a new array: map, filter, slice, concat, and spread [...arr]. The ES2023 copying counterparts of the mutators — toSorted, toReversed, toSpliced, and with — replace sort/reverse/splice and index assignment without touching the source. reduce builds a derived structure in one pass. When only a mutator exists, copy first then mutate the copy: const sorted = [...arr].sort(cmp). These patterns matter for immutable state in frameworks like React.

Map is a built-in keyed collection where keys can be any value — objects and functions, not just strings and symbols. It remembers insertion order, exposes a size property, and is directly iterable with for...of, .keys(), .values(), and .entries(). You read and write with get, set, has, and delete. It has no prototype keys, so user keys can never collide with inherited properties.

Set is a built-in collection of unique values: adding a value already present is ignored, so it never holds duplicates. Uniqueness uses SameValueZero, so NaN is treated as one value. It is iterable in insertion order with a size property. To dedupe an array, wrap it in a Set and spread back: [...new Set(arr)], which keeps the first occurrence of each value.

Default sort is lexicographic (elements stringified, compared by UTF-16), so numbers need (a, b) => a - b. Since ES2019 sort is guaranteed stable: equal elements keep their relative order. It mutates the array in place and returns the same reference. The comparator must be consistent — returning negative/zero/positive purely from its two arguments — or the order is implementation-defined. undefined values and holes are never passed to it and always move to the end.

A dense array has a value at every index from 0 to length - 1; a sparse array has holes — missing indices, created by [1, , 3], Array(3), delete arr[i], or raising length. A hole is not the same as an element set to undefined. Methods like forEach, map, filter, and reduce skip holes entirely (the callback never runs there), and map preserves the holes in its result. Reading a hole yields undefined, so in or hasOwnProperty is the reliable way to detect one.

An ArrayBuffer is a fixed-length block of raw binary bytes you cannot read directly. A typed array like Uint8Array or Float64Array is a view that interprets those bytes as numbers of a fixed type and width. Multiple views can share one buffer, so writing through one view changes the bytes the other sees. Typed arrays have a fixed length and only hold numbers — they back binary data such as files, network frames, and WebGL/canvas pixels.

WeakMap keys and WeakSet members must be objects (or symbols), and they are held weakly: if nothing else references the object, it can be garbage-collected and the entry disappears automatically. Because membership can vanish at any time, they are not iterable, have no size, and cannot be cleared by enumeration. They expose only get/set/has/delete (add/has/delete for WeakSet). Typical use: attaching private metadata to objects without leaking memory.