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

861
votes

I have an annoying problem in JavaScript.

> parseInt(1 / 0, 19)
> 18

Why does the parseInt function return 18?

4
javascriptparseint
Interesting. But why is this an annoying problem for you? Do you have to handle Infinity in other ways? If so, an if might help. – Thilo
What the hell were you even doing that required you to work with either base-19 numbers OR division by zero!? – Jack M
When you get confused about JS, just go back to this quote and remember that the whole damn language was designed and implemented in less than 10 days (according to the person who did it). – tylerl
From the FAQ: "You should only ask practical, answerable questions based on actual problems that you face." This isn't actually an "annoying problem" that you actually face, it's a unrealistic example that's been floating around the internet forever. – Jeremy
python does the same thing: int('I', 19) == 18 – oberhamsi

4 Answers

1302
votes

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.

228
votes

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.

38
votes

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"
13
votes

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