WEB DEVELOPER SITE
HTMLCSSJAVASCRIPTSQLPHPBOOTSTRAPJQUERYANGULARXML
 

JavaScript Type Conversion


Number() changes over to a Number, String() changes over to a String, Boolean() changes over to a Boolean.


JavaScript Data Types

In JavaScript there are 5 unique information types that can contain values:

  • string
  • number
  • boolean
  • object
  • function

There are 3 kinds of objects:

  • Object
  • Date
  • Array

And 2 information sorts that can't contain values:

  • null
  • undefined

The typeof Operator

You can utilize the typeof administrator to discover the information kind of a JavaScript variable.

Example

typeof "John"                 /Returns string
typeof 3.14                   /Returns number
typeof NaN                    /Returns number
typeof false                  /Returns boolean
typeof [1,2,3,4]              //Returns object
typeof {name:'John', age:34}  /Returns object
typeof new Date()             /Returns object
typeof work () {}        /Returns function
typeof myCar                  /Returns indistinct (if myCar isn't declared)
typeof null                   /Returns object
Try it Yourself »

Please observe:

  • The information kind of NaN is number
  • The information kind of a cluster is object
  • The information kind of a date is object
  • The information kind of invalid is object
  • The information kind of an unclear variable is undefined

The Data Type of typeof

The typeof administrator is anything but a variable. It is an administrator. Administrators ( + - */ ) don't have any information type.

But, the typeof administrator dependably returns a string containing the sort of the operand.


The constructor Property

The constructor property restores the constructor work for all JavaScript variables.

Example

"John".constructor                 /Returns work String()  { [native code] }
(3.14).constructor                 /Returns work Number()  { [native code] }
false.constructor                  /Returns work Boolean() { [native code] }
[1,2,3,4].constructor              /Returns work Array()   { [native code] }
{name:'John', age:34}.constructor  /Returns work Object()  { [native code] }
new Date().constructor             /Returns work Date()    { [native code] }
work () {}.constructor         /Returns work Function(){ [native code] }
Try it Yourself »

You can look at the constructor property to discover if an article is an Array (contains the word "Array"):

Example

work isArray(myArray) {
    return myArray.constructor.toString().indexOf("Array") > - 1;
}
Try it Yourself »

You can look at the constructor property to discover if an item is a Date (contains the word "Date"):

Example

work isDate(myDate) {
    return myDate.constructor.toString().indexOf("Date") > - 1;
}
Try it Yourself »

JavaScript Type Conversion

JavaScript factors can be changed over to another variable and another information type:

  • By the utilization of a JavaScript function
  • Automatically by JavaScript itself

Converting Numbers to Strings

The worldwide technique String() can change over numbers to strings.

It can be utilized on a numbers, literals, factors, or expressions:

Example

String(x)         //restores a string from a number variable x
String(123)      /restores a string from a number strict 123
String(100 + 23) /restores a string from a number from an expression
Try it Yourself »

The Number strategy toString() does the same.

Example

x.toString()
(123).toString()
(100 + 23).toString()
Try it Yourself »

In the section Number Methods, you will discover more strategies that can be utilized to change over numbers to strings:

Method Description
toExponential() Returns a string, with a number adjusted and composed utilizing exponential notation.
toFixed() Returns a string, with a number adjusted and composed with a predetermined number of decimals.
toPrecision() Returns a string, with a number composed with a predetermined length

Converting Booleans to Strings

The global method String() can convert booleans to strings.

String(false)        // returns "false"
String(true)         // returns "true"

The Boolean method toString() does the same.

false.toString()     // returns "false"
true.toString()      // returns "true"

Converting Dates to Strings

The global method String() can convert dates to strings.

String(Date())      // returns Thu Jul 17 2014 15:38:19 GMT+0200 (W. Europe Daylight Time)

The Date method toString() does the same.

Example

Date().toString()   // returns Thu Jul 17 2014 15:38:19 GMT+0200 (W. Europe Daylight Time)

In the chapter Date Methods, you will find more methods that can be used to convert dates to strings:

Method Description
getDate() Get the day as a number (1-31)
getDay() Get the weekday a number (0-6)
getFullYear() Get the four digit year (yyyy)
getHours() Get the hour (0-23)
getMilliseconds() Get the milliseconds (0-999)
getMinutes() Get the minutes (0-59)
getMonth() Get the month (0-11)
getSeconds() Get the seconds (0-59)
getTime() Get the time (milliseconds since January 1, 1970)

Converting Strings to Numbers

The worldwide strategy Number() can change over strings to numbers.

Strings containing numbers (like "3.14") convert to numbers (like 3.14).

Empty strings convert to 0.

Anything else changes over to NaN (Not a number).

Number("3.14")   /returns 3.14
Number(" ")      /returns 0
Number("")        //returns 0
Number("99 88")  /returns NaN

In the part Number Methods, you will discover more techniques that can be utilized to change over strings to numbers:

Method Description
parseFloat() Parses a string and returns a gliding point number
parseInt() Parses a string and returns an integer

The Unary + Operator

The unary + operator can be utilized to convert a variable to a number:

Example

var y = "5";      /y is a string
var x = + y;      /x is a number
Try it Yourself »

In the event that the variable can't be changed over, it will even now turn into a number, yet with the esteem NaN (Not a number):

Example

var y = "John";   /y is a string
var x = + y;      //x is a number (NaN)
Try it Yourself »

Converting Booleans to Numbers

The worldwide strategy Number() can likewise change over booleans to numbers.

Number(false)    /returns 0
Number(true)     /returns 1

Converting Dates to Numbers

The worldwide technique Number() can be utilized to change over dates to numbers.

d = new Date();
Number(d)         /returns 1404568027739

The date strategy getTime() does the same.

d = new Date();
d.getTime()       /returns 1404568027739

Automatic Type Conversion

When JavaScript endeavors to work on a "wrong" information type, it will attempt to convert the incentive to a "right" type.

The result isn't generally what you expect:

5 + null   /returns 5         since invalid is changed over to 0
"5" + null /returns "5null"   since invalid is changed over to "null"
"5" + 2    /returns 52        since 2 is changed over to "2"
"5" - 2    /returns 3         since "5" is changed over to 5
"5" * "2"  /returns 10        on the grounds that "5" and "2" are changed over to 5 and 2
Try it Yourself »

Automatic String Conversion

JavaScript naturally calls the variable's toString() work when you attempt to "output" an item or a variable:

document.getElementById("demo").innerHTML = myVar;

/if myVar = {name:"Fjohn"} /toString changes over to "[object Object]"
/if myVar = [1,2,3,4]      /toString changes over to "1,2,3,4"
/if myVar = new Date()     /toString changes over to "Fri Jul 18 2014 09:08:55 GMT+0200"

Numbers and booleans are likewise changed over, yet this isn't very visible:

/if myVar = 123            /toString changes over to "123"
/if myVar = genuine           /toString changes over to "true"
/if myVar = false          /toString changes over to "false"

JavaScript Type Conversion Table

This table demonstrates the aftereffect of changing over various JavaScript qualities to Number, String, and Boolean:

Original
Value
Converted
to Number
Converted
to String
Converted
to Boolean
Try it
false 0 "false" false
true 1 "true" true
0 0 "0" false
1 1 "1" true
"0" 0 "0" true
"1" 1 "1" true
NaN NaN "NaN" false
Infinity Infinity "Infinity" true
-Infinity -Infinity "- Infinity" true
"" 0 "" false
"20" 20 "20" true
"twenty" NaN "twenty" true
[ ] 0 "" true
[20] 20 "20" true
[10,20] NaN "10,20" true
["twenty"] NaN "twenty" true
["ten","twenty"] NaN "ten,twenty" true
function(){} NaN "function(){}" true
{ } NaN "[object Object]" true
null 0 "null" false
undefined NaN "undefined" false

Values in statements demonstrate string values.

Red values demonstrate values (a few) software engineers may not expect.