CODEWITHSUNDEEP
javascriptparseint
cebor
cebor

Reputation: 6546

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?

Upvotes: 864

Views: 59334

Answers (4)

Jon
Jon

Reputation: 437376

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.

Upvotes: 1308

Craig Citro
Craig Citro

Reputation: 6625

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.

Upvotes: 230

Imdad
Imdad

Reputation: 6032

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

Upvotes: 14

kybernetikos
kybernetikos

Reputation: 8689

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"

Upvotes: 39

Related Questions