How does JavaScript compare objects with `===`?

That result is expected. With objects, === asks whether the two operands refer to the very same object. It does not compare their properties one by one. Separately creating two objects with the same property names and values gives you two distinct objects, so strict equality is false. [S1]

For example:

const first = { name: "Mina", score: 8 };
const second = { name: "Mina", score: 8 };

console.log(first === second); // false

The contents match, but first and second refer to separately created objects. Think of === here as an identity check, not a test for matching contents. If you need to decide whether two objects are equivalent for your application, define what “equivalent” means and compare the relevant data accordingly.

Both variables then refer to the same object, so comparing them with === returns true. A runnable example that shows both cases is:

const first = { name: "Mina", score: 8 };
const separate = { name: "Mina", score: 8 };
const shared = first;

console.log(first === separate); // false
console.log(first === shared);   // true

The first comparison is false because separate was created as another object. The second is true because shared was assigned the object already referred to by first. The example demonstrates reference identity; it does not test whether two separately created objects have equivalent data. [S1]

Yes. For primitive values of the same type, strict equality compares their values. It does not coerce one type to another, so 3 === 3 is true, but 3 === "3" is false. Objects follow the identity rule instead. [S1]

console.log(3 === 3);       // true
console.log(3 === "3");    // false
console.log({ id: 1 } === { id: 1 }); // false

One technical boundary: the general primitive rule has numeric edge cases. NaN is unequal to itself, while positive and negative zero compare equal. [S1] These examples focus on ordinary numbers, strings, and object references; they are not a deep comparison utility.

Start by identifying what the comparison is meant to answer. If you want to know whether two variables refer to one object, === is appropriate. If you want to know whether their contents match, decide which properties matter and compare those deliberately; the result you want cannot be inferred from === alone.

A useful way to inspect a case is to write down where each value comes from, then log the comparison and the values separately. For example, label the values as “created separately” or “assigned from the same variable.” This helps distinguish a reference-identity check from a content comparison without assuming that identical-looking objects are the same object.