The equality operator (==
) checks whether its two operands are equal,
returning a Boolean result. Unlike the strict
equality operator, it attempts to convert and compare operands that are of
different types.
The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.
Syntax
x == y
Description
The equality operators (==
and !=
) use the Abstract Equality
Comparison Algorithm to compare two operands. This can be roughly summarised as
follows:
- If the operands are both objects, return
true
only if both operands reference the same object. - If one operand is
null
and the other isundefined
, returntrue
. - If the operands are of different types, try to convert them to the same type before
comparing:
- When comparing a number to a string, try to convert the string to a numeric value.
- If one of the operands is
Boolean
, convert the Boolean operand to 1 if it istrue
and +0 if it isfalse
. - If one of the operands is an object and the other is a number or a string, try
to convert the object to a primitive using the object's
valueOf()
andtoString()
methods.
- If the operands have the same type, they are compared as follows:
String
: returntrue
only if both operands have the same characters in the same order.Number
: returntrue
only if both operands have the same value.+0
and-0
are treated as the same value. If either operand isNaN
, returnfalse
.Boolean
: returntrue
only if operands are bothtrue
or bothfalse
.
The most notable difference between this operator and the strict
equality (===
) operator is that the strict equality operator does not
attempt type conversion. Instead, the strict equality operator always considers operands
of different types to be different.
Examples
Comparison with no type conversion
1 == 1; // true
"hello" == "hello"; // true
Comparison with type conversion
"1" == 1; // true
1 == "1"; // true
0 == false; // true
0 == null; // false
0 == undefined; // false
0 == !!null; // true, look at Logical NOT operator
0 == !!undefined; // true, look at Logical NOT operator
null == undefined; // true
const number1 = new Number(3);
const number2 = new Number(3);
number1 == 3; // true
number1 == number2; // false
Comparison of objects
const object1 = {"key": "value"}
const object2 = {"key": "value"};
object1 == object2 // false
object2 == object2 // true
Comparing strings and String objects
Note that strings constructed using new String()
are objects. If you
compare one of these with a string literal, the String
object will be
converted to a string literal and the contents will be compared. However, if both
operands are String
objects, then they are compared as objects and must
reference the same object for comparison to succeed:
const string1 = "hello";
const string2 = String("hello");
const string3 = new String("hello");
const string4 = new String("hello");
console.log(string1 == string2); // true
console.log(string1 == string3); // true
console.log(string2 == string3); // true
console.log(string3 == string4); // false
console.log(string4 == string4); // true
Comparing Dates and strings
const d = new Date('December 17, 1995 03:24:00');
const s = d.toString(); // for example: "Sun Dec 17 1995 03:24:00 GMT-0800 (Pacific Standard Time)"
console.log(d == s); //true
Specifications
Browser compatibility
BCD tables only load in the browser