What does it equal?

Equality operators are operators that compare two values ​​to determine whether they are identical or different and return a boolean (true or false) depending on the result of the comparison. For equality comparison we have two operators in javascript one is Equals(==) operator and the other is Strict Equals(===) operator.

Equals Operator

The Equals operator is quite liberal that is the values may be considered equal even if their types are not same. Javascript features weak typing. This means that the equality operator coerces types of one or both operands into a single type (usually a number) to perform comparison. Below is the list of some interesting conditions and their results.

Condition	Result
“” == “0″	false
0 == “”	true
0 == “0″	true
false == “false”	false
false == “0″	true
false == undefined	false
false == null	false
null == undefined	true
” \t\r\n” == 0	true

Now lets see how ECMA defined == logic. Only thing is that undefined and null equal each other (and nothing else) and most other types get coerced to a number to facilitate comparison:

Type(x)	Type(y)	Result
null	undefined	true
undefined	null	true
Number	String	x == toNumber(y)
String	Number	toNumber(x) == y
Boolean	any	toNumber(x) == y
any	Boolean	x == toNumber(y)
String or Number	Object	x == toPrimitive(y)
Object	Sring or Number	toPrimitive(x) == y
Both are of same type		x === y (srict equals)
Otherwise		false

Where the result is an expression the algorithm is reapplied until the result is a boolean. toNumber() and toPrimitive() are internal methods which convert their arguments according to the following rules:

toNumber():

Argument Type	Result
undefined	NaN
Null	+0
Boolean	Result is 1 if argument is true Result is 0 if argument is false
String	Parses to number. For ex: ‘abc’ returns NaN ’123′ returns 123
Object	first primValue = toPrimitive(argument) then toNumber(primValue)

toPrimitive():

Argument Type	Result
Object	(in the case of equality operator coercion) if valueOf returns a primitive, return it. Otherwise if toString returns a primitive return it. Otherwise throw an error
otherwise	The result equals the input argument (no conversion).

Lets see a simple condition and how its value is deduced

Condition: “SomeString” == true

Step1: First boolean is converted into number using toNumber. So now the resultant condition would be

“SomeString” == 1

Step2: Next the String is converted to Number again using the toNumber. So the resultant condition would be

Nan == 1

Result: now the above conditio returns false

Strict Equals Operator (===)

The strict equality operator consists of three equal signs: ===. It works exactly like the normal equality operator, except that strict equality operator does not perform type coercion between its operands. Below is the list of some interesting conditions and their results.

Condition	Result
“” === “0″	false
0 === “”	false
0 === “0″	false
false === “false”	false
false === “0″	false
false === undefined	false
false === null	false
null === undefined	false
” \t\r\n” === 0	false

Lets see when to choose equals and StrictEquals operators

The strict equals operator is a lot clearer and allow early breakage of code(no coercion). This hardens code to a certain degree and also gives performance improvements in case the operands are of different types. But completely avoiding the equals operator is also not wise. For example consider the following conditions

Condition1: typeof variable1 === “function”

Condition2: typeof variable1 == “function”

Considering the above two conditions the condition2 is a better option. The reason being typeof returns a string, so the operation always compares two strings , hence it is completely coercion proof.

So when there is no chance for coercion then == operator can be used at its best performance. The decision should be taken wisely.