Contents
Why “===” Does Not Equal “==” in JavaScript – In this blog post, we’ll explore the reasons why “===” doesn’t equal “==” in JavaScript and how you can avoid this gotcha.
Checkout this video:
The Difference Between “==” and “===” in JavaScript
“==” and “===” are both comparison operators in JavaScript. However, they are not the same. “==” only compares the value of two things, while “===” compares the value and the type of two things. This can be confusing, so let’s take a closer look.
“==” checks for value equality
In programming, the equal sign (“=”) is used to signify assignment, not equality. So how do we check if two values are actually equal to each other? In JavaScript, there are two different ways of accomplishing this — with the == operator and the === operator.
The == operator performs a type conversion before checking for value equality, while the === operator does not. This means that, in order for == to return true, the two values must first be converted to the same type. However, === will only return true if the two values have both the same type and value.
For simple types (like numbers), this is usually not an issue — but for more complex types (like objects), it can definitely lead to some unexpected results:
let x = 5;
let y = “5”;
console.log(x == y); //true
console.log(x === y); //false
Because of type conversion, == actually compares whether x and y are equal in value — not in type. Even though they’re not of the same type, JavaScript will automatically convert one to match the other before checking for equality (in this case, it converts 5 to “5”). On the other hand, === compares both value and type, so it will return false since 5 !== “5”.
Overall, it’s always best to use === unless you have a specific reason to use ==. With ===, you avoid any potential weirdness that might pop up due to type conversion — and you can sleep soundly knowing that your comparisons are being done correctly.
“===” checks for value and type equality
In JavaScript, both “==” (double equals) and “===” (triple equals) can be used to check if two values are equal. But how do they differ?
The == operator checks for value equality, meaning that it will convert different types of values to see if they are equal. For example, the string “1” is equal to the number 1. This can sometimes be useful, but it can also lead to unexpected results.
The === operator checks for both value and type equality, meaning that it will not convert different types of values. This can avoid some problems, but it also means that === may not behave as you expect.
Why You Should Use “===” in JavaScript
“===” is known as the strict equality operator and it does not convert data type while comparing two values, on the other hand “==” is known as the equality operator and it converts the data types of values before comparing them. That is why “===” is always recommended over “==”.
It avoids type coercion
In JavaScript, “==” (double-equals) comparison operator automatically does something called type coercion when comparing values of different types.
For example, let’s say you have two variables:
var a = 1;
var b = “1”;
You would think that the comparison a == b would return true, but it actually returns false. This is because when the comparison tries to compare a number with a string, JavaScript automatically coerces the string to a number first (in this case, it becomes 1). As a result, the two values are not equal to each other.
In order to get around this issue, you can use the “===” (triple-equals) comparison operator instead. This operator does not do any type coercion, so it will return false if the two values being compared are not of the same type. In our example above, the expression a === b would return false.
It makes your code more readable
If you are coming to JavaScript from another programming language, you might be surprised to find that the === operator behaves differently than the == operator. The == operator will compare two values and return true if they are equal. The === operator, on the other hand, will compare two values and return true if they are equal and of the same type.
This might not seem like a big deal, but it can actually make a big difference in the readability of your code. When you use the == operator, you are implicitly telling the reader of your code that you are aware that the two values might not be of the same type, but that you don’t care about that distinction. On the other hand, when you use the === operator, you are telling the reader of your code that you do care about the distinction between different types.
There is also a difference in how these two operators handle certain types of values. For example, when comparing a string and an integer with the == operator, JavaScript will first convert the string to an integer and then compare the two values. This can lead to some unexpected results:
“`javascript
“5” == 5 //true
“5” === 5 //false
“`
When You Should Use “==” in JavaScript
“===” and “==” are both comparison operators in JavaScript, but they are not the same. “===” is called the strict equality operator while “==” is called the abstract equality operator. The strict equality operator will only return true if the two operands are of the same type and have the same value. The abstract equality operator will convert the operands to the same type before comparing them.
When you want to check for value equality
JavaScript has two different ways of checking if two values are equal to each other: the double equals == and the triple equals === . So what’s the difference and when should you use each one?
The main difference is that == will try to convert (coerce) the values being compared to the same type before comparing, while === does not do any type conversion. This can lead to some unexpected results, as we’ll see below.
Double equals (==) will convert the types before comparing:
-If both values are numbers, then it will compare their numeric values.
-If both values are strings, then it will compare them alphabetically.
-If one value is a boolean, it will convert it to 1 if true or 0 if false before comparing.
When you want to check for value and type equality
In JavaScript, there are two main ways to check if a value is equal to another value:
The double equals == operator
The triple equals === operator
You might think that these two operators would work exactly the same way, but they don’t. In fact, they perform two completely different operations.
The == operator will check for value equality. This means that it will convert the values to the same type before checking for equality. For example, the values 5 and “5” are equal when using the == operator because JavaScript will convert the string “5” to a number 5 before checking for equality.
The === operator, on the other hand, will not convert the values to the same type before checking for equality. This means that the values 5 and “5” are NOT equal when using the === operator because they are of different types.
