The equality operator [ The equality operators [ Loose equality is symmetric: The most notable difference between this operator and the strict equality [==
] 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. Try it
Syntax
Description
==
and !=
] provide the IsLooselyEqual semantic. This can be roughly summarized as follows:true
only if both operands reference the same object.true
only if both operands have the same characters in the same order.true
only if both operands have the same value. +0
and -0
are treated as the same value. If either operand is NaN
, return false
; so, NaN
is never equal to NaN
.true
only if operands are both true
or both
false
.true
only if both operands have the same value.true
only if both operands reference the same symbol.null
or undefined
, the other must also be null
or undefined
to return true
. Otherwise return false
.@@toPrimitive[]
[with "default"
as hint], valueOf[]
, and toString[]
methods, in that order. [This primitive conversion is the
same as the one used in addition.]false
.true
is converted to 1, and false
is converted to 0. Then compare the two operands loosely again.Number[]
constructor. Conversion failure would result in NaN
, which will guarantee the equality to be false
.NaN
, return false
.BigInt[]
constructor. If conversion fails, return false
.A == B
always has identical semantics to B == A
for
any values of A
and B
[except for the order of applied conversions].===
] 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. The strict equality
operator essentially carries out only step 1, and then returns false
for all other cases.
There's a "willful violation" of the above algorithm: if one of the operands is document.all
, it is treated as if it's undefined
. This means that document.all == null
is true
, but document.all === undefined && document.all === null
is false
.
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
Comparing arrays and strings
const a = [1, 2, 3];
const b = "1,2,3";
a == b; // true, `a` converts to string
const c = [true, 0.5, "hey"];
const d = c.toString[]; // "true,0.5,hey"
c == d; // true
Specifications
ECMAScript Language Specification # sec-equality-operators |
Browser compatibility
BCD tables only load in the browser