Читать книгу JavaScript – Das Handbuch für die Praxis - David Flanagan - Страница 35

JavaScript-Programme rechnen mit Zahlen mittels der arithmetischen Operatoren, die JavaScript bereitstellt. Zu diesen Operatoren gehören + für Addition, - für Subtraktion, * für Multiplikation, / für Division und % für Modulo (Rest nach Division). In ES2016 kam ** für die Potenzierung hinzu. Vollständige Angaben zu diesen und weiteren Operatoren finden Sie in Kapitel 4.

Neben diesen elementaren arithmetischen Operatoren unterstützt JavaScript komplexere mathematische Operationen mithilfe der Funktionen und Konstanten, die als Eigenschaften des Math-Objekts definiert sind:

Math.pow(2,53) // => 9007199254740992: 2 hoch 53.

Math.round(.6) // => 1.0: Auf die nächste ganze Zahl runden.

Math.ceil(.6) // => 1.0: Auf die nächste ganze Zahl aufrunden.

Math.floor(.6) // => 0.0: Auf die nächste ganze Zahl abrunden.

Math.abs(-5) // => 5: Absolutwert.

Math.max(x,y,z) // Das größte der Argumente ermitteln.

Math.min(x,y,z) // Das kleinste der Argumente ermitteln.

Math.random() // Pseudozufallszahl, für deren Wert 0 <= x < 1.0 gilt.

Math.PI // π: Kreisumfang / Kreisdurchmesser.

Math.E // e: Die Basis des natürlichen Logarithmus.

Math.sqrt(3) // => 3**0.5: Die Quadratwurzel von 3.

Math.pow(3, 1/3) // => 3**(1/3): Die Kubikwurzel von 3.

Math.sin(0) // Trigonometrie: auch Math.cos, Math.atan usw.

Math.log(10) // Natürlicher Logarithmus von 10.

Math.log(100)/Math.LN10 // Logarithmus zur Basis 10 von 100.

Math.log(512)/Math.LN2 // Logarithmus zur Basis 2 von 512.

Math.exp(3) // Math.E hoch 3.

ES6 definiert weitere Funktionen auf dem Math-Objekt:

Math.cbrt(27) // => 3: Kubikwurzel.

Math.hypot(3, 4) // => 5: Quadratwurzel der Summe der Quadrate aller Argumente.

Math.log10(100) // => 2: Logarithmus zur Basis 10.

Math.log2(1024) // => 10: Logarithmus zur Basis 2.

Math.log1p(x) // Natürlicher Logarithmus von (1+x), genau für sehr kleine x.

Math.expm1(x) // Math.exp(x)-1, die Umkehrung von Math.log1p().

Math.sign(x) // -1, 0 oder 1 für Argumente <, == oder > 0.

Math.imul(2,3) // => 6: Optimierte Multiplikation von 32-Bit-Ganzzahlen.

Math.clz32(0xf) // => 28: Anzahl der führenden Nullbits in einer 32-Bit-Ganzzahl.

Math.trunc(3.9) // => 3: Konvertierung in eine Ganzzahl, indem der Nachkommateil

// abgeschnitten wird.

Math.fround(x) // Auf die nächste 32-Bit-Gleitkommazahl runden.

Math.sinh(x) // Hyperbolischer Sinus. Auch Math.cosh(), Math.tanh().

Math.asinh(x) // Hyperbolischer Arkussinus. Auch Math.acosh(), Math.atanh().

In JavaScript lösen arithmetische Operationen keine Fehler aus, wenn es zu Wertüberläufen, -unterläufen oder einer Division durch null kommt. Ist das Ergebnis einer numerischen Operation größer als die größte darstellbare Zahl (Überlauf), ist das Ergebnis ein spezieller Wert für unendlich, den JavaScript als Infinity ausgibt. Analog ergibt sich eine negative Unendlichkeit -Infinity, wenn der absolute Betrag (also der vorzeichenlose Wert) eines negativen Werts größer wird als der absolute Betrag der größten darstellbaren negativen Zahl. Unendliche Werte verhalten sich wie erwartet: Additions-, Subtraktions-, Multiplikations- und Divisionsoperationen auf einem unendlichen Wert liefern als Ergebnis wieder einen unendlichen Wert (gegebenenfalls mit umgekehrtem Vorzeichen).

