A JavaScript object exposes `fullName` through a getter. You copy the object with `{ ...user }` — what does the copy actually contain, and how do you copy it so the accessor survives?

## What spread and `Object.assign` actually do Both operations enumerate the source's own enumerable keys — strings and symbols — and for each one perform an ordinary **read**, then store the resulting value in the target. Nothing about the property's descriptor travels; only the value it produced at that instant. ```js const user = { first: 'Ada', last: 'Lovelace', get fullName() { return `${this.first} ${this.last}`; }, }; const copy = { ...user }; Object.getOwnPropertyDescriptor(copy, 'fullName'); // { value: 'Ada Lovelace', writable: true, enumerable: true, configurable: true } user.first = 'Augusta'; console.log(user.fullName); // 'Augusta Lovelace' console.log(copy.fullName); // 'Ada Lovelace' — snapshot, not a live accessor ``` The getter ran exactly once, during the copy. The copy now holds a plain string. Three consequences follow, and each is a real bug people ship: 1. **Staleness.** The derived value no longer derives from anything; it silently drifts out of sync with the fields it was computed from. 2. **Lost validation.** If the source had a setter enforcing an invariant, the copy accepts any assignment without complaint. 3. **Unexpected work, or an unexpected throw.** An expensive getter runs during what looked like a cheap copy, and a getter that throws makes the copy itself throw — often at a call site that has no idea an accessor was involved. ## What else is lost - **Non-enumerable own properties** are skipped, because both operations walk enumerable keys only. Hidden metadata installed with `Object.defineProperty` disappears. - **The prototype is not copied.** `{ ...instance }` produces a plain object whose prototype is `Object.prototype`, so class methods and prototype accessors are gone and `instanceof` no longer holds. That is why spreading a class instance yields a lifeless data bag. - **Descriptor flags are reset.** Even for surviving data properties, the copy's properties are writable, enumerable and configurable regardless of what the source's flags were, because they are created by ordinary definition on a fresh object. Enumerable **symbol-keyed** properties, by contrast, *are* copied by both spread and `Object.assign` — a detail people frequently get backwards. ## The descriptor-preserving copy The fix is to copy the records, not the values: ```js const clone = Object.create( Object.getPrototypeOf(user), Object.getOwnPropertyDescriptors(user), ); Object.getOwnPropertyDescriptor(clone, 'fullName'); // { get: [Function: get fullName], set: undefined, enumerable: true, configurable: true } user.first = 'Augusta'; console.log(clone.first); // 'Ada' — own data copied by value clone.first = 'Augusta'; console.log(clone.fullName); // 'Augusta Lovelace' — accessor still live ``` `Object.getOwnPropertyDescriptors(obj)` (ES2017) returns a map from every own key to its full descriptor, including non-enumerable ones and symbols. `Object.create(proto, descriptorMap)` builds a new object with that prototype and those exact descriptors. The pair is the standard recipe for a faithful shallow clone. For merging into an object that already exists, use the same descriptor map with `Object.defineProperties`: ```js Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); ``` ## `Object.assign` has one extra hazard Spread creates properties on a brand-new object by definition, so the target's own setters can never be involved. `Object.assign` instead performs an ordinary **assignment** on the target, which means an existing setter on the target — or on the target's prototype — runs for each copied key, and a non-writable target property makes the whole call throw a `TypeError` in strict mode partway through, leaving the target half-updated. When the target is a class instance rather than `{}`, that difference is worth knowing before you reach for `Object.assign`. ## Still shallow Neither approach deep-copies. Nested objects are shared by reference in every version above; the descriptor recipe simply guarantees that the *properties* of the top-level object are reproduced faithfully rather than flattened. ## How to answer this in an interview State the mechanism first — spread performs reads, so accessors collapse into values — then name the three losses (accessor-ness, non-enumerable keys, prototype), then give the `getOwnPropertyDescriptors` recipe. Finish with the pragmatic note: if a type has real behaviour, prefer an explicit factory or a `clone()` method over generic copying, because a spread of a rich object quietly produces something that has the same keys and none of the same guarantees.