Javascript: Difference between strict and lenient equality

[sgmb id=3]


In Javascript everyone recommends to use strict equality instead of lenient. In this article we will see the difference between strict and lenient equality and discover why it should not be used. So lets begin.

2 == true  // 2 === 1

2 == false  // 2 === 0

1 == true  // 1 === 1

0 == false  // 0 === 0

2 is not equal to true because lenient equality tries to convert true to number which is 1 and then does strict equality therefore 2 is not equal to 1.

2 is not equal to false also, why , because false is converted to 0 then 2 cannot be equal to 0.

1 is equal to true because true is converted to 1 thus it is true. Similarly false is equal to 0.

'' == false   // 0 === 0

'abc' == true  // NaN === 1

Empty string is false because conversion of empty string to number is 0

Number('')  // 0

0 is equal to 0 because false is also converted to 0.

'abc' is converted to NaN by Number thus Nan is not equal to 1.

'\n\t123\r ' == 123  

'' == 0  // 0 === 0

In first line comes the confusion \n\t123\r is also converted to 123. Thus  it becomes true.

In second line its understandable with previous examples.

{} == '[object Object]'

['123'] == 123

[] == 0

In first case lenient equality tries to convert it to string i.e. String({}) which gives '[object Object]'. Thus it is true.

In Second case, again it convert to string String(['123']) = 123. Thus it also becomes equal.

In third case, agains come the problem this time it uses Number conversion Number([]) = 0 thus it also satisfies.

Confusing? Lets see how these works.

The algorithm for comparing via normal equality works as follows. If both operands have the same type (one of the six specification types—Undefined, Null, Boolean, Number, String, and Object), then compare them via strict equality.

Otherwise, if the operands are:

  1. undefined and null, then they are considered leniently equal:

    undefined == null
  2. A string and a number, then convert the string to a number and compare both operands via strict equality.
  3. A boolean and a nonboolean, then convert the boolean to a number and compare leniently (again).
  4. An object and a number or a string, then try to convert the object to a primitive (via the algorithm described in Algorithm: ToPrimitive()—Converting a Value to a Primitive) and compare leniently (again).

Otherwise—if none of the aforementioned cases apply—the result of the lenient comparison is false.

This is taken from

Now try finding the reasons for below and comment for others.



Try everything in console and explore.

Also read about Javascript unknown fact and magic here



Liked the post, subscribe to stay updated of more such posts


Gaurav Yadav

Gaurav is cloud infrastructure engineer and a full stack web developer and blogger. Sportsperson by heart and loves football. Scale is something he loves to work for and always keen to learn new tech. Experienced with CI/CD, distributed cloud infrastructure, build systems and lot of SRE Stuff.

  • Mohammad Afzal

    awesome work sir . keep sharing your experience

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.