Objects & Prototypes

Object.keys(obj), Object.values(obj), and Object.entries(obj) return arrays of the object's own enumerable string-keyed properties. for...in loops over enumerable string keys too, but also walks inherited ones from the prototype chain, so you guard it with obj.hasOwnProperty(key) to skip inherited keys.

The common ways are: the object literal {} (most used); new Object() (discouraged); Object.create(proto), which makes an object with proto as its prototype; a constructor function called with new; and ES6 class syntax, which is sugar over the prototype system. All produce plain objects but differ in how the prototype is set.

An accessor property has no stored value; instead get runs a function on read and set runs one on write, accessed with plain property syntax like obj.lang. They let you compute a value on access or validate on assignment while looking like a normal field, hiding logic behind the dot. A property is either an accessor or a data property, not both.

Both Object.assign({}, o) and the spread {...o} make a shallow copy: they create a new object and copy the source's own enumerable properties one level deep. Primitive values are copied by value, but a nested object is copied by reference, so the original and the copy share that nested object and a mutation through one is visible in the other.

A shallow copy duplicates only the top level; nested objects are shared by reference, so Object.assign and spread leave the copy and original pointing at the same inner objects. A deep copy recursively duplicates every nested object so the two share nothing. structuredClone produces a deep copy of most data without the JSON round-trip's loss of functions and dates.

Own keys come out in a fixed order: integer-like keys first, sorted ascending numerically, then all other string keys in insertion order, then symbol keys in insertion order. So {2:'a', 1:'b', x:'c'} enumerates as 1, 2, x. This order is honoured by Object.keys, for...in, JSON.stringify, and spread.

A computed name {[expr]: v} evaluates expr at construction time and uses its result as the key, so the key can be dynamic. Shorthand {x} is sugar for {x: x}, and {f(){}} defines a method. Literals can also declare accessors with get name(){} / set name(v){}, which create getter/setter descriptors rather than plain data properties.

A descriptor is the record describing one property. A data property has value, writable, enumerable, and configurable; an accessor property replaces value/writable with get/set. Object.defineProperty creates or edits a property with chosen attributes (defaulting to false), and Object.getOwnPropertyDescriptor reads them back. configurable: false locks the attributes themselves.

A property's enumerable descriptor flag decides whether it shows up. Object.keys, for...in, and JSON.stringify list only enumerable own string keys; for...in additionally climbs the prototype chain. Object.getOwnPropertyNames returns all own string keys including non-enumerable ones but never inherited ones. Methods defined on class prototypes are non-enumerable by default.

Object.freeze only flips each own property's descriptor to writable: false and configurable: false; a property holding a nested object still references a fully mutable object, so the freeze stops at one level. To deep-freeze you recurse: freeze the object, then walk its own object-valued properties and freeze each, guarding against already-frozen objects to avoid cycles.

The [[OwnPropertyKeys]] internal method fixes ordering: integer-index keys ascending, then string keys in insertion order, then symbols in insertion order. Object.keys and friends follow it exactly. for...in order, however, was left unspecified until ES2020 — engines differed (notably on integer keys), so older code could not rely on it. Symbol keys are excluded from Object.keys, for...in, and JSON.stringify.