Javascript-Nummerntypwert

Allgemeine Einführung

JavaScript verwendet intern das IEEE754-Format zur Darstellung von Zahlen, unterscheidet also nicht zwischen Ganzzahlen und Gleitkommazahlen und wird in der Form 64 gespeichert -Bit-Gleitkommazahlen. Das heißt, in JavaScript gibt es überhaupt keine Dezimalstellen. Einige Operationen müssen jedoch mit Ganzzahlen abgeschlossen werden, daher konvertiert JavaScript manchmal 64-Bit-Gleitkommazahlen in 32-Bit-Ganzzahlen, bevor Operationen ausgeführt werden.

Integer

JavaScript bietet vier Darstellungsmethoden für ganze Zahlen:

1. Binär: Für Werte mit dem Präfix 0b, ein Fehler wird gemeldet, wenn eine andere Zahl als 0 oder 1 erscheint

2. Oktal: Werte mit dem Präfix 0o, oder 0 gefolgt von einer Zahl (0-7 ). Wenn sie den zuvor genannten Zahlenbereich überschreitet, wird die erste Ziffer 0 ignoriert und als Dezimalzahl behandelt.

Hinweis: Oktalliterale sind im strikten Modus ungültig und führen dazu, dass JavaScript-Engines, die diesen Modus unterstützen, einen Fehler auslösen

3. Hexadezimal: Es gibt ein Präfix von 0x, gefolgt von einer beliebigen hexadezimalen Ziffer (0~9 und A~F). Bei Überschreitung des Bereichs wird ein Fehler angezeigt gemeldet

4. Dezimalzahl

var num2 = 0b11;
 console.log(num2); //3
 var num2 = 0b12;
 console.log(num2); //报错
 var num8 = 0o76;
 console.log(num8); //02
 var num8 = 0o78;
 console.log(num8); //报错
 var num16 = 0x2a;
 console.log(num16); //42
 var num16 = 0x2h;
 console.log(num16) //报错

Gleitkommazahl

Die sogenannte Gleitkommazahl, das heißt, der Wert muss einen Dezimalpunkt enthalten und nach dem Dezimalpunkt muss mindestens eine Ziffer stehen. Im Gegensatz zu Ganzzahlen können Gleitkommazahlen nur in Dezimalzahlen ausgedrückt werden.

Die Genauigkeit von Gleitkommazahlen ist weitaus schlechter als die von Ganzzahlen, daher müssen Sie beim Entwerfen von Operationen mit Gleitkommazahlen vorsichtig sein

Zum Beispiel:

 console.log(0.1 + 0.2 == 0.3); //false 0.30000000000000004
 console.log(0.6/0.2); //2.9999999999999996

Wissenschaftliche Notation

Für diejenigen, die extrem sind Kleine und extrem kleine Werte können durch e dargestellt werden. Eine numerische Gleitkommadarstellung in wissenschaftlicher Notation. Der in der e-Notation ausgedrückte Wert ist gleich dem Wert vor e multipliziert mit der Exponentialpotenz von 10

In den folgenden beiden Fällen konvertiert JavaScript den Wert automatisch in die wissenschaftliche Notation. In anderen Fällen wird dies der Fall sein direkt in wörtlicher Form ausgedrückt werden.

1. Es gibt mehr als 21 Stellen vor dem Komma

 console.log(1234567890123456789012);// 1.2345678901234568e+21
 console.log(123456789012365648787); //123456789012365660000　

2 als 5 Nachkommastellen

 console.log(0.0000006);//6e-7
 console.log(0.000006); //0.000006

Wertebereich

Aufgrund von Speicherbeschränkungen kann ECMAScript nicht alle Werte der Welt speichern, daher gibt es Maximal- und Minimalwerte

Der Minimalwert wird in Number.MIN_VALUE gespeichert, dieser Wert ist 5e-324

Der Maximalwert wird in Number.MAX_VALUE gespeichert, dieser Wert ist 1,7976931348623157e+308

 console.log(Number.MIN_VALUE) //5e-324
 console.log(Number.MAX_VALUE); //1.7976931348623157e+308

Wenn der Wenn die Zahl den Maximalwert überschreitet, gibt Javascript Unendlichkeit zurück, was als positiver Überlauf bezeichnet wird. Wenn sie gleich oder größer als der minimale negative Wert -1023 ist (d. h. sehr nahe bei 0), konvertiert JavaScript diese Zahl direkt in 0 wird als negativer Überlauf bezeichnet.

Wenn Sie feststellen möchten, ob ein Wert endlich ist, verwenden Sie die Funktion isFinite(). Diese Funktion gibt „true“ zurück, wenn das Argument zwischen dem minimalen und dem maximalen Wert liegt

 var result = Number.MAX_VALUE + Number.MAX_VALUE;
 console.log(isFinite(result)); //false

Sonderwerte

1, +0 und -0

Diese beiden Nullen sind bei großen Logarithmen äquivalent

 -0 === +0; //true
 0 === -0; //true
 0 === +0; //true

Aber es ist anders, wenn es als Nenner verwendet wird

1/-0 == 1/+0; //false

2. Unendlichkeit

