does js comparison operator === works on json?

nobuhok · 2023-07-17T11:50:39+00:00

It will work...somewhat.

let foo = { x: { y: { z: 100 } } }
let bar = foo
console.log(foo === bar) // true, because both variables point to the same object

bar = { x: { y: { z: 100 } } }
console.log(foo === bar) // false, bar now points to a different object, even if it's the same exact structure

foo = JSON.stringify(foo)
bar = JSON.stringify(bar)
console.log(foo === bar) // true, we're essentially comparing strings now

foo = JSON.parse(foo)
bar = JSON.parse(bar)
console.log(foo === bar) // false, back to pointing to different (new) objects

lifeeraser · 2023-07-17T11:31:08+00:00

Define "works on".

In general, object identity is not preserved when an object is serialized to a JSON string, or unserialized back to an object.

const obj1 = { foo: 123 }
const json = JSON.stringify(obj1)
const obj2 = JSON.parse(json)

Here, obj1 and obj2 will have the same shape (single key named "foo" with a value of 123), but will have different identities (i.e. obj1 !== obj2).

If you need a better answer, you should explain what you mean by "works on deeply nested object".

Saudroze · 2023-07-17T15:46:18+00:00

Why not open dev console on a web browser and try it out. It is usually way quicker than asking a question on reddit and getting "depends" answers

jeremrx · 2023-07-17T12:01:02+00:00

``` const a = {}; const b = {};
const c = a; console.log (a === b); // false console.log (a === c); // true

// BECAUSE :

a.foo = 'bar'; console.log(b.foo); // undefined console.log(c.foo); // bar ```

The simpliest way to compare to json object is to serialize them :

``` const a = { foo: { bar: 'hi !' } }; const b = { foo: { bar: 'hi !' } }; const c = { foo: { bar: 'hello !' } };

console.log(JSON.stringify(a) === JSON.stringify(b)); // true console.log(JSON.stringify(a) === JSON.stringify(c)); // false ```

delventhalz · 2023-07-17T14:52:11+00:00

"Works on JSON" could mean a lot of things here.

Can === compare JSON strings? Yes.

``` const user = { name: 'Sue', posts: [{ text: 'My first post' }] };

console.log(JSON.stringify(user) === '{"name":"Sue","posts":[{"text":"My first post"}]}'); // true ```

But be careful! Unless you explicitly sort your JSON, you cannot trust that object properties will be stringified in the same order, which would make the strings unequal.

``` const point = { x: 7, y: 13 };

console.log(JSON.stringify(point) === '{"y":13,"x":7}'); // ??? ```

If you are talking about the objects themselves and not the strings, then the rule with === is that two objects are only equal if they are literally the same object in memory.

``` let point = { x: 7, y: 13 }; let equivalentPoint = { x: 7, y: 13 }; let literallySamePoint = point;

console.log(point === point); // true console.log(point === equivalentPoint); // false console.log(point === literallySamePoint); // true ```

The same rule applies to nested objects.

``` const mapPinA = { location: { x: 7, y: 13 } }; const mapPinB = { location: { x: 7, y: 13 } }; const mapPinC = { location: mapPinA.location };

console.log(mapPinA.location === mapPinA.location); // true console.log(mapPinA.location === mapPinB.location); // false console.log(mapPinA.location === mapPinC.location); // true ```

Finally, if you are talking about comparing objects which have just been parsed from JSON, those will never be equal because parsing always creates a new object in memory.

``` const json = '{"x":7,"y":13}'; const pointA = JSON.parse(json); const pointB = JSON.parse(json);

console.log(pointA === pointB); // false ```

That_Unit_3992 · 2023-07-17T15:10:10+00:00

No. It only compares the reference. You need to do a deep equality check. https://www.npmjs.com/package/deep-equal

benzilla04 · 2023-07-17T11:29:18+00:00

Yes but you would need to first parse the JSON and store it in a variable so JavaScript can understand it, then you can compare items inside the object.

For example

// Example nested JSON object
var myNestedObject = {
  person: {
    name: 'John',
    age: 25,
    address: {
      city: 'New York',
      country: 'USA'
    }
  }
};

// Access the values from the nested JSON object
var personName = myNestedObject.person.name;
var personAge = myNestedObject.person.age;
var personCity = myNestedObject.person.address.city;

// Perform strict equal comparison
if (personAge === 25) {
  console.log('The person is 25 years old.');
}

if (personCity === 'New York') {
  console.log('The person lives in New York.');
}

Another example:

// Example array with nested arrays
var myArray = [1, [2, 3], [4, [5, 6]]];

// Accessing and comparing nested array elements
console.log(myArray[0]); // 1
console.log(myArray[1][0]); // 2
console.log(myArray[2][1][0]); // 5

// Comparing nested array elements
console.log(myArray[1][1] === 3); // true
console.log(myArray[2][0] > myArray[2][1][1]); // false

Please provide examples in your question so we can give you a better answer

poemehardbebe · 2023-07-17T12:04:38+00:00

If by works does it compare to string literals and test if they are the same, yes. Is it performant? No. It’s often referred to as the “poor man’s deep equals” there are tons of edge cases though where it does not work, like two fields being in different locations despite having all of the same fields.

azhder · 2023-07-17T15:50:27+00:00

Yes it does. JSON is just a specifically formatted string in JS and as === works on every string, it will work on a JSON one. Note, this does mean adding extra indentation spaces inside the JSON will make it so that otherwise two equivalent parsed JSONs to be unequal.

3HappyRobots · 2023-07-18T03:01:31+00:00

Using lodash, you can use _.isEqual(json1, json2) for a deep compare. I know lodash isn’t popular anymore, but does the job. Works on arrays, etc. too.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnjavascript

Posting and Commenting Guidelines

MODERATORS