Objects and prototypes

An object in JavaScript is a set of properties, where each property is described not only by its value but by a hidden descriptor: the flags writable, enumerable, configurable. These flags decide whether a property can be overwritten, whether enumeration sees it, and whether it can be deleted. You create most properties with a plain assignment and never notice descriptors — until a class method fails to show up in Object.keys, or a frozen object silently ignores a write.

This topic covers the mechanics of objects themselves: how they are created, how descriptors and accessors work, in what order keys enumerate, and why copying is shallow by default. The prototype chain — how objects inherit from one another — gets its own topic, Prototypes & Inheritance. The full map is in the layers below.

Topic map

• Object creation — the literal {}, Object.create, a constructor with new and class, plus computed property names.
• Property descriptors — the writable/enumerable/configurable flags, defineProperty, and getOwnPropertyDescriptor.
• Accessor properties — get/set instead of a stored value — computing on read and validating on write.
• Property enumeration — Object.keys/values/entries versus for...in, the enumerable flag, and why class methods are invisible.
• Property order — integer keys ascending, then string keys in insertion order, then symbols.
• Object copying — shallow copy (spread, Object.assign) versus deep (structuredClone) and the shared-reference trap.

Common traps

Interview relevance

Objects are asked to check whether you understand the difference between value and reference and know that a property is not just "a key and a value" but a record with flags. A candidate who answers the copying question with "spread copies one level, the nested part stays shared by reference" sounds more confident than one who confuses a copy with a clone.

Typical checks:

• The ways to create an object and how Object.create(proto) differs from a literal.
• What a descriptor is and which flags it holds; why defineProperty exists.
• Why for...in sees inherited keys while Object.keys does not.
• The key enumeration order and why {2:'a',1:'b'} yields 1,2.
• Shallow versus deep copy and what structuredClone does.

Common wrong answer: "Object.assign makes a deep copy." In fact it is a shallow, one-level copy — nested objects and arrays stay shared by reference, and a mutation through one side is visible on the other.