Wie viele Arten von numerischen Javascript-Typen gibt es?

In JavaScript gibt es nur einen numerischen Typ: den Gleitkommatyp. JavaScript speichert Zahlen intern als 64-Bit-Gleitkommatypen, sodass es in JavaScript eigentlich keinen Ganzzahltyp gibt. Gemäß dem Zahlenformat in JavaScript beträgt der Bereich der darstellbaren Ganzzahlen „[-2^53 ~ 2^53]“, einschließlich Grenzwerten. Es ist jedoch zu beachten, dass Array-Indizes, Bitoperatoren usw. 32 verwenden -Bit-Ganzzahlen.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, JavaScript-Version 1.8.5, Dell G3-Computer.

In JavaScript gibt es nur einen numerischen Typ, der intern als 64-Bit-Gleitkommazahl dargestellt wird. Daher gibt es in JavaScript eigentlich keinen Integer-Typ.

print(3/2); // 1.5

Man erkennt, dass die Werte als Gleitkommazahlen verarbeitet werden.

Weil JavaScript Zahlen intern in 64-Bit-Gleitkommatypen speichert, unabhängig von Ganzzahlen oder Dezimalzahlen. Was verwirrend ist, ist, dass für die Ausführung einiger Bitoperationen Ganzzahlen erforderlich sein müssen, sodass 64-Bit-Gleitkommazahlen automatisch in 32-Bit-Ganzzahlen umgewandelt werden. Führen Sie dann Bitoperationen durch. In JavaScript sind 1 und 1.0 gleich.

1 == 1.0 true
0.1+0.2 == 0.3 false
0.3/0.1 = 2.99999999996
(0.3-0.2) === (0.2-0.1) false

Kurz gesagt: Seien Sie vorsichtig, wenn Sie Operationen mit Dezimalzahlen ausführen darstellbar ist [- 2^53 ~ 2^53], einschließlich Grenzwerten. Es ist jedoch zu beachten, dass Array-Indizierung, bitweise Operatoren usw. 32-Bit-Ganzzahlen verwenden.

Die höchste Genauigkeit von Gleitkommawerten beträgt 17 Dezimalstellen, bei arithmetischen Berechnungen ist ihre Genauigkeit jedoch weitaus geringer als die von Ganzzahlen. Das Ergebnis der Addition von 0,1 zu 0,2 ist beispielsweise nicht 0,3, sondern 0,30000000000000004. Dieser kleine Rundungsfehler macht es unmöglich, bestimmte Gleitkommawerte zu testen.

Weil binäre Gleitkommazahlen 1/2, 1/8 usw. genau darstellen können, nicht jedoch 1/10, 1/100 usw. genau. Daher können einfache Zahlen wie 0,1 nicht genau dargestellt werden.

Aufgrund von Präzisionsproblemen bei Gleitkommazahlen erhalten Sie beim Vergleich möglicherweise unerwartete Ergebnisse:

print((0.1+0.2) == 0.3); // false
print(0.1+0.2);          // 0.30000000000000004
print(0.3);              // 0.3

print((10/3-3) == (1/3));// false
print(10/3-3);           // 0.3333333333333335
print(1/3);              // 0.3333333333333333

Bei Ganzzahlen gibt es keine Genauigkeitsprobleme, solange Sie Ganzzahlen mit maximal 53 Ziffern verwenden, und Sie können sie bedenkenlos verwenden.

Ganzzahlen können nicht nur dezimal dargestellt werden, sondern auch durch Literale im Oktalformat (Basis 8) oder Hexadezimalformat (Basis 16). Dabei muss die erste Ziffer des Oktalliterals Null (0) sein, gefolgt von einer Folge oktaler Ziffern (0 bis 7). Wenn der Wert im Literal den Bereich überschreitet, werden führende Nullen ignoriert und der folgende Wert wird als Dezimalwert interpretiert.

Oktale Literale sind im strikten Modus ungültig und führen dazu, dass JavaScript-Engines, die diesen Modus unterstützen, Fehler auslösen.

Die ersten beiden Ziffern eines hexadezimalen Literalwerts müssen 0x sein, gefolgt von einer beliebigen hexadezimalen Ziffer (0~9 und A~F). Dabei können die Buchstaben A bis F sowohl Groß- als auch Kleinbuchstaben sein.

Da das Speichern von Gleitkommawerten doppelt so viel Speicherplatz benötigt wie das Speichern von Ganzzahlwerten, verschwendet ECMAScript keine Zeit mit der Konvertierung von Gleitkommawerten in Ganzzahlwerte. Wenn auf den Dezimalpunkt keine Ziffern folgen, kann der Wert natürlich als Ganzzahlwert gespeichert werden. Wenn der Gleitkommawert selbst eine Ganzzahl darstellt (z. B. 1,0), wird der Wert ebenfalls in eine Ganzzahl konvertiert.

Numerisches Objekt
So wie ein String-Wert einem String-Objekt entspricht, hat auch ein numerischer Wert ein entsprechendes numerisches Objekt, nämlich Number.

Zahlen können auch direkt die Eigenschaften aufrufen, die dem numerischen Wert entsprechen:

print((6).toString()); // 6

Beachten Sie, dass in diesem Beispiel der numerische Wert in Klammern hinzugefügt werden muss, andernfalls wird der Punkt als Dezimalpunkt betrachtet.

Die Verwendung von Number ähnelt der Verwendung von String. Es kann eine Typkonvertierung durchführen, numerische Objekte erstellen usw.

