Dive Into JavaScript

The JavaScript parseInt Function

The JavaScript parseInt global function returns the integer value of a variable. It parses the string representation of that variable and returns an integer using the specified base.

Syntax

var int_val = parseInt(value [, base]);

Parameters

value

Represents the value to be parsed

base

An integer representing the base or radix of the string to be parsed

Examples:

parseInt("11"); // returns 11
parseInt("11", 2); // returns 3
parseInt("11", 8); // returns 9
parseInt("11", 16); // returns 17

If the variable cannot be converted to a string, the parseInt() function returns NaN. However it is possible to convert compound types such as arrays and objects to numbers, provided that their toString methods return numeric strings:

function Foo(arg) {
	this.x = arg;
}
Foo.prototype.toString = function() {
	return this.x;
}
var f = new Foo(42);
parseInt(f); // returns 42

The base argument must be an integer between 2 and 36, otherwise parseInt() returns NaN. If base is undefined, null or 0, JavaScript assumes the following:

• If the subject string begins with 0x, the base is 16 (hexadecimal)
• If the subject string begins with 0, the base is 8 (octal)
• If the subject string begins with any other value, the base is 10 (decimal)

Description

The parseInt function walks through the characters of the string until it finds a character that is not a numeral in the specified base. The value parsed up to that point is then converted to an integer. Consequently, the result of the parseInt() function depends on the leftmost characters of the string.

If the first character of the string cannot be converted to a number, parseInt returns NaN.

The base defines which characters are used to represent numbers. As pointed out earlier, the base determines when the parseInt() function should stop parsing.

For example, the decimal system uses the digits from 0 through 9. On the other hand, the hexatridecimal system (base 36) uses the digits from 0 through 9 plus the letters A through Z. As a result, a radix of 10 will cause the parseInt() function to stop when it encounters a letter. On the contrary, when using base 36, parseInt will not stop until it encounters a non alphanumeric value.

The following examples illustrate this:

parseInt("12a"); // base 10 (implied), returns 12
parseInt("12a", 10); // base 10, returns 12
parseInt("12a", 36); // base 36, returns 1378
parseInt("12a?", 36); // base 36, returns 1378

The isNaN() function can be used to determine if the result of the parseInt() function is NaN.

Base Conversion

Using the parseInt() function together with the Number.toString() method we can create a small function to convert a number from one base to another:

function base_convert(number, from_base, to_base) {
    return parseInt(number, from_base || 10).toString(to_base || 10);
}

Both from_base and to_base have to be integers between 2 and 36.

Base conversion examples:

base_convert(222, 8, 36); // 42
base_convert(10101, 2, 10); // 21
base_convert(0xfc); // 252

See also

• The parseFloat() function
• The NaN property
• The isNaN() function
• The Number object