Type
conversion

JavaScript

is very flexible about the types of values it requires

when

JavaScript

expects a certain value
no matter the value supplied
it will try to convert it as needed

type conversions summary

Primitive to primitive

conversions

1 + ' string'         //=> "1 string"    -> Number becomes a string
"1" / "2"             //=> 0.5           -> both strings become numbers
1 / "two"             //=> NaN           -> string can't be converted to number
NaN + ' string'       //=> "NaN string"  -> NaN becomes a string
true + 1 + null       //=> 2             -> true becomes 1, null becomes 0 (1 + 1 + 0 = 2)
1 / false             //=> Infinity      -> false becomes 0 (1 / 0 = Infinity)
['Java'] + 'Script'   //=> "JavaScript"  -> array values become a string

PRIMITIVE TO OBJECT

CONVERSIONs

primitives convert to their wrapper object

as if by calling the 

String() / Number() / Boolean()

constructor functions

BUT

null & undefined are an exception
they raise a TypeError if used where an object is expected

OBJECT TO PRIMITIVE

CONVERSIONs

var obj = new Boolean(false);

if (obj) {
  console.log(true);   //=> true -> new Boolean(false) is an object & converts to true
} else {
  console.log(false);
}

BUT

toString() method

var obj = {
  title: 'JavaScript - The Basics'
};

obj.toString();   //=> "[object Object]"

[1, 2, 3, 4].toString();       //=> "1,2,3,4"

var fn = function (param) { 
  return param; 
};
fn.toString();                 //=> "function (param) { return param; }"

var time = new Date(); 
time.toString();          //=> "Tue Aug 12 2014 21:07:31 GMT+0300 (GTB Daylight Time)"

valueOf() method

a less well-defined conversion function

because objects are compound values
cannot really be represented by a single primitive value
by default the valueOf() method simply returns the object itself

var obj = {
  title: 'JavaScript - The Basics'
};

obj.valueOf();            //=> Object {title: "JavaScript - The Basics"}
[1, 2, 3, 4].valueOf();   //=> [1, 2, 3, 4]

(new Date()).valueOf();   //=> 1407867809210 -> milliseconds since January 1, 1970

Conversions & equality

because JavaScript can convert values flexibly
its == equality operator is also flexible with its notion of equality
all of the following comparisons are true

null == undefined   //=> true
"0"  == 0           //=> true -> string becomes a number (0 == 0)
 0   == false       //=> true -> boolean becomes a number (0 == 0)
"0"  == false       //=> true -> both 0 & false become numbers (0 == 0)

undefined == false  //=> false -> == operator never attempts to
                    //            convert its operands to booleans    

Explicit conversions

although many type conversions are performed automatically
sometimes explicit conversions are needed

the simplest way to do it is by invoking the functions
Number() / String() / Boolean() and Object()
without the new operator

Number("1");   // => 1
String(true);  // => "true"
Boolean({});   // => true
Object(1);     // => Number {} -> new Number(1)
Object();      // => Object {} -> an empty object

some operators perform implicit type conversions

&

are sometimes used for this purposes

1 + ""    //=> "1"   -> + converts the second operator to string if one operator is a string
+"1"      //=> 1     -> unary + operator converts its operand to number
!!""      //=> false -> unary ! operator converts its operand to a boolean and negates it

JavaScript 

toString() 

defined by the Number class
converts a number to a string
accepts optional argument as radix for the conversion

var n = 15;

n.toString(2);    //=> "1111"
n.toString(8);    //=> "17"
n.toString(16);   //=> "f"

var n = 12345.6789;

n.toFixed(0);    //=> "12345"
n.toFixed(2);    //=> "12345.68"
n.toFixed(7);    //=> "12345.6789000" 

toExponential()

converts a number to a string using exponential notation
with one digit before the decimal point & a specified number of digits
after the decimal point

var n = 12345.6789;

n.toExponential(0);   //=> "1e+4"
n.toExponential(2);   //=> "1.23e+4"
n.toExponential(7);   //=> "1.2345679e+4"

toPrecision()

var n = 12345.6789;

n.toPrecision(1);     //=> "1e+4"
n.toPrecision(7);     //=> "12345.68"
n.toPrecision(21);    //=> "12345.6789000000007945"

parseFloat()

parses integers and floating-point numbers

 parseFloat("1px");    //=> 1
 parseFloat(".1");     //=> 0.1
 parseFloat("$1.0");   //=> NaN

parseInt()

parseInt("1px");   // => 1
parseInt("1.0");   // => 1
parseInt("0.1");   // => 0
parseInt(".1");    // => NaN -> integers can't start with "."
parseInt("0xf");   // => 15
parseInt("0XF");   // => 15

parseInt("1111", 2);  // => 15
parseInt("f", 16);    // => 15
parseInt("017", 8);   // => 15

both parseInt() & parseFloat() functions 

skip leading whitespace