What is Object.is() method in Javascript?

I was scrolling through my WhatsApp status in search of memes to take my mind off the stress of the day in my usual manner when I came across a code snippet on the object.is() method in Javascript. It piqued my interest since I just learned about it for the first time. I decided to do some digging about it. This article is a result of my research and provides insight into how I understood the subject matter.

JavaScript has a number of different ways to compare values, and one of these is the Object.is() method. This method allows you to determine whether two values are the same, and it is similar to the === operator. However, there are some key differences between Object.is() and === that you should be aware of. In this article, we will take a closer look at the Object.is() method and how it can be used in your JavaScript programs.

First, let’s start by looking at the syntax for the Object.is() method. The basic syntax for this method is as follows:

Object.is(value1, value2)

Here, value1 and value2 are the two values that you want to compare. The Object.is() method will return a boolean value of true if value1 and value2 are the same, and false if they are not.

Now, you might be wondering how Object.is() is different from the === operator. After all, the === operator is also used to compare values in JavaScript, and it returns a boolean value depending on whether the values are the same or not. So what's the difference?

One of the main differences between Object.is() and === is that Object.is() is more sensitive to differences in value. For example, consider the following code:

const x = 0;
const y = -0;

console.log(x === y); // Output: true
console.log(Object.is(x, y)); // Output: false

Here, we have two variables x and y, both of which are set to the number 0. However, y is set to -0, which is a special value in JavaScript that represents a negative version of zero.

If we use the === operator to compare x and y, the result will be true. This is because === treats 0 and -0 as the same value. However, if we use the Object.is() method to compare x and y, the result will be false. This is because Object.is() is more sensitive to differences in value, and it treats 0 and -0 as different values.

Another key difference between Object.is() and === is how they handle the special value NaN. In JavaScript, NaN stands for "Not a Number", and it is a special value that represents a numeric value that is not a number. For example, you might get the value NaN if you try to perform a mathematical operation on a value that is not a number, like this:

const x = 'foo';
const y = x * 2;

console.log(y); // Output: NaN

If you try to compare NaN using the === operator, the result will always be false, even if you compare NaN to itself. This can be a bit confusing because you might expect NaN === NaN to return true. However, this is not the case.

On the other hand, if you use the Object.is() method to compare NaN, the result will be true if both values are NaN.

I hope you have been able to learn something too. Feel free to connect with me and drop your comments or questions.