Why is it that two objects do not equate in Javascript?

Question

Why is it that two objects do not equate in Javascript?

Although there are similar questions on SO, none of them have the answer I need.

In JavaScript, if you execute the following code, the result will be false:

https://i.sstatic.net/c5T8t.png

I understand it has to do with how JavaScript is defined in the spec, but why is it this way? It doesn't seem logical.

If ("string" === "string") evaluates to true, then why doesn't ({ } === { }) evaluate to true as well?

I read somewhere that the equality algorithm was designed to mimic that of C++ or C#, but it seems like creating a new engine that uses significantly less fuel and not utilizing it just for consistency with other vehicles.

What was the reasoning behind defining JavaScript in this manner? Was there a specific purpose behind this decision, or was it done simply to align with industry standards?

javascript object equality

Answer 1

Answer №1

{} is a special syntax in JavaScript used to create objects. Essentially, you can replace

var obj = new Object();

with

var obj = {};

Therefore, whenever you use {}, you are creating a new object.

The line you referenced, {} == {}, actually creates two distinct objects with no properties. In essence, they are similar. If you were to have an equals(obj1, obj2) method that compares the properties of both obj1 and obj2, it would return true if both objects had the same values for all properties.

However, the == operator does not examine properties; it checks if both objects point to the same object/reference.

On the other hand,

var obj1 = {};
obj2 = obj1;
console.log(obj2 == obj1); // returns true

returns true because both obj1 and obj2 point to the same reference.

Lastly, when it comes to the comparison of strings like "abc" == "abc", the == operator evaluates the actual string contents and returns either true or false based on them.

Answer 2

{} is a special syntax in JavaScript used to create objects. Essentially, you can replace

var obj = new Object();

with

var obj = {};

Therefore, whenever you use {}, you are creating a new object.

The line you referenced, {} == {}, actually creates two distinct objects with no properties. In essence, they are similar. If you were to have an equals(obj1, obj2) method that compares the properties of both obj1 and obj2, it would return true if both objects had the same values for all properties.

However, the == operator does not examine properties; it checks if both objects point to the same object/reference.

On the other hand,

var obj1 = {};
obj2 = obj1;
console.log(obj2 == obj1); // returns true

returns true because both obj1 and obj2 point to the same reference.

Lastly, when it comes to the comparison of strings like "abc" == "abc", the == operator evaluates the actual string contents and returns either true or false based on them.

Answer 3

Answer №2

While strings are unchangeable, making two strings with identical contents essentially indistinguishable.

Conversely, objects and arrays have the capability to be modified, allowing them to be distinct even if they currently share the same values. Altering one will not necessarily affect another.

To illustrate, if obj1 == obj2, modifying obj1.x = 1 will result in a change to obj2.x as well.

Answer 4

While strings are unchangeable, making two strings with identical contents essentially indistinguishable.

Conversely, objects and arrays have the capability to be modified, allowing them to be distinct even if they currently share the same values. Altering one will not necessarily affect another.

To illustrate, if obj1 == obj2, modifying obj1.x = 1 will result in a change to obj2.x as well.

Answer 5

Answer №3

In the realm of JavaScript, a string may be an object but is still considered a primitive like integers or booleans. This means they are always compared by their actual value, as primitives are defined as simple atomic values. For example, "string" == "string", 1 = 1, and true == true all hold true.

On the other hand, objects are complex types made up of multiple primitives, making them more intricate to compare. It is not as straightforward as checking for equal values - {name:'a',address:'b',phone:'c'} != {name:'a',address:'b'} due to differing attributes. The comparison becomes even trickier with slight attribute variations such as {name:'x',address:'y'} == {name:'a',address'b'}, or different attribute orderings like {name:'x',address'y'} == {address:'y',name:'c'}. These complexities make it difficult to implement a standard method of comparing complex objects.

Given this complexity, it is often left to the programmer to define the rules for comparisons between complex objects based on the specific scenario at hand.

One useful method implemented in programming languages is comparing if two object references are equal, which allows for validations like obj == null, obj == this, or obja == objb to determine the identity of the objects being referenced. In essence, primitives are compared by value while complex types are typically compared by reference, following the usual conventions across most programming languages.

Answer 6

In the realm of JavaScript, a string may be an object but is still considered a primitive like integers or booleans. This means they are always compared by their actual value, as primitives are defined as simple atomic values. For example, "string" == "string", 1 = 1, and true == true all hold true.

On the other hand, objects are complex types made up of multiple primitives, making them more intricate to compare. It is not as straightforward as checking for equal values - {name:'a',address:'b',phone:'c'} != {name:'a',address:'b'} due to differing attributes. The comparison becomes even trickier with slight attribute variations such as {name:'x',address:'y'} == {name:'a',address'b'}, or different attribute orderings like {name:'x',address'y'} == {address:'y',name:'c'}. These complexities make it difficult to implement a standard method of comparing complex objects.

Given this complexity, it is often left to the programmer to define the rules for comparisons between complex objects based on the specific scenario at hand.

One useful method implemented in programming languages is comparing if two object references are equal, which allows for validations like obj == null, obj == this, or obja == objb to determine the identity of the objects being referenced. In essence, primitives are compared by value while complex types are typically compared by reference, following the usual conventions across most programming languages.

Why is it that two objects do not equate in Javascript?

Answer №1

Answer №2

Answer №3

Similar questions

I encountered an error stating "angular not found" when attempting to dynamically load my Angular scripts

Adding up and finding the contrast between odd and even numbers

What causes the closure variable to be reset after iterating over JSON data using $.each method?

The React snackbar is mysteriously peeking out from behind the popup

The Electron BrowserWindow event triggered when the window is closed

Parsley JS failing to validate

`What's the best way to merge 3 IDs after pressing a button?`

Introduction to Interactive HTML Pinball Game

Implementing sliders for interactive functionality with an HTML table

Object-oriented programming (OOP) implementation with asynchronous JavaScript and XML (

Error encountered during discord oauth request

Numerous rotation and resizing transitions failing to function properly

What steps should I take to include a React component in my HTML document?

The ReactJS Application Cache Client fails to display the most recent updates

Scaling texture to fit on a plane in THREE.js

Acquire information using Vue through HTTP requests based on Router parameters

Removing a specific item from an array

Access the URL with personalized request headers

Listening for button clicks in a Bootstrap drop down menu using JavaScript

How to tally objects within an array of nested array objects based on a specific property using JavaScript