Zahlendarstellung

Neue Notation für binäre Literale: Präfix 0b oder 0B.

console.log(0b11 === 3); // true
console.log(0B11 === 3); // true

Neue Notation für oktale Literale: Präfix 0o oder 0O.

console.log(0o11 === 9); // true
console.log(0O11 === 9); // true

Konstanten

Number.EPSILON

Die Eigenschaft Number.EPSILON repräsentiert die Differenz zwischen 1 und der kleinsten Gleitkommazahl, die größer als 1 ist.

Ihr Wert ist ungefähr 2.2204460492503130808472633361816E-16, oder 2^-52.

Testen Sie, ob eine Zahl innerhalb der Fehlertoleranz liegt:

0.1 + 0.2 === 0.3; // false
// 在误差范围内即视为相等
equal = (Math.abs(0.1 - 0.3 + 0.2) < Number.EPSILON); // true

Eigenschaftsattribute

writable:false
enumerable:false
configurable:false

Maximale / minimale sichere Ganzzahl

Sichere Ganzzahl

Eine sichere Ganzzahl ist eine Ganzzahl, die in JavaScript exakt dargestellt werden kann. Der Bereich sicherer Ganzzahlen reicht vom Negativen von 2 hoch 53 bis 2 hoch 53 (unter Ausschluss beider Endpunkte). Ganzzahlen außerhalb dieses Bereichs können nicht exakt dargestellt werden.

Maximale sichere Ganzzahl

Die Obergrenze des Bereichs sicherer Ganzzahlen, d. h. 2 hoch 53 minus 1.

Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true Number.MAX_SAFE_INTEGER === Number.MAX_SAFE_INTEGER + 1; // false Number.MAX_SAFE_INTEGER - 1 === Number.MAX_SAFE_INTEGER - 2; // false

Minimale sichere Ganzzahl

Die Untergrenze des Bereichs sicherer Ganzzahlen, d. h. das Negative von 2 hoch 53 minus 1.

Number.MIN_SAFE_INTEGER + 1 === Number.MIN_SAFE_INTEGER + 2; // false Number.MIN_SAFE_INTEGER === Number.MIN_SAFE_INTEGER - 1; // false Number.MIN_SAFE_INTEGER - 1 === Number.MIN_SAFE_INTEGER - 2; // true

Eigenschaftsattribute

writable:false
enumerable:false
configurable:false

Methoden

Neue Methoden des Number-Objekts

Number.isFinite()

Wird verwendet, um zu prüfen, ob eine Zahl endlich ist, d. h. nicht Infinity.

console.log( Number.isFinite(1)); // true console.log( Number.isFinite(0.1)); // true //NaN ist nicht endlich. console.log( Number.isFinite(NaN)); // false console.log( Number.isFinite(Infinity)); // false console.log( Number.isFinite(-Infinity)); // false //Number.isFinate führt keine implizite Number()-Typkonvertierung durch; es gibt für alle Nicht-Number-Werte false zurück. console.log( Number.isFinite('foo')); // false console.log( Number.isFinite('15')); // false console.log( Number.isFinite(true)); // false Number.isNaN()Wird verwendet, um zu prüfen, ob ein WertNaN 。 console.log(Number.isNaN(NaN)); // true console.log(Number.isNaN('true'/0)); // true //In der globalen isNaN() geben alle folgenden true zurück, da Nicht-Zahlen-Werte vor der Prüfung in Zahlen umgewandelt werden. //Number.isNaN() führt jedoch keine implizite Number()-Typkonvertierung durch; alle Werte, die nicht NaN sind, geben false zurück. Number.isNaN("NaN"); // false Number.isNaN(undefined); // false Number.isNaN({}); // false Number.isNaN("true"); // false

Vom globalen Objekt auf das Number-Objekt portierte Methoden

Schrittweise Reduzierung globaler Methoden zur Modularisierung globaler Variablen.

Das Verhalten der Methoden hat sich nicht geändert.

Number.parseInt()

Wird verwendet, um eine gegebene Zeichenkette in eine ganze Zahl mit einer angegebenen Basis umzuwandeln.

