Arrays and Objects in Practice

• map(fn) → new array, same length, one transformed value per element
• filter(fn) → new array of elements where fn is truthy
• filter length can shrink to 0, never grows

const nums = [1, 2, 3];
nums.map(x => x * 2);     // [2, 4, 6]
nums.filter(x => x > 5);  // []

same length vs shrunk to 0

• reduce((acc, x) => ..., init) folds an array into one value
• acc carries the result between calls
• Always pass init: empty array with no init throws TypeError

[].reduce((a, x) => a + x);        // TypeError
[].reduce((a, x) => a + x, 0);     // 0
[1, 2, 3].reduce((a, x) => a + x, 0);  // 6

init is also the result for an empty array

• Array spread copies or merges: [...a, ...b]
• Object spread merges, later keys win
• Rest collects the remainder: [head, ...tail], { id, ...others }
• Rest must come last

const all = [...a, ...b];
const cfg = { ...defaults, ...overrides };
// overrides.size replaces defaults.size

order decides the winner

• b = a copies the reference, not the data; mutating b also mutates a
• Spread, Object.assign, slice, Array.from make shallow copies
• Top level is new; nested objects are still shared

const o = { inner: { x: 0 } };
const c = { ...o };
c.inner.x = 1;
console.log(o.inner.x); // 1

the shallow copy trap: o.inner is shared

• structuredClone(value) is a true deep copy
• Handles Date, Map, Set, RegExp and circular references
• Drops class prototypes and getters
• JSON.parse(JSON.stringify(x)) is a lossy deep copy

• Object.entries(obj) returns [key, value] pairs of own enumerable string keys
• Object.keys gives keys only; Object.values gives values only

const obj = { a: 1, b: 2 };
Object.fromEntries(
  Object.entries(obj).map(([k, v]) => [k, v*2])
);

result { a: 2, b: 4 }: every value transformed