Implicit data type conversion in JavaScript when comparing integer with string using ==

Yes, all the rules of type conversion applied by the equals operator are described on the ECMA-262 specification, in The Abstract Equality Comparison Algorithm.

The algorithm might look quite complex but it can be summarized to the following cases:

1. The type the two operands is the same:

   • For primitives (String, Number, Boolean, Null, Undefined)
     • Return true if the value is exactly the same
   • For the Object type
     • Return true if the two references point to the same object

2. If the types of the two operands differ

   • If the type of one operand is either Null or Undefined
     • Return true only if the other operand value is either null or undefined
   • If one of the operands is of type Boolean or Number
     • (after some steps) Convert the other operand to Number and compare

3. If one of the operands is an Object and the other is a primitive

   • Perform Object-to-Primitive conversion on the Object and compare again

The Object-to-Primitive conversion is made through an abstract operation called ToPrimitive, this method will try to convert the object to a primitive value, using the internal [[PrimitiveValue]] method.

This will try to ejecute the object's valueOf and toString methods, and it will take the value of the first that returns a primitive value.

In the case those two methods don't return a primitive, or they aren't callable, a TypeError is thrown, e.g.:

1 == { toString:null } // TypeError!

The above statement will produce a TypeError because the default Object.prototype.valueOf method doesn't do anything more than actually the same object instance (this, not a primitive value) and we are setting an own toString property that's not a function.

A friend made small tool that might be interesting to you, it shows all the steps and recursive comparisons made between types:

• JS Coercion Tool

In JavaScript, there are two operators that can be used to compare two values: the == and === operators.

Quoted from JavaScript The Definitive Guide 6th Edition:

The equality operator == is like the strict equality operator (===), but it is less strict. If the values of the two operands are not the same type, it attempts some type conversions and tries the comparison again.

And

The strict equality operator === evaluates its operands, and then compares the two values as follows, performing no type conversion.

So I suggest that you use === all the time to avoid problems like:

null == undefined // These two values are treated as equal. 
"0" == 0 // String converts to a number before comparing. 
0 == false // Boolean converts to number before comparing. 
"0" == false // Both operands convert to numbers before comparing.

P.S. I could post the entire "comparison guidelines" as written in the book but it's too long ;) Just tell me and I'll edit my post for you.

Avoid implicit type conversion in JavaScript. Always take steps to test and/or convert individual values before comparing them to ensure you are comparing apples to apples. Always test explicitly for undefined to determine if a value or property has a value, use null to indicate that object variables or properties do not refer to any object, and convert & compare all other values to ensure operations are performed against values of the same type.