Ein Unterlauf tritt ein, wenn das Ergebnis einer numerischen Operation näher an null liegt als die kleinste darstellbare Zahl. In diesem Fall liefert JavaScript 0 zurück. Tritt der Unterlauf bei einer negativen Zahl auf, liefert JavaScript einen speziellen Wert zurück, der als negative Null bezeichnet wird. Dieser Wert ist beinahe vollständig mit dem gewöhnlichen Nullwert identisch, und JavaScript-Programmierer müssen ihn nur äußerst selten gesondert behandeln.

Eine Division durch null löst in JavaScript keinen Fehler aus – sie liefert einfach unendlich oder negativ unendlich zurück. Es gibt allerdings eine Ausnahme: Null geteilt durch null hat keinen wohldefinierten Wert – das Ergebnis dieser Operation ist ein spezieller »Keine-Zahl«-Wert, der als NaN (kurz für Not-a-Number) ausgegeben wird. NaN ist auch das Ergebnis, wenn Sie versuchen, unendlich durch unendlich zu teilen, die Quadratwurzel einer negativen Zahl zu ermitteln oder arithmetische Operatoren auf nicht numerischen Operanden zu nutzen, die sich nicht in Zahlen umwandeln lassen.

JavaScript definiert die globalen Konstanten Infinity und NaN so, dass sie den positiven Unendlichkeits- bzw. den Not-a-Number-Wert enthalten, und diese Werte sind auch als Eigenschaften des Number-Objekts verfügbar:

Infinity // Eine positive Zahl, die zu groß ist,

// um sie darzustellen.

Number.POSITIVE_INFINITY // Der gleiche Wert.

1/0 // => Infinity.

Number.MAX_VALUE * 2 // => Infinity; Überlauf.

-Infinity // Eine negative Zahl, die zu groß ist,

// um sie darzustellen.

Number.NEGATIVE_INFINITY // Der gleiche Wert.

-1/0 // => -Infinity.

-Number.MAX_VALUE * 2 // => -Infinity.

NaN // Der Not-a-Number-Wert.

Number.NaN // Der gleiche Wert, anders geschrieben.

0/0 // => NaN.

Infinity/Infinity // => NaN.

Number.MIN_VALUE/2 // => 0: Unterlauf.

-Number.MIN_VALUE/2 // => -0: Negative Null.

-1/Infinity // -> -0: Ebenfalls negative Null.

-0

// Die folgenden Eigenschaften des Number-Datentyps sind in ES6 definiert.

Number.parseInt() // Dasselbe wie die globale parseInt()-Funktion.

Number.parseFloat() // Dasselbe wie die globale parseFloat()-Funktion.

Number.isNaN(x) // Ist x der NaN-Wert?

Number.isFinite(x) // Ist x eine Zahl und endlich?

Number.isInteger(x) // Ist x eine Ganzzahl?

Number.isSafeInteger(x) // Ist x eine Ganzzahl -(2**53) < x < 2**53?

Number.MIN_SAFE_INTEGER // => -(2**53 - 1)

Number.MAX_SAFE_INTEGER // => 2**53 - 1

Number.EPSILON // => 2**-52: Kleinste Differenz zwischen Zahlen.

NaN hat in JavaScript eine ungewöhnliche Eigenschaft: Dieser Wert ist keinem anderen Wert gleich, nicht einmal sich selbst. Das heißt, Sie können nicht x === NaN benutzen, um zu prüfen, ob der Wert einer Variablen x gleich NaN ist. Stattdessen müssen Sie x != x oder Number.isNaN(x) schreiben. Diese Ausdrücke sind wahr, wenn – und nur, wenn – x den gleichen Wert wie die globale Konstante NaN hat.

Die globale Funktion isNaN() ähnelt Number.isNaN(). Sie liefert true, wenn ihr Argument NaN ist oder ein nicht numerischer Wert, der nicht in einen numerischen Wert umgewandelt werden kann. Die verwandte Funktion Number.isFinite() liefert true, wenn ihr Argument eine Zahl ungleich NaN, Infinity oder -Infinity ist. Die globale Funktion isFinite() gibt true zurück, wenn ihr Argument eine endliche Zahl ist oder in diese konvertiert werden kann.

Der negative Nullwert ist ebenfalls etwas ungewöhnlich. Er wird als gleich (selbst beim strikten Gleichheitstest von JavaScript) mit der positiven Null erkannt, sodass die beiden Werte kaum zu unterscheiden sind, es sei denn, sie werden als Divisor verwendet:

let zero = 0; // Gewöhnliche Null.

let negz = -0; // Negative Null.

zero === negz // => true: Die beiden Nullwerte sind gleich.

1/zero === 1/negz // => false: Infinity und -Infinity sind nicht gleich.