Question

150

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

rated 0 times [ 156] [ 6] / answers: 1 / hits: 18233 / 13 Years ago, sun, october 2, 2011, 12:00:00

The code:

var num = 20;



if(num == 20)

{

    alert(It works);

}

else

{

    alert(Not working);

}

The question:

In C programming we have a rule name data type promotion, where when there's a mix of data type (example: addition of integer and floating point), the integer will first converted to floating point before the addition is being carry out.

The code above will prompt me an alert box with the message It works that shows the if test condition is evaluate to true.

For loosely typed JavaScript, I'm just curious: is there any rule like C that determines which conversion will be carry out in which situation? Besides that, the JavaScript code above converts num variable value from an integer value to string value before making comparison or vice versa?

Answers

Only authorized users can answer the question. Please sign in first, or register a free account.

patienceannel

Add To Favorites

Follow

Total Points: 674

Total Questions: 101

Total Answers: 101

Location: Northern Mariana Islands

Member since Fri, Jan 15, 2021

3 Years ago

patienceannel questions

1 React Functional Component: how to use componentDidMount()

Fri, Mar 11, 22, 00:00, 2 Years ago

1 Map of Maps in Typescript / ECMAScript

Tue, Oct 20, 20, 00:00, 4 Years ago

1 Using moment.js to determine if current time (in hour) is between certain hours

Fri, May 29, 20, 00:00, 4 Years ago

1 How to display success message after copying url to clipboard?

Wed, Apr 8, 20, 00:00, 4 Years ago

1 Refactor aliased @ imports to relative paths

Wed, Jul 24, 19, 00:00, 5 Years ago

View All

answered 13 Years ago anyssaarielles · Accepted Answer

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:

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

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

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