Weird behavior of parsing parseInt() in JavaScript

This article will introduce to you the weird behavior of parsing parseInt() in JavaScript. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to everyone.

[Recommended learning: javascript advanced tutorial]

parseInt() is a built-in JS function. Used to parse integers in numeric strings. For example, parsing the numeric string '100':

const number = parseInt('100');
number; // 100

As expected, '100' is parsed as the integer 100.

parseInt(numericalString, radix) Also accepts a second parameter: from 2 to 36, indicating the radix of the string. For example, specifying 16 means that the parsed value is a hexadecimal number. Please note that 10 is not the default value, the most common ones are 2, 8, 10 and 16.

For example, we use parseInt to parse a numeric string in binary mode: The corresponding binary number of

const number = parseInt('100', 2);
number; // 4

100 is 4, so 4 is returned.

1. Weird behavior of parseInt()

parseInt(numericalString)Always converts its first argument to a string if it is not string) and then parses that numeric string into an integer value.

This is why you can ( but shouldn't) use parseInt() to extract the integer part of a floating point number:

parseInt(0.5);      // => 0
parseInt(0.05);     // => 0
parseInt(0.005);    // => 0
parseInt(0.0005);   // => 0
parseInt(0.00005);  // => 0
parseInt(0.000005); // => 0

Extract the float The integer part of the point, such as 0.5, 0.05, etc., results in 0, which is as expected.

How about extracting the integer part of 0.0000005?

parseInt(0.0000005); // => 5

parseInt() Parses the floating point number 0.0000005 into 5. Why does parseInt(0.0000005) have such a weird behavior?

2. Solving parseInt()weird behavior

Let’s take another look at parseInt(numericalString)’s first arguments: if it is not a string, convert it to a string, parse it, and return the parsed integer.

This may be the first clue.

We then try to manually convert the float to a string representation:

String(0.5);      // => '0.5'
String(0.05);     // => '0.05'
String(0.005);    // => '0.005'
String(0.0005);   // => '0.0005' 
String(0.00005);  // => '0.00005'
String(0.000005); // => '0.000005'

String(0.0000005); // => '5e-7'

Explicit conversion to string(0.0000005)Strings behave like other floats Difference: It is expressed in exponential form.

This is the second important clue!

When the exponent notation is parsed into an integer, we get the number 5

parseInt(0.0000005); // => 5
// same as
parseInt(5e-7);      // => 5
// same as
parseInt('5e-7');    // => 5

parseInt('5e-7')Consider the first number' 5', but skip 'e-7'.

The mystery has been solved! Because parseInt() always converts its first argument to a string, floating-point numbers less than 10 minus 6 will be expressed as an exponent. Then parseInt() extracts the integer from the exponential representation of float.

In addition, in order to safely extract the integer part of the floating point number, it is recommended to use the Math.floor() function:

Math.floor(0.5);      // => 0
Math.floor(0.05);     // => 0
Math.floor(0.005);    // => 0
Math.floor(0.0005);   // => 0
Math.floor(0.00005);  // => 0
Math.floor(0.000005); // => 0

Math.floor(0.0000005); // => 0

3. Summary

parseInt() is a function that parses a numeric string into an integer.

Care must be taken when trying to use parseInt() to extract the integer part of a floating point number.

Floating point numbers less than 10 raised to the power of -6 (for example, 0.0000005, which is 5*10-7) are written in exponential notation when converted into strings (for example, 5e-7 is the exponential notation of 0.0000005) . This is why using such small floating point numbers in parseInt() can lead to unexpected results: only the significant part of the exponent notation (e.g. in 5e-7 5) will be parsed.

So now everyone can try to explain why parseInt(9999999999999999999999) is equal to 1?

English original address: https://dmitripavlutin.com/parseint-mystery-javascript/

Author: Dmitri Pavlutin

More programming related For knowledge, please visit: programming video! !

The above is the detailed content of Weird behavior of parsing parseInt() in JavaScript. For more information, please follow other related articles on the PHP Chinese website!