Why does "parseint(0.0000005)" return "5" in Javascript?

Question

Again, Javascript shows me a show of horrors magic and this time I want to know why this unexpected behavior while using the parseInt.

Why parseInt(0.0000005) returns 5 and not 0? How I get around this problem?

I would like a detailed explanation of this behaviour magical Javascript strange (at least for me).

console.log(parseInt(0.5))       // ok
console.log(parseInt(0.0005))    // ok
console.log(parseInt(0.000005))  // ok
console.log(parseInt(0.0000005)) // mágica

What’s interesting is that if it’s a string '0.0000005', the parseInt works as expected.

console.log(parseInt('0.0000005')) // ok
console.log(parseInt(0.0000005))   // mágica

Answer 1

According to the documentation, parseInt first converts the argument to string, and then evaluates this string.

This is also described in language specification, is the first thing that parseInt ago:

1. Let inputString be Tostring(string).

^{Whereas string is the first argument received by parseInt}

And what happens is that very small values, when converted to string, end up resulting in their representation in scientific notation:

let x = 0.05;
console.log(x.toString()); // 0.05
x = 0.0000005;
console.log(x.toString()); // 5e-7

And the string 5e-7 is interpreted as the number 5, because the algorithm of parseInt reads the digits, and when it finds a character that is not a valid digit, it stops and converts the digits read so far (and in this case, it is just the 5).

---

It is also worth remembering this rule:

• If the input string Begins with "0x" or "0X" (a zero, Followed by lowercase or uppercase X), Radix is assumed to be 16 and the Rest of the string is Parsed as a hexadecimal number.
• If the input string Begins with any other value, the Radix is 10 (decimal).

That is, if the string starts with 0x or 0X, it is assumed that the basis is 16 (if it has not been informed). In any other case, it is assumed that the basis is 10, and as the letter e is not a valid digit in base 10, Parsing only reads the digit 5.

---

In the case of string '0.0000005', this problem does not occur because this string, when converted to string, is not changed to scientific notation, remaining unchanged, and the Parsing is done by reading the zero and stopping at the point, resulting in zero.

Finally, as stated in the comments, the idea of parseInt - and also of parseFloat - is to do the Parsing of a string, resulting in the numerical value it represents. But if you are going to work directly with numbers, and not with strings, it is better to use mathematical functions for such.

If the idea was to take the whole part of the number, for example, the best thing would be to Math.floor(0.0000005) (or else Math.trunc, or Math.round, or some other function or calculation, depending on how you want to make the rounding). Use parseInt may even work in many cases, but as we have seen, it also hides some traps.

---

Finally, this problem also happens with very large numbers, which are also converted to a string in scientific notation:

let x = 10000000000000000000000;
console.log(x.toString()); // 1e+22
console.log(parseInt(x)); // 1