JS hat nur einen numerischen Datentyp. Egal, ob es sich um eine Ganzzahl oder eine schwimmende Punktnummer handelt, JS klassifiziert sie als Zahl.
Typ 17; // "Nummer"
Typ von 98,6; // "Nummer"
typeof 2.1; // "Nummer"
Alle Zahlen in JS sind doppelte Präzisionsfloatpunktzahlen. Es ist eine 64-Bit-codierte Nummer, die vom IEEE754-Standard formuliert wurde (was ist das für ein Ding, ich weiß nicht, schau es einfach nach und schau es dir an)
Wie drückt JS Ganzzahlen aus? Doppelte Präzisionsfloat-Punktzahlen können perfekt Zahlen mit einer Präzision von bis zu 53-Bit darstellen (kein Konzept, ich habe nicht zu viele Daten verarbeitet, ich habe nicht verbraucht!) Und alle Ganzzahlen von -9007199254740992 (-253) bis 900719254740992 (253) Die gültigen Präzisionsfloßpunkte sind gültig.
Die meisten arithmetischen Operatoren können unter Verwendung von Ganzzahlen, reellen Zahlen oder einer Kombination aus beiden berechnet werden.
0,1*1,9 //0.19
-99+100 // 1
21-12.3 //8.7
2.5/5 //0.5
21%8 // 5
Arithmetische Operatoren sind etwas Besonderes. JS berechnet Operanden nicht direkt als schwimmende Punktzahlen, sondern wandelt sie implizit in 32-Bit-Ganzzahlen um, um Operationen durchzuführen. (Um genau zu sein, wird es in eine Ganzzahl umgewandelt, die 2 von 32-Bit-Big-Endian darstellt (um ehrlich zu sein, ich weiß wirklich nicht, was es hier bedeutet, bitte suchen
Beispiel:
8 | 1; // 9
Berechnungsprozess
Erstens sind 8 und 1 doppelte Precision-Gleitkomma-Zahlen. Es kann aber auch als 32-Bit-Ganzzahl dargestellt werden, dh eine 32-Bit-binäre Darstellung.
Integer 8 wird als 32-Bit-binär dargestellt wie:
0000 0000 0000 0000 0000 0000 0000 1000
Es kann auch sein
(8) .ToString (2); // "1000"
Der Parameterostring ist die Konvertierungsbasis
(Im Folgenden habe ich versucht, mich mit einer anderen Kardinalität zu konvertieren, und es hat nichts mit diesem Artikel zu tun.)
(8) .ToString (8); // "10"
(8) .ToString (16); // "8"
Integer 1 wird als 32-Bit-binär dargestellt wie:
0000 0000 0000 0000 0000 0000 0000 0000 0001
Bitweise laufen oder
0000 0000 0000 0000 0000 0000 0000 1000
0000 0000 0000 0000 0000 0000 0000 0000 0001
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
0000 0000 0000 0000 0000 0000 0000 1001
Gleiches verwendet die Standardbibliotheksfunktion ParseInT -Überprüfung und verwendet 2 als Kardinalität. Die führende 0 wirkt sich nicht auf das Berechnungsergebnis aus, was unnötig ist.
ParseInt ('1001', 2) // 9
(Im Folgenden habe ich versucht, mich mit einer anderen Kardinalität zu konvertieren, und es hat nichts mit diesem Artikel zu tun.)
ParseInt ('1001', 8) // 513
ParseInt ('1001', 16) // 4097
Der Prozess der Zusammenfassung des arithmetischen Betriebs besteht darin, Operanden in Ganzzahlen umzuwandeln, dann den Ganzzahl -Bit -Modus zur Durchführung von Operationen und schließlich in eine Standard -JS -Schwimmpunktzahl umzuwandeln.
Warnung vor schwimmenden Punktzahlen: notorisch ungenau. Zum Beispiel
0,1+0,2; //0.300000000000000004
Grund: Obwohl die Genauigkeit von 64-Bit-Gleitkomma-Zahlen bereits sehr hoch ist, kann die schwimmende Punktnummern mit doppelter Präzision nur einen endlichen Satz von Zahlen darstellen, können jedoch nicht alle reellen Sätze darstellen. Schwimmpunktoperationen können nur ungefähre Ergebnisse erzielen und auf die engste reelle Zahl runden. Wenn Sie eine Reihe von Operationen ausführen, werden die Betriebsergebnisse bei der Ansammlung des Rundungsfehlers weniger genau. Runden verursacht auch einige Abweichungen in den Gesetzen arithmetischer Operationen. Zum Beispiel das Gesetz der Bindung. Für jede reelle Anzahl
x, y, z befriedigt immer (x+y)+z = x+(y+z)
Schwimmende Punkte sind nicht unbedingt:
(0,1+0,2) +0,3; //0.600000000000000001
0,1+ (0,2+0,3); //0.6
Die schwimmenden Punktzahlen wiegen die Genauigkeit und Leistung. Wenn Sie sich für Präzision interessieren, sollten Sie vorsichtig mit den Einschränkungen der schwimmenden Punktzahlen achten.
Die Lösung besteht darin, die schwimmenden Punktvorgänge in ganzzahlige Operationen umzuwandeln.
(10+20) +30; // 60
10+ (20+30); // 60
Teilen Sie dann den Vergrößerungsfaktor. Beachten Sie, dass der Ganzzahlbereich innerhalb von -253 ~ 253 liegen sollte.
Zusammenfassen
1. Die Zahlen von JS sind doppelte Precision-Schwimmpunktzahlen
2. Die Ganzzahl von JS ist nur eine Teilmenge von Gleitkomma-Zahlen doppelter Präzision, kein einzelner Typ
3. Bit Operation behandelt Zahlen als signierte Ganzzahlen von 32 Bits
V.
Der obige Artikel, der in JavaScript ausführlich Verständnis für schwimmende Punktzahlen ist, ist der gesamte Inhalt, den ich mit Ihnen geteilt habe. Ich hoffe, es kann Ihnen eine Referenz geben und ich hoffe, Sie können Wulin.com mehr unterstützen.