Math-FunktionenMath-Funktionen Number-EigenschaftenMath-MethodenNumber.parseInt() und die neuen Ganzzahl-LiteraleNumber-EigenschaftenNumber.EPSILONNumber.isInteger(number)Math-FunktionalitätSie können jetzt Ganzzahlen in binärer und oktaler Notation angeben
Number-Eigenschaften Das globale Objekt Number hat einige neue Eigenschaften erhalten
Number.EPSILON zum Vergleichen von Fließkommazahlen mit einer Toleranz für Rundungsfehler.Number.isInteger(num) prüft, ob num eine Ganzzahl ist (eine Zahl ohne Dezimalbruch)Number.isSafeInteger(number)Number.MIN_SAFE_INTEGERNumber.MAX_SAFE_INTEGERNumber.isNaN(num) prüft, ob num der Wert NaN ist. Im Gegensatz zur globalen Funktion isNaN() erzwingt sie keine Typumwandlung ihres Arguments in eine Zahl und ist daher sicherer für Nicht-Zahlen.Number sind weitgehend äquivalent zu den globalen Funktionen mit denselben Namen: Number.isFinite, Number.parseFloat, Number.parseInt.Math-Methoden Das globale Objekt Math hat neue Methoden für numerische, trigonometrische und bitweise Operationen. Sehen wir uns vier Beispiele an.
Math.sign() gibt das Vorzeichen einer Zahl zurück
Math.trunc() entfernt den Dezimalbruch einer Zahl
Math.log10() berechnet den Logarithmus zur Basis 10
Math.hypot() berechnet die Quadratwurzel der Summe der Quadrate seiner Argumente (Satz des Pythagoras)
ECMAScript 5 hat bereits Literale für hexadezimale Ganzzahlen
ECMAScript 6 bringt zwei neue Arten von Ganzzahl-Literalen
0b oder 0B0o oder 0O (das ist eine Null gefolgt vom Großbuchstaben O; die erste Variante ist sicherer)Denken Sie daran, dass die Methode Number.toString(radix) verwendet werden kann, um Zahlen in einer anderen Basis als 10 anzuzeigen
(Die doppelten Punkte sind notwendig, damit der Punkt für den Eigenschaftszugriff nicht mit einem Dezimalpunkt verwechselt wird.)
Im Node.js Dateisystemmodul haben mehrere Funktionen den Parameter mode. Sein Wert wird verwendet, um Dateiberechtigungen anzugeben, über eine Kodierung, die ein Überbleibsel von Unix ist.
Das bedeutet, dass Berechtigungen durch 9 Bits dargestellt werden können (3 Kategorien mit je 3 Berechtigungen)
| Benutzer | Gruppe | Alle | |
|---|---|---|---|
| Berechtigungen | r, w, x | r, w, x | r, w, x |
| Bit | 8, 7, 6 | 5, 4, 3 | 2, 1, 0 |
Die Berechtigungen einer einzelnen Benutzerkategorie werden in 3 Bits gespeichert
| Bits | Berechtigungen | Oktale Ziffer |
|---|---|---|
| 000 | ––– | 0 |
| 001 | ––x | 1 |
| 010 | –w– | 2 |
| 011 | –wx | 3 |
| 100 | r–– | 4 |
| 101 | r–x | 5 |
| 110 | rw– | 6 |
| 111 | rwx | 7 |
Das bedeutet, dass Oktalzahlen eine kompakte Darstellung aller Berechtigungen sind, Sie benötigen nur 3 Ziffern, eine Ziffer pro Benutzerkategorie. Zwei Beispiele
Number.parseInt() und die neuen Ganzzahl-Literale Number.parseInt() (das dasselbe tut wie die globale Funktion parseInt()) hat die folgende Signatur
Number.parseInt(string, radix?)
Number.parseInt(): Hexadezimale Zahlen-Literale Number.parseInt() bietet spezielle Unterstützung für die hexadezimale Literalnotation – das Präfix 0x (oder 0X) von string wird entfernt, wenn
radix fehlt oder 0 ist. Dann wird radix auf 16 gesetzt. In der Regel sollten Sie radix niemals weglassen.radix 16 ist.Zum Beispiel
In allen anderen Fällen werden Ziffern nur bis zur ersten Nicht-Ziffer geparst
Number.parseInt(): Binäre und Oktale Zahlen-Literale Allerdings hat Number.parseInt() keine spezielle Unterstützung für binäre oder oktale Literale!
Wenn Sie diese Arten von Literalen parsen möchten, müssen Sie Number() verwenden.
Number.parseInt() funktioniert gut mit Zahlen, die eine andere Basis haben, solange kein spezielles Präfix vorhanden ist und der Parameter radix angegeben ist.
Number-Eigenschaften Dieser Abschnitt beschreibt neue Eigenschaften, die der Konstruktor Number in ECMAScript 6 erhalten hat.
Vier zahlenbezogene Funktionen sind bereits als globale Funktionen verfügbar und wurden Number als Methoden hinzugefügt: isFinite und isNaN, parseFloat und parseInt. Alle funktionieren fast genauso wie ihre globalen Gegenstücke, aber isFinite und isNaN erzwingen keine Typumwandlung ihrer Argumente mehr, was besonders wichtig für isNaN ist. Die folgenden Unterabschnitte erklären alle Details.
Number.isFinite(number) Number.isFinite(number) bestimmt, ob number eine tatsächliche Zahl ist (weder Infinity noch -Infinity noch NaN).
Der Vorteil dieser Methode ist, dass sie ihren Parameter nicht in eine Zahl umwandelt (während die globale Funktion dies tut).
Number.isNaN(number) Number.isNaN(number) prüft, ob number der Wert NaN ist.
Eine ES5-Möglichkeit, diese Prüfung durchzuführen, ist über !==.
Eine aussagekräftigere Methode ist die globale Funktion isNaN().
Diese Funktion wandelt jedoch Nicht-Zahlen in Zahlen um und gibt true zurück, wenn das Ergebnis NaN ist (was normalerweise nicht erwünscht ist).
Die neue Methode Number.isNaN() weist dieses Problem nicht auf, da sie ihre Argumente nicht in Zahlen umwandelt.
Number.parseFloat und Number.parseInt Die folgenden beiden Methoden funktionieren exakt wie die globalen Funktionen mit denselben Namen. Sie wurden aus Vollständigkeitsgründen zu Number hinzugefügt; jetzt sind alle zahlenbezogenen Funktionen dort verfügbar.
Number.EPSILON Besonders bei Dezimalbrüchen können Rundungsfehler in JavaScript zu einem Problem werden3. Zum Beispiel können 0.1 und 0.2 nicht präzise dargestellt werden, was Sie bemerken, wenn Sie sie addieren und mit 0.3 vergleichen (das ebenfalls nicht präzise dargestellt werden kann).
Number.EPSILON gibt eine angemessene Fehlertoleranz beim Vergleichen von Fließkommazahlen an. Es bietet eine bessere Möglichkeit, Fließkommawerte zu vergleichen, wie die folgende Funktion zeigt.
function epsEqu(x, y) {
return Math.abs(x - y) < Number.EPSILON;
}
console.log(epsEqu(0.1+0.2, 0.3)); // true
Number.isInteger(number) JavaScript hat nur Fließkommazahlen (Doubles). Dementsprechend sind Ganzzahlen einfach Fließkommazahlen ohne Dezimalbruch.
Number.isInteger(number) gibt true zurück, wenn number eine Zahl ist und keinen Dezimalbruch hat.
JavaScript-Zahlen haben nur genügend Speicherplatz, um 53-Bit-Ganzzahlen mit Vorzeichen darzustellen. Das heißt, Ganzzahlen i im Bereich −253 < i < 253 sind sicher. Was genau das bedeutet, wird gleich erklärt. Die folgenden Eigenschaften helfen dabei, festzustellen, ob eine JavaScript-Ganzzahl sicher ist.
Number.isSafeInteger(number)Number.MIN_SAFE_INTEGERNumber.MAX_SAFE_INTEGERDie Vorstellung von sicheren Ganzzahlen konzentriert sich darauf, wie mathematische Ganzzahlen in JavaScript dargestellt werden. Im Bereich (−253, 253) (ohne die untere und obere Grenze) sind JavaScript-Ganzzahlen sicher: Es gibt eine Eins-zu-eins-Zuordnung zwischen ihnen und den mathematischen Ganzzahlen, die sie darstellen.
Außerhalb dieses Bereichs sind JavaScript-Ganzzahlen unsicher: Zwei oder mehr mathematische Ganzzahlen werden als dieselbe JavaScript-Ganzzahl dargestellt. Beispielsweise kann JavaScript ab 253 nur jede zweite mathematische Ganzzahl darstellen.
Daher ist eine sichere JavaScript-Ganzzahl eine, die eindeutig eine einzelne mathematische Ganzzahl darstellt.
Number-Eigenschaften für sichere Ganzzahlen Die beiden statischen Number-Eigenschaften, die die untere und obere Grenze sicherer Ganzzahlen angeben, könnten wie folgt definiert werden.
Number.MAX_SAFE_INTEGER = Math.pow(2, 53)-1;
Number.MIN_SAFE_INTEGER = -Number.MAX_SAFE_INTEGER;
Number.isSafeInteger() bestimmt, ob eine JavaScript-Zahl eine sichere Ganzzahl ist, und könnte wie folgt definiert werden.
Number.isSafeInteger = function (n) {
return (typeof n === 'number' &&
Math.round(n) === n &&
Number.MIN_SAFE_INTEGER <= n &&
n <= Number.MAX_SAFE_INTEGER);
}
Für einen gegebenen Wert n prüft diese Funktion zuerst, ob n eine Zahl und eine Ganzzahl ist. Wenn beide Prüfungen erfolgreich sind, ist n sicher, wenn es größer oder gleich MIN_SAFE_INTEGER und kleiner oder gleich MAX_SAFE_INTEGER ist.
Wie können wir sicherstellen, dass die Ergebnisse von Berechnungen mit Ganzzahlen korrekt sind? Beispielsweise ist das folgende Ergebnis eindeutig nicht korrekt.
Wir haben zwei sichere Operanden, aber ein unsicheres Ergebnis.
Das folgende Ergebnis ist ebenfalls falsch.
Dieses Mal ist das Ergebnis sicher, aber einer der Operanden ist es nicht.
Daher ist das Ergebnis der Anwendung eines Ganzzahloperators op nur dann garantiert korrekt, wenn alle Operanden und das Ergebnis sicher sind. Formeller ausgedrückt:
isSafeInteger(a) && isSafeInteger(b) && isSafeInteger(a op b)
impliziert, dass a op b ein korrektes Ergebnis ist.
Math-Funktionalität Das globale Objekt Math hat in ECMAScript 6 mehrere neue Methoden.
Math.sign(x) Math.sign(x) gibt zurück
-1, wenn x eine negative Zahl ist (einschließlich -Infinity).0, wenn x Null ist4.+1, wenn x eine positive Zahl ist (einschließlich Infinity).NaN, wenn x NaN oder keine Zahl ist.Beispiele
Math.trunc(x) Math.trunc(x) entfernt den Dezimalbruch von x. Ergänzt die anderen Rundungsmethoden Math.floor(), Math.ceil() und Math.round().
Sie könnten Math.trunc() wie folgt implementieren.
function trunc(x) {
return Math.sign(x) * Math.floor(Math.abs(x));
}
Math.cbrt(x) Math.cbrt(x) gibt die Kubikwurzel von x (∛x) zurück.
Ein kleiner Bruch kann genauer dargestellt werden, wenn er nach der Null kommt. Ich werde dies mit Dezimalbrüchen demonstrieren (JavaScript-Zahlen werden intern mit Basis 2 gespeichert, aber die gleiche Logik gilt auch dort).
Fließkommazahlen mit Basis 10 werden intern als Mantisse × 10Exponent dargestellt. Die Mantisse hat eine einzelne Ziffer vor dem Dezimalpunkt und der Exponent "verschiebt" den Punkt bei Bedarf. Das bedeutet, wenn Sie einen kleinen Bruch in die interne Darstellung umwandeln, führt eine Null vor dem Punkt zu einer kleineren Mantisse als eine Eins vor dem Punkt. Zum Beispiel:
Was die Genauigkeit betrifft, so ist die hier wichtige Größe die Kapazität der Mantisse, gemessen in signifikanten Ziffern. Deshalb bietet (A) eine höhere Genauigkeit als (B).
Darüber hinaus stellt JavaScript Zahlen nahe Null (z. B. kleine Brüche) mit höherer Genauigkeit dar.
Math.expm1(x) Math.expm1(x) gibt Math.exp(x)-1 zurück. Die Umkehrfunktion von Math.log1p().
Daher bietet diese Methode eine höhere Genauigkeit, wenn Math.exp() Ergebnisse nahe 1 hat. Den Unterschied zwischen beiden können Sie in der folgenden Interaktion sehen.
Das erstere ist das bessere Ergebnis, was Sie durch die Verwendung einer Bibliothek (wie z. B. decimal.js) für Fließkommazahlen mit beliebiger Genauigkeit ("Bigfloats") verifizieren können.
> var Decimal = require('decimal.js').config({precision:50});
> new Decimal(1e-10).exp().minus(1).toString()
'1.000000000050000000001666666666708333333e-10'
Math.log1p(x) Math.log1p(x) gibt Math.log(1 + x) zurück. Die Umkehrfunktion von Math.expm1().
Daher können Sie mit dieser Methode Parameter angeben, die nahe 1 liegen, mit höherer Genauigkeit. Die folgenden Beispiele zeigen, warum das so ist.
Die folgenden beiden Aufrufe von log() ergeben dasselbe Ergebnis.
Im Gegensatz dazu liefert log1p() unterschiedliche Ergebnisse.
Der Grund für die höhere Genauigkeit von Math.log1p() ist, dass das korrekte Ergebnis für 1 + 1e-16 mehr signifikante Ziffern hat als 1e-16.
Math.log2(x) Math.log2(x) berechnet den Logarithmus zur Basis 2.
Math.log10(x) Math.log10(x) berechnet den Logarithmus zur Basis 10.
Emscripten war Vorreiter bei einem Programmierstil, der später von asm.js übernommen wurde: Die Operationen einer virtuellen Maschine (denken Sie an Bytecode) werden in einer statischen Teilmenge von JavaScript ausgedrückt. Diese Teilmenge kann von JavaScript-Engines effizient ausgeführt werden: Wenn sie das Ergebnis einer Kompilierung aus C++ ist, läuft sie mit etwa 70 % der nativen Geschwindigkeit.
Die folgenden Math-Methoden wurden hauptsächlich zur Unterstützung von asm.js und ähnlichen Kompilierungsstrategien hinzugefügt, sie sind für andere Anwendungen weniger nützlich.
Math.fround(x) Math.fround(x) rundet x auf einen 32-Bit-Fließkommawert (float). Wird von asm.js verwendet, um eine Engine anzuweisen, intern einen float-Wert zu verwenden.
Math.imul(x, y) Math.imul(x, y) multipliziert die beiden 32-Bit-Ganzzahlen x und y und gibt die unteren 32 Bits des Ergebnisses zurück. Dies ist die einzige 32-Bit-Grundrechenart, die nicht durch die Verwendung eines JavaScript-Operators und die Umwandlung des Ergebnisses zurück in 32 Bits simuliert werden kann. Beispielsweise könnte idiv wie folgt implementiert werden.
function idiv(x, y) {
return (x / y) | 0;
}
Im Gegensatz dazu kann die Multiplikation zweier großer 32-Bit-Ganzzahlen eine Zahl ergeben, die so groß ist, dass untere Bits verloren gehen.
Math.clz32(x)x.Warum ist das interessant? Zitat aus „Fast, Deterministic, and Portable Counting Leading Zeros“ von Miro Samek.
Das Zählen führender Nullen in einer Ganzzahl ist eine kritische Operation in vielen DSP-Algorithmen, wie z. B. der Normalisierung von Samples in der Audio- oder Videoverarbeitung, sowie in Echtzeitplanern, um schnell die Task mit der höchsten Priorität zu finden, die bereit zum Ausführen ist.
Math.sinh(x)x.Math.cosh(x)x.Math.tanh(x)x.Math.asinh(x)x.Math.acosh(x)x.Math.atanh(x)x.Math.hypot(...values)JavaScript-Ganzzahlen haben einen Bereich von 53 Bits. Das ist ein Problem, wenn 64-Bit-Ganzzahlen benötigt werden. Zum Beispiel: In seiner JSON-API musste Twitter von Ganzzahlen zu Strings wechseln, als Tweet-IDs zu groß wurden.
Derzeit gibt es keine Möglichkeit, diese Einschränkung zu umgehen, außer eine Bibliothek für höhere Genauigkeitszahlen (BigInts oder BigFloats) zu verwenden. Eine solche Bibliothek ist decimal.js.
Es gibt Pläne, größere Ganzzahlen in JavaScript zu unterstützen, aber die Umsetzung könnte noch einige Zeit dauern.