Numerische Konvertierung von Number(), parseInt() und parseFloat()

Es gibt drei Funktionen, die nicht numerische Werte in numerische Werte umwandeln können: Number(), parseInt() und parseFloat(). Die erste Funktion, die Konvertierungsfunktion Number(), kann für jeden Datentyp verwendet werden, während die anderen beiden Funktionen speziell zum Konvertieren von Zeichenfolgen in Zahlen dienen. Diese drei Funktionen führen bei derselben Eingabe zu unterschiedlichen Ergebnissen.

Die Konvertierungsregeln der Funktion Number() lauten wie folgt:

Wenn es sich um einen booleschen Wert handelt, werden wahr und falsch in 1 bzw. 0 umgewandelt.
Wenn es ein ist numerischer Wert, er wird einfach übergeben Enter und zurückgeben
Wenn es ein Nullwert ist, geben Sie 0 zurück
Wenn es undefiniert ist, geben Sie NaN zurück
Wenn es eine Zeichenfolge ist, befolgen Sie die folgenden Regeln:
Wenn Die Zeichenfolge enthält nur Zahlen. Konvertieren Sie sie in Dezimalwerte. „1“ wird zu 1, „123“ wird zu 123 und „011“ wird zu 11 (die führende 0 wird ignoriert).
Wenn die Zeichenfolge nur gültige Gleitkommazahlen enthält B. „1.1“, und konvertieren Sie ihn dann in den entsprechenden Gleitkommawert (ebenso werden auch führende Nullen ignoriert).
Wenn die Zeichenfolge nur ein gültiges Hexadezimalformat enthält, z. B. „0xf“, dann konvertieren Sie sie ein dezimaler ganzzahliger Wert derselben Größe
Wenn die Zeichenfolge leer ist (keine Zeichen enthält), wird sie in 0 konvertiert
Wenn die Zeichenfolge andere Zeichen als das oben genannte Format enthält, wird sie in NaN konvertiert
If Es handelt sich um ein Objekt. Rufen Sie die valueOf()-Methode des Objekts auf und konvertieren Sie dann den zurückgegebenen Wert gemäß den vorherigen Regeln. Wenn das Ergebnis der Konvertierung NaN ist, ist es tatsächlich etwas kompliziert, toString() des Objekts aufzurufen, um verschiedene Datentypen in numerische Werte umzuwandeln. Hier ein paar konkrete Beispiele:

var num1 = Number("Hello world!"); //NaN
var num2 = Number(""); //0
var num3 = Number("000011"); //11
var num4 = Number("true"); //1

Zuerst wird die Zeichenfolge „Hallo Welt!“ in NaN konvertiert, da sie keinen aussagekräftigen numerischen Wert enthält. Leere Zeichenfolgen werden in 0 konvertiert. Die Zeichenfolge „000011“ wird in 11 konvertiert, da führende Nullen ignoriert werden. Abschließend wird der wahre Wert in 1 umgewandelt.

Da die Funktion Number() beim Konvertieren von Zeichenfolgen komplex und unzumutbar ist, wird die Funktion parseInt() häufiger bei der Verarbeitung von Ganzzahlen verwendet. Wenn die Funktion parseInt() einen String konvertiert, kommt es eher darauf an, ob er dem numerischen Muster entspricht. Es ignoriert führende Leerzeichen in der Zeichenfolge, bis das erste Nicht-Leerzeichen gefunden wird. Wenn das erste Zeichen kein numerisches Zeichen oder ein negatives Vorzeichen ist, gibt parseInt() NaN zurück, d. h. die Verwendung von parseInt() zum Konvertieren einer leeren Zeichenfolge gibt NaN zurück (Number() gibt 0 für eine leere Zeichenfolge zurück). Wenn das erste Zeichen ein numerisches Zeichen ist, analysiert parseInt() das zweite Zeichen weiter, bis alle nachfolgenden Zeichen analysiert wurden oder ein nicht numerisches Zeichen gefunden wird. Beispielsweise würde „123blue“ in 1234 umgewandelt, da „blue“ komplett ignoriert würde. Ebenso wird „22,5“ in 22 umgewandelt, da der Dezimalpunkt kein gültiges numerisches Zeichen ist.

Wenn das erste Zeichen in der Zeichenfolge ein numerisches Zeichen ist, kann parseInt() auch verschiedene Ganzzahlformate (d. h. dezimal, oktal, hexadezimal) erkennen. Das heißt, wenn die Zeichenfolge mit „0x“ beginnt und von numerischen Zeichen gefolgt wird, wird sie als hexadezimale Ganzzahl behandelt. Wenn die Zeichenfolge mit „0“ beginnt und von numerischen Zeichen gefolgt wird, wird sie als oktale Ganzzahl behandelt .

Um die Konvertierungsregeln der Funktion parseInt() besser zu verstehen, werden im Folgenden einige Beispiele aufgeführt:

