JavaScript provides two methods for converting non-number primitives into numbers: parseInt() and parseFloat() . As you may have guessed, the former converts a value into an integer whereas the latter converts a value into a floating-point number.

Any number literal contained in a string is also converted correctly, so the string "0xA" is properly converted into the number 10. However, the string "22.5" will be converted to 22 , because the decimal point is an invalid character for an integer. Some examples:

var iNum1 = parseInt("1234blue"); //returns 1234

var iNum2 = parseInt("0xA"); //returns 10

var iNum3 = parseInt("22.5"); //returns 22

var iNum4 = parseInt("blue"); //returns NaN

The parseInt() method also has a radix mode, allowing you to convert strings in binary, octal, hexadecimal, or any other base into an integer. The radix is specified as a second argument to parseInt() , so a call to parse a hexadecimal value looks like this:

var iNum1 = parseInt("AF", 16); //returns 175

Of course, this can also be done for binary, octal, and even decimal (which is the default mode):

var iNum1 = parseInt("10", 2); //returns 2

var iNum2 = parseInt("10", 8); //returns 8

var iNum2 = parseInt("10", 10); //returns 10

If decimal numbers contain a leading zero, it’s always best to specify the radix as 10 so that you won’t accidentally end up with an octal value. For example:

var iNum1 = parseInt("010"); //returns 8

var iNum2 = parseInt("010", 8); //returns 8

var iNum3 = parseInt("010", 10); //returns 10

In this code, both lines are parsing the string "010" into a number. The first line thinks that the string is an octal value and parses it the same way as the second line (which specifies the radix as 8). The last line specifies a radix of 10, so iNum3 ends up equal to 10.

Another difference when using parseFloat() is that the string must represent a floating-point number in decimal form, not octal or hexadecimal. This method ignores leading zeros, so the octal number 0908 will be parsed into 908 , and the hexadecimal number 0xA will return NaN because x isn’t a valid character for a floating-point number. There is also no radix mode for parseFloat() .

Some examples of using parseFloat() :

var fNum1 = parseFloat("1234blue"); //returns 1234

var fNum2 = parseFloat("0xA"); //returns 0

var fNum3 = parseFloat("22.5"); //returns 22.5

var fNum4 = parseFloat("22.34.5"); //returns 22.34

var fNum5 = parseFloat("0908"); //returns 908

var fNum6 = parseFloat("blue"); //returns NaN

Read More, Read More

Similar Question Read more here

• Number.parseInt method (or just parseInt)

  • Ignores leading and trailing whitespace
  • Parses a leading number to an integer (not a floating point number)
  • Ignores invalid trailing data
  • Lets you set the base to use when interpreting the number
  • Will interpret text starting with 0x as hexadecimal, if another base was not provided
  • Returns NaN if the value could not be successfully parsed to an integer

• Number.parseFloat method (or just parseFloat)

  • Similar to parseInt, except that it allows for a decimal part to be interpreted
  • Only parses to base-10

• Number() function (or class?)

  • Similar to parseFloat, but does not allow trailing text
  • Will return 0 for an empty string or a string that only contains whitespace
  • It's not a class; when called without new, it returns a primitive number

• the + operator

  • Basically the same as Number(), but in operator form.

• eval()

  • Interprets and executes the given input as a JavaScript program.
  • Given the string "2", it will be interpreted as a numeric literal, and return that value since it's the result of the last expression in the program
  • Throws an error if the input was not a valid program.

• JSON.parse()

  • Parses the textual data as JSON-serialized data.
  • If the data is valid, it creates the JavaScript objects/primitives that are represented by the data, and returns them.
  • If the data is invalid, it throws an error.
  • Given the string "2", it will be interpreted as a numeric literal, and return the value that was successfully parsed out of it according to the parsing requirements of JSON.

So you decide which is appropriate to use based on their capabilities.

parseInt() assumes the base of your number according to the first characters in the string. If it begins with 0x it assumes base 16 (hexadecimal). Otherwise, if it begins with 0 it assumes base 8 (octal). Otherwise it assumes base 10.

You can specify the base as a second argument:

alert(parseInt(hfrom[0], 10)); // 8

From MDN (linked above):

If radix is undefined or 0, JavaScript assumes the following:

If the input string begins with "0x" or "0X", radix is 16 (hexadecimal). If the input string begins with "0", radix is eight (octal). This feature is non-standard, and some implementations deliberately do not support it (instead using the radix 10). For this reason always specify a radix when using parseInt. If the input string begins with any other value, the radix is 10 (decimal).