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.