//Wenn keine Basis angegeben wird, wird standardmäßig Basis 10 verwendet. Number.parseInt('12.34'); // 12 Number.parseInt(12.34); // 12 //Festlegen einer Basis Number.parseInt('0011',2); // 3 //Es ist dieselbe Funktion wie die globale Funktion parseInt(). Number.parseInt === parseInt; // true Number.parseFloat()Wird verwendet, um eine Zeichenkette in eine Gleitkommazahl zu parsen.Number.parseFloat('123.45') // 123.45 Number.parseFloat('123.45abc') // 123.45 //Wenn es nicht als Gleitkommazahl geparst werden kann, wird NaN zurückgegeben. Number.parseFloat('abc') // NaN //Es ist dieselbe Methode wie die globale Methode parseFloat(). Number.parseFloat === parseFloat // true Number.isInteger()Wird verwendet, um festzustellen, ob das angegebene Argument eine ganze Zahl ist.Number.isInteger(value) Number.isInteger(0); // true //Intern verwendet JavaScript dieselbe Speichermethode für ganze Zahlen und Gleitkommazahlen, daher werden 1 und 1.0 als derselbe Wert behandelt. Number.isInteger(1); // true Number.isInteger(1.0); // true Number.isInteger(1.1); // false Number.isInteger(Math.PI); // false //NaN und positiv/negativ Infinity sind keine ganzen Zahlen. Number.isInteger(NaN); // false Number.isInteger(Infinity); // false Number.isInteger(-Infinity); // false Number.isInteger("10"); // false Number.isInteger(true); // false Number.isInteger(false); // false Number.isInteger([1]); // false //Wenn die Präzision einer Zahl 53 Binärbits überschreitet, werden das 54. und alle nachfolgenden Bits verworfen, was zu einer Fehlbeurteilung führen kann. Number.isInteger(1.0000000000000001) // true //Wenn der Absolutwert einer Zahl kleiner als Number.MIN_VALUE (5E-324) ist, d. h. kleiner als der kleinste Wert, den JavaScript unterscheiden kann, //wird die Zahl automatisch in 0 umgewandelt, was ebenfalls zu einer Fehlbeurteilung führt. Number.isInteger(5E-324); // false Number.isInteger(5E-325); // true Number.isSafeInteger()Wird verwendet, um zu bestimmen, ob eine Zahl innerhalb des sicheren Bereichs liegt.Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1); // false Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1); // false

Erweiterungen des Math-Objekts

ES6 hat 17 mathematische statische Methoden zum Math-Objekt hinzugefügt; diese Methoden können nur auf Math aufgerufen werden.

Grundlegende Berechnungen

Math.cbrt

Wird verwendet, um die Kubikwurzel einer Zahl zu berechnen.

Math.cbrt(1); // 1 Math.cbrt(0); // 0 Math.cbrt(-1); // -1 //Es wandelt Nicht-Zahlenwerte um. Math.cbrt('1'); // 1 //Gibt NaN für Nicht-Zahlenwerte zurück, die nicht in Zahlen umgewandelt werden können. Math.cbrt('hhh'); // NaN
Math.imul

Das Ergebnis der Multiplikation zweier Zahlen als 32-Bit-Ganzzahlen mit Vorzeichen; der Rückgabewert ist ebenfalls eine 32-Bit-Ganzzahl mit Vorzeichen.

//In den meisten Fällen ist das Ergebnis dasselbe wie a * b. Math.imul(1, 2); // 2 //Wird verwendet, um den niederwertigen Wert im Multiplikationsergebnis großer Zahlen korrekt zurückzugeben. Math.imul(0x7fffffff, 0x7fffffff); // 1
Math.hypot

Wird verwendet, um die Quadratwurzel der Summe der Quadrate aller Argumente zu berechnen.

Math.hypot(3, 4); // 5 //Nicht-Zahlenwerte werden vor der Berechnung zuerst in Zahlen umgewandelt. Math.hypot(1, 2, '3'); // 3.741657386773941 Math.hypot(true); // 1 Math.hypot(false); // 0 //Leere Werte werden in 0 umgewandelt. Math.hypot(); // 0 Math.hypot([]); // 0 //Gibt Infinity zurück, wenn ein Argument Infinity oder -Infinity ist. Math.hypot(Infinity); // Infinity Math.hypot(-Infinity); // Infinity //Gibt NaN zurück, wenn ein Argument nicht in eine Zahl umgewandelt werden kann. Math.hypot(NaN); // NaN Math.hypot(3, 4, 'foo'); // NaN Math.hypot({}); // NaN
Math.clz32

Wird verwendet, um die Anzahl der führenden Nullbits in der 32-Bit-Darstellung einer Zahl als vorzeichenlose Ganzzahl zurückzugeben.

Math.clz32(0); // 32 Math.clz32(1); // 31 Math.clz32(0b01000000000100000000000000000000); // 1 //Wenn das Argument eine Dezimalzahl ist, wird nur der ganzzahlige Teil berücksichtigt. Math.clz32(0.5); // 32 //Für leere Werte oder Werte, die keine Zahlen sind, werden diese vor der Berechnung in Zahlen umgewandelt. Math.clz32('1'); // 31 Math.clz32(); // 32 Math.clz32([]); // 32 Math.clz32({}); // 32 Math.clz32(NaN); // 32 Math.clz32(Infinity); // 32 Math.clz32(-Infinity); // 32 Math.clz32(undefined); // 32 Math.clz32('hhh'); // 32

Zahlenverarbeitung

Math.trunc

Wird verwendet, um den ganzzahligen Teil einer Zahl zurückzugeben.

Math.trunc(12.3); // 12 Math.trunc(12); // 12 //Selbst wenn der ganzzahlige Teil 0 ist, wird das Vorzeichen trotzdem ermittelt. Math.trunc(-0.5); // -0 Math.trunc(0.5); // 0 //Math.trunc wandelt Werte, die keine Zahlen sind, vor der Verarbeitung in Zahlen um. Math.trunc("12.3"); // 12 //Gibt NaN für leere Werte zurück oder wenn die Umwandlung in eine Zahl nicht möglich ist. Math.trunc(); // NaN Math.trunc(NaN); // NaN Math.trunc("hhh"); // NaN Math.trunc("123.2hhh"); // NaN
Math.fround

