## Why does parseInt(1/0, 19) return 18?

I have an annoying problem in JavaScript.

> parseInt(1 / 0, 19)

> 18

Why does the parseInt function return 18?

## Solutions/Answers:

### Solution 1:

The result of `1/0`

is `Infinity`

.

`parseInt`

treats its first argument as a string which means first of all `Infinity.toString()`

is called, producing the string `"Infinity"`

. So it works the same as if you asked it to convert `"Infinity"`

in base 19 to decimal.

Here are the digits in base 19 along with their decimal values:

```
Base 19 Base 10 (decimal)
---------------------------
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
a 10
b 11
c 12
d 13
e 14
f 15
g 16
h 17
i 18
```

What happens next is that `parseInt`

scans the input `"Infinity"`

to find which part of it can be parsed and stops after accepting the first `I`

(because `n`

is not a valid digit in base 19).

Therefore it behaves as if you called `parseInt("I", 19)`

, which converts to decimal 18 by the table above.

### Solution 2:

Here’s the sequence of events:

`1/0`

evaluates to`Infinity`

`parseInt`

reads`Infinity`

and happily notes that`I`

is 18 in base 19`parseInt`

ignores the remainder of the string, since it can’t be converted.

Note that you’d get a result for any base `>= 19`

, but not for bases below that. For bases `>= 24`

, you’ll get a larger result, as `n`

becomes a valid digit at that point.

### Solution 3:

To add to the above answers:

parseInt is intended to parse strings into numbers (the clue is in the name). In your situation, you don’t want to do any parsing at all since 1/0 is *already* a number, so it’s a strange choice of function. If you have a number (which you do) and want to convert it to a particular base, you should use toString with a radix instead.

```
var num = 1 / 0;
var numInBase19 = num.toString(19); // returns the string "Infinity"
```

### Solution 4:

To add to the above answers

`parseInt(1/0,19)`

is equivalent to `parseInt("Infinity",19)`

Within base 19 numbers `0-9`

and `A-I`

`(or a-i)`

are a valid numbers. So, from the “Infinity” it takes `I`

of base 19 and converts to base 10 which becomes 18

Then it tries to take the next character i.e. `n`

which is not present in base 19 so discards next characters (as per javascript’s behavior of converting string to number)

So, if you write `parseInt("Infinity",19)`

OR `parseInt("I",19)`

OR `parseInt("i",19)`

the result will be same i.e `18`

.

Now, if you write `parseInt("I0",19)`

the result will be `342`

as `I X 19 (the base)^1 + 0 X 19^0`

= `18 X 19^1 + 0 X 19^0`

= `18 X 19 + 0 X 1`

= `342`

Similarly, `parseInt("I11",19)`

will result in `6518`

i.e.

```
18 X 19^2 + 1 X 19^1 + 1 X 19^0
= 18 X 19^2 + 1 X 19^1 + 1 X 19^0
= 18 X 361 + 1 X 19 + 1 X 1
= 6498 + 19 + 1
= 6518
```