The equality operators (== and!=) provide theIsLooselyEqual semantic. This can be roughly summarized as follows:

1. If the operands have the same type, they are compared as follows:
   • Object: returntrue only if both operands reference the same object.
   • 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; so,NaN is never equal toNaN.
   • Boolean: returntrue only if operands are bothtrue or bothfalse.
   • BigInt: returntrue only if both operands have the same value.
   • Symbol: returntrue only if both operands reference the same symbol.
2. If one of the operands isnull orundefined, the other must also benull orundefined to returntrue. Otherwise returnfalse.
3. If one of the operands is an object and the other is a primitive,convert the object to a primitive.
4. At this step, both operands are converted to primitives (one of String, Number, Boolean, Symbol, and BigInt). The rest of the conversion is done case-by-case.
   • If they are of the same type, compare them using step 1.
   • If one of the operands is a Symbol but the other is not, returnfalse.
   • If one of the operands is a Boolean but the other is not,convert the boolean to a number:true is converted to 1, andfalse is converted to 0. Then compare the two operands loosely again.
   • Number to String:convert the string to a number. Conversion failure results inNaN, which will guarantee the equality to befalse.
   • Number to BigInt: compare by their mathematical value. If the number is ±Infinity orNaN, returnfalse.
   • String to BigInt: convert the string to a BigInt using the same algorithm as theBigInt() constructor. If conversion fails, returnfalse.

Loose equality issymmetric:A == B always has identical semantics toB == A for any values ofA andB (except for the order of applied conversions).

The most notable difference between this operator and thestrict 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. The strict equality operator essentially carries out only step 1, and then returnsfalse for all other cases.

There's a "willful violation" of the above algorithm: if one of the operands isdocument.all, it is treated as if it'sundefined. This means thatdocument.all == null istrue, butdocument.all === undefined && document.all === null isfalse.

Note that strings constructed usingnew String() are objects. If youcompare one of these with a string literal, theString object will beconverted to a string literal and the contents will be compared. However, if bothoperands areString objects, then they are compared as objects and mustreference 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); // trueconsole.log(string1 == string3); // trueconsole.log(string2 == string3); // trueconsole.log(string3 == string4); // falseconsole.log(string4 == string4); // true

• Inequality (!=)
• Strict equality (===)
• Strict inequality (!==)