Seltsames Verhalten beim Parsen von parseInt() in JavaScript

Dieser Artikel stellt Ihnen das seltsame Verhalten beim Parsen von parseInt() in JavaScript vor. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.

【Empfohlenes Lernen: Javascript-Tutorial für Fortgeschrittene】

parseInt() ist eine integrierte JS-Funktion, die zum Parsen von Ganzzahlen in numerischen Zeichenfolgen verwendet wird. Beispiel: Parsen der numerischen Zeichenfolge '100': parseInt()是内置的 JS 函数，用于解析数字字符串中的整数。 例如，解析数字字符串'100'：

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

如预期的那样，'100'被解析为整数 100。

parseInt(numericalString, radix)还接受第二个参数：从 2 到 36，表示字符串的基数。例如指定 16 表示被解析值是十六进制数。请注意，10 不是默认值，最常见的是 2、8、10 和 16。

例如我们使用 parseInt 以二进制方式解析数字字符串：

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

100 对应的二进制数是 4，所以返回 4。

1. parseInt() 的怪异行为

parseInt(numericalString)始终将其第一个参数转换为字符串（如果不是字符串），然后将该数字字符串解析为整数值。

这就是为什么你可以（但不应该）使用parseInt()提取浮点数的整数部分的原因：

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

提取浮点数的整数部分，如0.5、0.05等，结果为0, 这和预期的一样。

那提取0.0000005的整数部分怎么样？

parseInt(0.0000005); // => 5

parseInt() 将浮点数 0.0000005 解析为 5。为什么 parseInt(0.0000005) 有这样一个怪异的行为？

2.解决parseInt()怪异行为

我们再看一看 parseInt(numericalString) 的第一个参数：如果它不是字符串，则将其转换为字符串，然后解析，并返回解析后的整数。

这可能是第一个线索。

然后，我们尝试将浮点数手动转换为字符串表示形式：

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'

显式转换为string(0.0000005)字符串的行为与其他浮点数不同:它的表示方式是用指数的形式。

这是第二个重要的线索！

当指数符号被解析为整数时，我们会得到数字5

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

parseInt('5e-7')考虑第一个数字'5'，但跳过'e-7'。

谜团已揭开！ 因为 parseInt() 始终将其第一个参数转换为字符串，所以小于10负6次方的浮点数将以指数表示。 然后 parseInt() 从 float 的指数表示法中提取整数。

另外，为了安全地提取浮点数的整数部分，建议使用 Math.floor() 函数：

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.总结

parseInt() 是将数字字符串解析为整数的函数。

尝试使用parseInt()提取浮点数的整数部分时必须小心。

小于10的-6次方 (例如0.0000005，也就是5*10-7)的浮点数转换成字符串时被写成指数表示法(例如5e-7是0.0000005的指数表示法)。这就是为什么在 parseInt() 中使用这么小的浮点数会导致意想不到的结果:只有指数表记的重要部分(例如 5e-7 中的 5)会被解析。

那么现在大家可以试着解释为什么 parseInt(999999999999999999999)rrreee

Wie erwartet wird '100' als Ganzzahl 100 analysiert.

parseInt(numericalString, radix) akzeptiert auch einen zweiten Parameter: von 2 bis 36, der die Basis des Strings angibt. Die Angabe von 16 bedeutet beispielsweise, dass der analysierte Wert eine Hexadezimalzahl ist. Beachten Sie, dass 10 nicht der Standardwert ist, am häufigsten sind 2, 8, 10 und 16.

Zum Beispiel verwenden wir parseInt, um eine numerische Zeichenfolge im Binärmodus zu analysieren:

rrreee

Die entsprechende Binärzahl von 100 ist 4, daher wird 4 zurückgegeben.

1. Seltsames Verhalten von parseInt()

parseInt(numericalString) konvertiert sein erstes Argument immer in eine Zeichenfolge, wenn es keine Zeichenfolge ist ) und analysiert dann die numerische Zeichenfolge in einen ganzzahligen Wert. Aus diesem Grund können Sie (aber nicht) parseInt() verwenden, um den ganzzahligen Teil einer Gleitkommazahl zu extrahieren: 🎜rrreee🎜Extrahieren Sie den ganzzahligen Teil von eine Gleitkommazahl wie 0.5, 0.05 usw., das Ergebnis ist 0, was wie erwartet ist. 🎜🎜Wie wäre es mit dem Extrahieren des ganzzahligen Teils von 0.0000005? 🎜rrreee🎜parseInt() analysiert die Gleitkommazahl 0.0000005 in 5. Warum hat parseInt(0.0000005) so ein seltsames Verhalten? 🎜

2. Lösung des seltsamen Verhaltens von parseInt()

🎜Werfen wir noch einmal einen Blick auf den ersten Schritt von parseInt(numericalString) Argumente: Wenn es sich nicht um eine Zeichenfolge handelt, konvertieren Sie sie in eine Zeichenfolge, analysieren Sie sie und geben Sie die analysierte Ganzzahl zurück. 🎜🎜Das könnte der erste Hinweis sein. 🎜🎜Wir versuchen dann, den Float manuell in eine String-Darstellung umzuwandeln: 🎜rrreee🎜 Explizite Konvertierung in <code>string(0.0000005) Strings verhalten sich anders als andere Floats: Die Darstellung erfolgt in Exponentialform. 🎜🎜Das ist der zweite wichtige Hinweis! 🎜🎜Wenn die Exponentennotation in eine Ganzzahl geparst wird, erhalten wir die Zahl 5🎜rrreee🎜parseInt('5e-7')Unter Berücksichtigung der ersten Zahl '5', Aber 'e-7' wird übersprungen. 🎜🎜Das Rätsel ist gelöst! Da parseInt() sein erstes Argument immer in einen String umwandelt, werden Gleitkommazahlen kleiner als 10 minus 6 als Exponenten ausgedrückt. Dann extrahiert parseInt() die Ganzzahl aus der Exponentialdarstellung des Floats. 🎜🎜Um den ganzzahligen Teil der Gleitkommazahl sicher zu extrahieren, wird außerdem empfohlen, die Funktion Math.floor() zu verwenden: 🎜rrreee

3

🎜 parseInt() ist eine Funktion, die eine numerische Zeichenfolge in eine Ganzzahl analysiert. 🎜🎜Seien Sie vorsichtig, wenn Sie versuchen, mit parseInt() den ganzzahligen Teil einer Gleitkommazahl zu extrahieren. 🎜🎜Gleitkommazahlen kleiner als 10 hoch -6 (z. B. 0,0000005, also 5*10-7) werden bei der Konvertierung in Zeichenfolgen in Exponentialschreibweise geschrieben (5e-7 ist beispielsweise die Exponentialschreibweise von). 0,0000005). Aus diesem Grund führt die Verwendung solch kleiner Gleitkommazahlen in parseInt() zu unerwarteten Ergebnissen: Nur der signifikante Teil der Exponentennotation (z. B. 5e-7 code>5 ) wird analysiert. 🎜🎜Jetzt kann also jeder versuchen zu erklären, warum parseInt(999999999999999999999) gleich 1 ist? 🎜🎜🎜Englische Originaladresse: https://dmitripavlutin.com/parseint-mystery-javascript/🎜🎜Autor: Dmitri Pavlutin🎜🎜🎜Weitere Programmierkenntnisse finden Sie unter: 🎜Programmiervideo🎜! ! 🎜

Das obige ist der detaillierte Inhalt vonSeltsames Verhalten beim Parsen von parseInt() in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!