Arrays, objects, and the methods people actually use

Three methods cover most of what a hand-written for loop over an array is doing.

const nums = [1, 2, 3, 4];

nums.map((n) => n * 2);              // [2, 4, 6, 8] — same length, transformed
nums.filter((n) => n % 2 === 0);     // [2, 4] — a subset, same shape
nums.reduce((sum, n) => sum + n, 0); // 10 — collapsed to one value

map transforms every element and keeps the length. filter keeps some elements and drops the rest. reduce folds the whole array into one value — a sum, an object, another array, anything. Reaching for reduce to build a new array is legal and occasionally the cleanest option, but map/filter read better when either one alone would do.

None of the three mutate the original array. push, pop, splice and sort do — sort in particular surprises people, because it sorts in place and returns the same array, so const sorted = nums.sort() quietly reorders nums too.

Destructuring

Pulling values out of an object or array by shape, instead of by obj.property one line at a time.

const { name, email = "unknown" } = user;   // email defaults if absent
const [first, , third] = [1, 2, 3];          // skip an element with a comma
const { address: { city } = {} } = user;     // nested, with a fallback object

The nested default (= {}) matters: without it, a user with no address throws trying to read .city off undefined, rather than quietly giving city the value undefined.

Try it

Spread copies one level deep

const original = { name: "Nino", address: { city: "Tbilisi" } };
const copy = { ...original, name: "Ana" };

copy.address.city = "Batumi";
original.address.city;   // "Batumi" — the same nested object, not a copy

{ ...original } creates a new top-level object, but every value that was itself an object is copied by reference, not cloned. This is a shallow copy, and it is the correct default — a genuine deep copy is rarely what you actually want, and it is easy to reach for structuredClone(value) on the rare occasion it is. Lesson 11 goes further into copying.

Common mistakes

• const sorted = items.sort(...) on data you do not own. The caller's array is reordered too, and sorted === items — the example shows it. Copy first ([...items].sort(...)) or use toSorted.
• reduce with no initial value. On an empty array it throws TypeError: Reduce of empty array with no initial value; always pass the starting value.
• Editing a spread copy's nested object. The original changes with it, because only the top level was copied.
• Nested destructuring without a fallback. const { address: { city } } = user throws when address is missing; add = {}.

What interviewers ask

• What is the difference between map and forEach? — map returns a new array of the callback's results; forEach returns undefined and exists for side effects.
• Does const arr = [] make the array immutable? — No. stops the name being reassigned; the array can still be pushed to and sorted.