var x = "3.14";
x = 3.14;

var x = "10" - 2;

var x = "false";  // a string
if (x) 
  {
   alert("x evaluated to the Boolean value true");
  }

var x = 21.84e22;    // a number
document.write(x);   // x is automatically converted to a string here

Conversion Rules for Primitive Types

The type conversion rules for primitive types are given in Tables 3-5, 3-6, and 3-7. You can use these tables to answer questions like what happens in this example:

Table 3-5: Result of Conversion to a Boolean

Type	Converted to Boolean
Undefined	false
Null	false
Number	false if 0 or NaN, else true
String	false if string length is 0, else true
Other object	true

Table 3-6: Result of Converting to a Number

Type	Converted to Number
Undefined	NaN
Null	0
Boolean	1 if true, 0 if false
String	The numeric value of the string if it looks like a number, else NaN
Other object	NaN

Table 3-7: Result of Converting to a String

Type	Converted to a String
Undefined	"Undefined"
Null	"Null"
Boolean	"True" if true, "false" if false
Number	"NaN", "0", or the string representation of the numeric value
Other object	Value of object's toString() method if it exists, else "undefined"

var x = "false";  // a string
if (x) 
  {
    alert("x evaluated to the Boolean value true");
  }

Since every string but the empty string ("") converts to the Boolean value of true, the conditional is executed and the user is shown the alert.

These type conversion rules mean that comparisons such as

1 == true

0 == ""

are true. But sometimes you don’t want type conversion to be applied when checking equality, so JavaScript provides the strict equality operator (===). This operator evaluates to true only if its two operands are equal and they have the same type. So, for example, the following comparisons would be false:

1 === true

0 === ""

0 === "0"

How the JavaScript interpreter determines the type required for most operators is fairly natural and isn’t required knowledge for most developers. For example, when performing arithmetic, types are converted into numbers, then computations are performed.

One important exception is the + operator. The + operator performs addition on numbers but also serves as the concatenation operator for strings. Because string concatenation has precedence over numeric addition, + will be interpreted as string concatenation if any of the operands are strings. For example, both statements,

x = "2" + "3";
x = "2" + 3;

result in the assignment of the string "23" to x. The numeric 3 in the second statement is automatically converted to a string before concatenation is applied.

Promotion of Primitive Data to Objects

It was previously mentioned that there is an object corresponding to each primitive type. These objects provide useful methods for manipulating primitive data. For example, the String object provides a method to convert a string to lowercase: toLowerCase(). You can invoke this method on a String object:

var myStringObject = new String("ABC");
var lowercased = myStringObject.toLowerCase();

The interesting aspect of JavaScript is that you can also invoke it on primitive string data:

var myString = "ABC";
var lowercased = myString.toLowerCase();

as well as on literals:

var lowercased = "ABC".toLowerCase();

The key insight is that JavaScript automatically converts the primitive data into its corresponding object when necessary. In the preceding examples, the interpreter knew that the toLowerCase method requires a String object, so it automatically and temporarily converted the primitive string into the object in order to invoke the method.

Explicit Type Conversion

The reality of most programming tasks is that it is probably better to perform type conversion manually than trust the interpreter to do it for you. One situation when this is definitely the case is when processing user input. User input acquired through use of dialog boxes and (X)HTML forms usually comes in strings. It is often necessary to explicitly convert such data between string and number types to prevent operators like + from carrying out the wrong operation (for example, concatenation instead of addition, or vice versa). JavaScript provides several tools for carrying out explicit type conversion, for example, objects’ toString() method and the parseInt() and parseFloat() methods of the Global object. These methods are discussed in depth in later chapters (particularly Chapter 7) as their applications become more apparent.