How Do Objects Work in JavaScript?

An object is a collection of key and value pairs. A key is a string or a symbol, and a value can be anything at all, including another object or a function. Objects are the base of almost everything else in JavaScript. Arrays are objects, functions are objects, and even a date is an object.

const user = {
  name: 'Ada',
  greet() { return 'Hi ' + this.name; }
};

console.log(user.name);                 // Ada
console.log(user.greet());              // Hi Ada
console.log(typeof user);               // object
console.log(Object.keys(user));         // [ 'name', 'greet' ]
console.log('name' in user);            // true
console.log(user.hasOwnProperty('name')); // true
console.log(Object.entries(user));      // [ [ 'name', 'Ada' ], [ 'greet', [Function] ] ]

A property that holds a function is called a method. The important point is that a method is not owned by the object in any special way. It is simply a value that is stored under a key. When you call it as a method, the object is passed to the function as the receiver, and that is where the this binding comes from.

There are three ways to ask whether a property exists, and they are not the same. The in operator checks the object and its prototype chain, so it also finds inherited properties. The hasOwnProperty method checks only the object itself, and it is the one to use when you care about own properties. The third option is to check the value, and that one cannot tell a missing property apart from a property that holds an empty value.

Every object also has a prototype, and property lookup walks the prototype chain until it finds a match. The chain has its own set of questions, but the practical point for this answer is that a plain object literal inherits from the shared object prototype. That is why toString and valueOf are available on every value.

Two objects are equal only when they are the very same object. The equality operators compare references, so two objects that were created separately are never equal, even when they hold exactly the same content. This is true for the loose comparison as well, because comparing two objects falls back to reference identity.

const a = { id: 1 };
const b = { id: 1 };

console.log(a === b);   // false, two different objects
console.log(a == b);    // false as well
console.log(a === a);   // true, the same object

// Comparing the contents instead:
console.log(JSON.stringify(a) === JSON.stringify(b));   // true

The JSON comparison is the quick and dirty version of comparing contents. It works well for plain data with no special types, but it has real limits. The order of the properties matters, because the two strings differ when the keys are in a different order. Values that JSON cannot represent, such as dates, become strings, so two different dates can compare equal after a round trip. Functions are dropped completely, so two objects that differ only in a function compare equal. A very large integer loses precision on the way through. And an object that refers back to itself makes the serialisation throw an error.

The correct general solution is a comparison that walks both structures, checks the type at each step, compares the keys and the values, and handles dates, arrays, and regular expressions in a special way. The assertion libraries inside most test runners do exactly this. If you are writing tests, you should use the deep equality helper that your test runner already provides instead of writing your own.

There is one more thing worth saying in an interview. If you find yourself needing deep equality inside ordinary application code, there is usually a design problem hiding underneath. It often means that the data should be compared by a stable key such as an id, or that it should be turned into a map that is keyed by that id.

Objects are usually created with an object literal. Copying an object is where the interesting decisions are, because a plain assignment or a spread gives you a shallow copy.

// An object literal.
const point = { x: 1, y: 2 };

// A shallow copy with spread.
const copy = { ...point };
copy.x = 99;
console.log(point.x);   // 1, the top level is independent
console.log(copy.x);    // 99

// Nested objects are still shared by a shallow copy.
const nested = { inner: { count: 1 } };
const shallow = { ...nested };
shallow.inner.count = 5;
console.log(nested.inner.count);   // 5, the inner object is shared

There are two other ways to copy the top level of an object. The Object.assign method copies own enumerable properties from one or more source objects into a target, and it can be used to merge objects. The spread operator does the same job for a single source, and it is the more modern choice because it also works with arrays and with everything else that can be iterated.

The key thing to understand is what the word shallow means. A shallow copy gives you a new object at the top level, but every value inside it is copied by reference. If a property holds an object, then both copies point at that same object, so changing it through one copy is visible through the other. The example above shows exactly that, because the inner count changes to five in the original object as well.

For a real deep copy, use the structuredClone function. It is built into modern browsers and into Node, and it understands dates, maps, sets, typed arrays, and objects that refer back to themselves. The older trick of turning the object into JSON text and parsing it back works for plain data, but it quietly loses dates, drops functions, and fails on circular structures.