Unendlichkeit bedeutet „Unendlichkeit“ und wird zur Darstellung zweier Szenarien verwendet. Zum einen ist ein positiver Wert zu groß oder ein negativer Wert zu klein, um dargestellt zu werden. Zum anderen wird ein Wert ungleich 0 durch 0 geteilt, um Unendlichkeit zu erhalten.

 Math.pow(2,Math.pow(2,100));//Infinity
 1/0;//Infinity

Das Operationsergebnis von Infinity kann nur es selbst, 0 oder NaN sein

* Infinity;//Infinity
- Infinity;//-Infinity
+ Infinity;//Infinity
/ Infinity;//0
 Infinity / 2;//Infinity
 Infinity * Infinity;//Infinity
 Infinity - Infinity;//NaN
 Infinity + Infinity;//Infinity
 Infinity / Infinity;//NaN

3. NaN

Dieser Wert stellt einen Operanden dar, der einen Wert zurückgeben soll . Fälle, in denen kein numerischer Wert zurückgegeben wird

NaN entspricht keinem Wert, einschließlich sich selbst, und jede Operation, an der NaN beteiligt ist, gibt NaN zurück

 5 - 'x'; //NaN
 Math.acos(2); //NaN
 0 / 0; //NaN
 NaN == NaN;//false
 NaN == Infinity;//false

NaN ist kein unabhängiger Datentyp, sondern ein spezieller Wert. Sein Datentyp gehört immer noch zu Number

typeof NaN; //number

isNaN-Methode kann verwendet werden Bestimmen Sie, ob ein Wert NaN ist. IsNaN gilt jedoch nur für numerische Werte. Wenn andere Werte übergeben werden, werden diese zuerst in numerische Werte umgewandelt. Wenn beispielsweise eine Zeichenfolge übergeben wird, wird die Zeichenfolge zuerst in NaN konvertiert, sodass am Ende „true“ zurückgegeben wird. Darauf sollte besonders geachtet werden. Mit anderen Worten: Der Wert, für den isNaN wahr ist, ist möglicherweise nicht NaN, sondern eine Zeichenfolge.

 isNaN('Hello') // true
 // 相当于
 isNaN(Number('Hello')) // true

Eine zuverlässigere Möglichkeit, NaN zu beurteilen, besteht darin, sich die Tatsache zunutze zu machen, dass NaN der einzige Wert in Javascript ist ist nicht gleich sich selbst. Machen Sie ein Urteil

 function isNaN(value){
 return value != value;
 }

Umrechnung des Zahlensystems

Es gibt 3 Funktionen zum Konvertieren nicht numerischer Werte in numerische Werte: Number(), parseInt() und parseFloat(). Unter diesen kann Number() jede Art von Wert in einen numerischen Wert umwandeln, während parseInt() und parseFloat() nur zum Konvertieren von Zeichenfolgen in Zahlen

Number()<🎜 verwendet werden >

Konvertierungsregeln:

1 Wenn es sich um einen booleschen Wert handelt, werden wahr und falsch in 1 bzw. 0 umgewandelt.

2 ein Nullwert, 0

3、如果是undefined，返回NaN

4、如果是字符串，遵循以下规则：

（1）若字符串只包含十进制或十六进制数字，则转成十进制的数字

注意：Number()不识别八进制数字的字符串，会按照十进制数字处理

字符串'1.2.'不会报错，但数字1.2.会报错

（2）若字符串为空字符串或空格字符串，则转成0

（3）其他情况的字符串，则转成NaN

Number(true) //1
 Number(null) //0
 Number(undefined) //NaN
 Number("0123") //123
 Number("0x123") //291
 Number("0.2") //0.2
 Number("") //0
 Number("asd") //NaN

parseInt()

parseInt()专门用于把字符串转换成整数。在转换字符串时，会忽略字符串前面的空格，直到找到第一个非空格字符。如果第一个字符不是数字字符或者负号，parseInt()就会返回NaN。如果是，则继续解析，直到解析完成或者遇到非数字字符

 console.log(parseInt(' 123.8px'));//123
 console.log(parseInt(' 123.8 '));//123
 console.log(parseInt(' -123.8px'));//-123
 console.log(parseInt('a123.8px'));//NaN
 console.log(parseInt('0 123.8px'));//0

注意：在ECMAScript5中，parseInt()已经不具备解析八进制的能力。例如八进制“070”，会忽略前面的“0”，得到十进制的70

为了消除在使用parseInt()函数时可能导致的上述困惑，可以为这个函数提供第二个参数：转换时使用的基数（多少进制）

 parseInt("070") //70
 parseInt("070",8) //56

parseFloat()

parseFloat()专门用于字符串转换浮点数。同样地，解析时会忽略字符串前面的空格，直到找到第一个非空格字符，然后一直解析到字符串末尾或一个无效的浮点数字字符为止

console.log(parseFloat(' 0123.px'));//123
 console.log(parseFloat(' 123.px'));//123
 console.log(parseFloat(' 123.1px'));//123.1
 console.log(parseFloat(' 123.1.2px '));//123.1
 console.log(parseFloat(' -123.0px'));//-123
 console.log(parseFloat('.123.1px'));//0.123
 console.log(parseFloat('0 123px'));//0

注意：parseFloat()只解析十进制，所以十六进制的字符串始终会被转换成0。因此也没有第二个参数用来指定基数

 parseFloat("0xA") //0

注意：Number('')的结果是0，parseInt('')和parseFloat('')的结果是NaN

更多Number类型值相关文章请关注PHP中文网！