JavaScript – Das Handbuch für die Praxis. David Flanagan

Notation dargestellt werden. Bei dieser Exponentialdarstellung folgen auf eine reelle Zahl der Buchstabe e (oder E), ein optionales Plus- oder Minuszeichen und ein ganzzahliger Exponent. Eine in dieser Schreibweise dargestellte Zahl entspricht der reellen Zahl mal 10 hoch dem Exponenten.

      Kompakter formuliert, sieht diese Syntax so aus:

      [digits][.digits][(E|e)[(+|-)]digits]

      Zum Beispiel:

      3.14

      2345.6789

      .333333333333333333

      6.02e23 // 6.02 × 10²³

      1.4738223E-32 // 1.4738223 × 10^-32

       Trennzeichen in Zahlliteralen

      Sie können in Zahlliteralen Unterstriche verwenden, um lange Literale in besser lesbare Abschnitte zu unterteilen:

      let billion = 1_000_000_000; // Unterstrich als Tausendertrennzeichen.

      let bytes = 0x89_AB_CD_EF; // Als Byte-Trennzeichen.

      let bits = 0b0001_1101_0111; // Als Halbbyte-Trennzeichen.

      let fraction = 0.123_456_789; // Das funktioniert auch im Nachkommateil.

      Anfang 2020, als ich dieses Buch verfasste, waren Unterstriche in Zahlliteralen noch nicht formal als Teil von JavaScript standardisiert. Aber sie befinden sich in einer fortgeschrittenen Phase des Standardisierungsprozesses und werden von allen gängigen Browsern und von Node verstanden.

       3.2.3Arithmetik in JavaScript

      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