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 integer100.

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 useparseIntto 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) useparseInt()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 as0.5,0.05, etc., results in0, which is as expected.

How about extracting the integer part of0.0000005?

parseInt(0.0000005); // => 5

parseInt()Parses the floating point number0.0000005into5. Why doesparseInt(0.0000005)have such a weird behavior?

2. SolvingparseInt()weird behavior

Let’s take another look atparseInt(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 tostring(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! BecauseparseInt()always converts its first argument to a string, floating-point numbers less than10 minus 6will be expressed as an exponent. ThenparseInt()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 theMath.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 useparseInt()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 inparseInt()can lead to unexpected results: only the significant part of the exponent notation (e.g.in5e-75) will be parsed.

So now everyone can try to explain whyparseInt(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!