Wird verwendet, um die 32-Bit-Gleitkommadarstellung mit einfacher Genauigkeit einer Zahl zu erhalten.

//Für ganze Zahlen zwischen dem Negativen von 2 hoch 24 und 2 hoch 24 (unter Ausschluss beider Endpunkte) ist das zurückgegebene Ergebnis identisch mit dem Argument. Math.fround(-(2**24)+1); // -16777215 Math.fround(2 ** 24 - 1); // 16777215 //Wird verwendet, um eine 64-Bit-Gleitkommazahl mit doppelter Genauigkeit in eine 32-Bit-Gleitkommazahl mit einfacher Genauigkeit umzuwandeln. Math.fround(1.234) // 1.125 //Wenn die Genauigkeit einer Dezimalzahl 24 Binärbits überschreitet, geht Genauigkeit verloren. Math.fround(0.3); // 0.30000001192092896 //Gibt das Argument selbst zurück, wenn es NaN oder Infinity ist. Math.fround(NaN) // NaN Math.fround(Infinity) // Infinity //Wenn das Argument einen anderen Nicht-Zahl-Typ hat, wird es umgewandelt. Math.fround('5'); // 5 Math.fround(true); // 1 Math.fround(null); // 0 Math.fround([]); // 0 Math.fround({}); // NaN

Vorzeichenbestimmung

Math.sign

Bestimmt das Vorzeichen einer Zahl (positiv, negativ oder null).

Math.sign(1); // 1 Math.sign(-1); // -1 //Wenn das Argument 0 ist, liefern unterschiedliche Vorzeichen unterschiedliche Ergebnisse. Math.sign(0); // 0 Math.sign(-0); // -0 //Nicht-Zahlen-Werte werden vor der Prüfung konvertiert. Math.sign('1'); // 1 Math.sign('-1'); // -1 //Gibt NaN zurück, wenn das Argument ein Nicht-Zahlen-Wert ist (der nicht in eine Zahl umgewandelt werden kann). Math.sign(NaN); // NaN Math.sign('hhh'); // NaN

Logarithmus-Methoden

Math.expm1()

Wird verwendet, um e hoch x minus 1 zu berechnen, d. h. Math.exp(x) - 1.

Math.expm1(1); // 1.718281828459045 Math.expm1(0); // 0 Math.expm1(-1); // -0.6321205588285577 //Es konvertiert Nicht-Zahlen-Werte. Math.expm1('0'); //0 //Gibt NaN zurück, wenn das Argument keine Zahl ist und nicht in eine Zahl umgewandelt werden kann. Math.expm1(NaN); // NaN
Math.log1p(x)

Wird verwendet, um den natürlichen Logarithmus von 1 + x zu berechnen, d. h. Math.log(1 + x).

Math.log1p(1); // 0.6931471805599453 Math.log1p(0); // 0 Math.log1p(-1); // -Infinity //Gibt NaN zurück, wenn das Argument kleiner als -1 ist. Math.log1p(-2); // NaN
Math.log10(x)

Wird verwendet, um den Logarithmus zur Basis 10 von x zu berechnen.

Math.log10(1); // 0 //Werte, die keine Zahlen sind, werden vor der Berechnung umgewandelt. Math.log10('1'); // 0 //Gibt -Infinity zurück, wenn das Argument 0 ist. Math.log10(0); // -Infinity //Gibt NaN zurück, wenn das Argument kleiner als 0 ist oder wenn das Argument keine Zahl ist (und nicht in eine Zahl umgewandelt werden kann). Math.log10(-1); // NaN
Math.log2()

Wird zur Berechnung des Logarithmus zur Basis 2 von x verwendet.

Math.log2(1); // 0 //Nichtnumerische Werte werden vor der Berechnung umgewandelt. Math.log2('1'); // 0 //Gibt -Infinity zurück, wenn das Argument 0 ist. Math.log2(0); // -Infinity //Gibt NaN zurück, wenn das Argument kleiner als 0 ist oder wenn das Argument keine Zahl ist (und nicht in eine Zahl umgewandelt werden kann). Math.log2(-1); // NaN

Methoden für hyperbolische Funktionen

  • Math.sinh(x): Wird zur Berechnung des hyperbolischen Sinus verwendet.
  • Math.cosh(x): Wird zur Berechnung des hyperbolischen Kosinus verwendet.
  • Math.tanh(x): Wird zur Berechnung des hyperbolischen Tangens verwendet.
  • Math.asinh(x): Wird zur Berechnung des inversen hyperbolischen Sinus verwendet.
  • Math.acosh(x): Wird zur Berechnung des inversen hyperbolischen Kosinus verwendet.
  • Math.atanh(x): Wird zur Berechnung des inversen hyperbolischen Tangens verwendet.

Exponentiationsoperator

1 ** 2; // 1 //Rechtsassoziativ, wird von rechts nach links ausgewertet. 2 ** 2 ** 3; // 256 // **= let exam = 2; exam ** = 2; // 4