var num1 = parseInt("1234blue"); //1234
var num2 = parseInt(""); //NaN
var num3 = parseInt("0xA") //10(十六进制)
var num4 = parseInt("22.5"); //22
var num5 = parseInt("070"); //56(八进制)
var num6 = parseInt("70"); //(70)十进制
var num7 = parseInt("0xF") //15(十六进制)

Beim Verständnis dieser Beispiele ist es am wichtigsten, darauf zu achten parseInt( ) verschiedene Möglichkeiten zum Parsen von „070“ und „70“. Zu diesem Zeitpunkt zeigen die führenden Nullen in „070“ an, dass es sich um eine Zeichenfolge im oktalen (nicht dezimalen) Format handelt, sodass das Ergebnis 56 ist (beachten Sie, dass sich dieses Ergebnis vom Aufruf der Number()-Funktion unterscheidet). Und „70“, weil es keine führende Null gibt, wird in 70 umgewandelt. Um die oben genannte Verwirrung zu beseitigen, die bei der Verwendung der Funktion parseInt() auftreten kann, stellt ECMAScript auch einen zweiten Parameter für diese Funktion bereit: die für die Konvertierung verwendete Basis (d. h. die Basis).

Wenn Sie wissen möchten, dass der zu analysierende Wert eine Zeichenfolge im Hexadezimalformat ist, kann die Angabe der Basis 16 als zweiten Parameter das korrekte Ergebnis sicherstellen, zum Beispiel:

var num = parseInt("0xAF", 16); //175
Wenn 16 als zweiter Parameter angegeben wird, kann die Zeichenfolge tatsächlich ohne das vorangehende „0x“ sein, wie unten gezeigt:

var num1 = parseInt("AF", 16); //175
var num2 = parseInt("AF"); //NaN

Die erste Konvertierung in diesem Beispiel ist erfolgreich, die zweite schlägt jedoch fehl. Der Unterschied besteht darin, dass die erste Konvertierung die Basis durchläuft und parseInt() explizit anweist, eine Zeichenfolge im Hexadezimalformat zu analysieren, während die zweite Konvertierung feststellt, dass das erste Zeichen kein numerisches Zeichen ist, und daher automatisch beendet wird.

Die Angabe der Basis wirkt sich auf das Ausgabeergebnis der Konvertierung aus. Zum Beispiel:

var num1 = parseInt("10", 2); //2
var num2 = parseInt("10", 8);  //8
var num3 = parseInt("10", 10); //10
var num4 = parseInt("10", 16); //16

Da die Nichtangabe der Basis bedeutet, dass parseInt() entscheiden kann, wie die Eingabezeichenfolge analysiert wird, empfehlen wir, um eine falsche Analyse zu vermeiden, unabhängig von der Situation die explizite Angabe der Basis – insbesondere beim Umgang mit Oktalzahlen wie folgt:

var num1 = parseInt("010"); //8
var num2 = parseInt("010", 8); //8
var num2 = parseInt("010", 10); //10

　　在这个例子中，“010”会因为第二个参数不同而被转换成不同的值。第一行的转换很直观，即让parseInt()决定如何转换。由于第一个字符是 “0”而后面也是数字字符，因而parseInt()假设它是一个八进制数。实际上，parseInt()的这个默认行为域第二行转换中明确了基数行为是 一致的。第三行传入基数10，因此parseInt()就会忽略字符串中的前导零，而只解析其余的数字符。

　　多数情况下，我们要解析的都是十进制数值，因此始终将10作为第二个参数是非常必要的。

　　与parseInt()函数类似，parseFloat()也是从第一个字符（位置0）开始解析每个字符。而且也是一直解析到字符串末尾，或者解析 到遇见一个无效的浮点数字字符为止。也就是说，字符串中的第一个小数点是有效的，而第二个小数点是无效的，因此它后面的字符串将被忽略。举例来 说，“22.34.5”将会被转换为22.34。

　　除了第一个小数点有效之外，parseFloat()与parseInt()的第二个区别在于它始终都会忽略前导零。parseFloat()可以 识别前面讨论过的所有浮点数值格式，也包括十进制整数格式。但十六进制格式的字符串始终会被转换为0。由于parseFloat()只解析十进制值，因此 它没有用第二个参数指定基数的用法。最后还要注意一点：如果字符串包含的是一个可解析为整数的数（没有小数点，或者小数点后面都是 零），parseFloat()会返回整数。以下是使用parseFloat()转换数值的几个典型示例：

var num1 = parseFloat("1234blue"); //1234
var num1 = parseFloat("0xA"); //0
var num1 = parseFloat("22.5"); //22.5
var num1 = parseFloat("22.34.5"); //22.34
var num1 = parseFloat("0908.5"); //908.5
var num1 = parseFloat("3.125e7"); //31250000

Das obige ist der detaillierte Inhalt vonNumerische Konvertierung von Number(), parseInt() und parseFloat(). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!