Wenn bei der Typkonvertierung die Konvertierung fehlschlägt, gibt Number NaN zurück. Das Gleiche gilt für die Verwendung numerischer Objekte.

var a = Number('x');
print(typeof a, a);       // number NaN
var b = new Number('x'); 
print(typeof b, b);       // object [Number: NaN]

Number hat 5 spezielle Attribute (schreibgeschützt), nämlich:

MAX_VALUE: Der Maximalwert einer positiven Zahl. Wenn sie größer ist, wird sie unendlich.
MIN_VALUE: Der Minimalwert von a positive Zahl, wenn sie kleiner ist, wird sie zu Unendlichkeit wird 0
NaN: Keine Zahl
NEGATIVE_INFINITY: Negative Unendlichkeit, das heißt -Unendlichkeit
POSITIVE_INFINITY: Positive Unendlichkeit, das heißt Unendlichkeit

• print(Number.MAX_VALUE);         // 1.7976931348623157e+308
  print(Number.MIN_VALUE);         // 5e-324
  print(Number.NaN);               // NaN
  print(Number.NEGATIVE_INFINITY); // -Infinity
  print(Number.POSITIVE_INFINITY); // Infinity

UnendlichWenn das Ergebnis der Zahlenoperation die Obergrenze der Zahl überschreitet, die JavaScript darstellen kann, ist das Ergebnis ein spezieller Unendlichkeitswert (Unendlichkeit), wenn der negative Wert den Bereich negativer Zahlen überschreitet das JavaScript darstellen kann, ist das Ergebnis -Infinity.

Wenn das Operationsergebnis unendlich nahe bei Null liegt und kleiner als der Mindestwert ist, den JavaScript darstellen kann (Unterlauf), ist das Ergebnis 0. Wenn eine negative Zahl unterläuft, ist das Ergebnis -0. Wenn eine positive Zahl unterläuft, ist das Ergebnis ist +0.

JavaScript definiert die globalen Variablen Infinity und NaN vor, die beide schreibgeschützte Variablen sind.

由于内存的限制，ECMAScript并不能保存世界上所有的数值。ECMAScript能够表示的最小数值保存在Number.MIN_VALUE中——在大多数浏览器中，这个值是5e-324；能够表示的最大数值保存在Number.MAX_VALUE中——在大多数浏览器中，这个值是1.7976931348623157e+308。如果某次计算的结果得到了一个超出JavaScript数值范围的值，那么这个数值将被自动转换成特殊的Infinity值。具体来说，如果这个数值是负数，则会被转换成-Infinity（负无穷），如果这个数值是正数，则会被转换成Infinity（正无穷）。 

如果某次计算返回了正或负的Infinity值，那么该值将无法继续参与下一次的计算，因为Infinity不是能够参与计算的数值。要想确定一个数值是不是有穷的（换句话说，是不是位于最小和最大的数值之间），可以使用isFinite()函数。

NaN

NaN是一个特殊的数值，这个数值用于表示一个本来要返回数值的操作数未返回数值的情况（这样就不会抛出错误了）。

对于NaN，要记住的一点是，只要运算中出现NaN，结果就一定是NaN，就算是"NaN*0"这样的运算，也一样是NaN。只要对NaN运行比较运行，结果就一定是false，就算"NaN==NaN"/"NaN!=NaN"等，都是false。

要判断一个值是否为NaN，可以使用isNaN()函数：

print(isNaN(NaN));  // true
print(isNaN(0/0));  // true

在基于对象调用isNaN()函数时，会首先调用对象的valueOf()方法，然后确定该方法返回的值是否可以转换为数值。如果不能，则基于这个返回值再调用toString()方法，再测试返回值。

也可以使用x!==x来判断x是否为NaN，只有在x为NaN的时候，这个表达式的值才为true。

inFinite()

isFinite函数用于判断一个数是否为“正常”的数值：

print(isFinite(Number.NaN));               // false
print(isFinite(Number.NEGATIVE_INFINITY)); // false
print(isFinite(Number.POSITIVE_INFINITY)); // false

除了以上3个特殊值外，其他值的结果都为true

假如x是一个普通数值，则有：

x/0 = Infinity
x%0 = NaN
x/Infinity = 0
x%Infinity = x
0/0 = NaN
0%0 = NaN
Infinity/x = Infinity
Infinity%x = NaN
Infinity/Infinity = NaN
Infinity%Infinity = NaN

完整输出如下：

print(0 / 0);           // NaN
print(3 / 0);           // Infinity
print(Infinity / 0);    // Infinity
print(0 % 0);           // NaN
print(3 % 0);           // NaN
print(Infinity % 0);    // NaN
----------
print(0 / 4);           // 0
print(3 / 4);           // 0.75
print(Infinity / 4);    // Infinity
print(0 % 4);           // 0
print(3 % 4);           // 3
print(Infinity % 4);    // NaN
----------
print(0 / Infinity);           // 0
print(3 / Infinity);           // 0
print(Infinity / Infinity);    // NaN
print(0 % Infinity);           // 0
print(3 % Infinity);           // 3
print(Infinity % Infinity);    // NaN

负零与正零

负零与正零的值相等，不过毕竟带有符号，在一些运算中会有符号方面的差别，比如：

var zero = 0; 
var negz = -0;

此时，zero 等于 negz ， 但1/zero 却不等于 1/negz。

【相关推荐：javascript视频教程、编程基础视频】

Das obige ist der detaillierte Inhalt vonWie viele Arten von numerischen Javascript-Typen gibt es?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!