Bitte warten...

JavaScript: Numerische Variablen

► JavaScript-Referenz: Operatoren parseInt() parseFloat() toFixed() toString()

Der Zahlenraum von JavaScript liegt (wie bei PHP und Python) etwa zwischen –1.797×10308 und +1.797×10308 (Doppelte Genauigkeit). Zahlen jenseits dieser Grenzen haben den Wert Infinity.

JavaScript unterscheidet nicht zwischen Ganzzahlen und Fließkommazahlen. Sie haben beide den Datentyp number. Zeichenketten, die aus Zahlen bestehen, können auch ohne Umwandlung in eine Zahl verrechnet werden, können aber bei Bedarf mit parseInt() (für Ganzzahlen) bzw. mit parseFloat() (für Fließkommazahlen) umgewandelt werden. Für Rechenoperationen in den Grundrechenarten stehen die üblichen Operatoren +, -, * und / zur Verfügung.

Außerdem existiert der Operator % für den Modulo. Hierbei ist zu beachten, dass es sich – im Gegensatz zu anderen Programmiersprachen wie beispielsweise PHP – um den Rest einer Fließkommadivision handelt. a % b entspricht daher a - b * Math.trunc(a / b).

Weiterhin existieren die Operatoren +=, -=, *=, /= und %= als Kurzschreibweisen, wenn eine Rechenoperation mit nur einer Variable durchgeführt wird.

Zahlen können auch in Exponentialschreibweise (mit kleinem e oder großem E) geschrieben werden.

Mit der Methode toFixed() kann die Anzahl der Nachkomastellen festgelegt werden. Das Ergebnis ist vom Datentyp string.

Mit der Methode toString(bar) kann eine Zahl in ein anderes Zahlensystem mit der Basis bar umgewandelt werden. Das Ergebnis ist vom Datentyp string.

Mit der Methode parseInt(foo, bar) kann eine Zahl foo aus einem Zahlensystem mit der Basis bar wieder in eine Dezimalzahl umgewandelt werden.

Mit dem Operator ++ wird der Wert einer Variable um 1 erhöht (inkrementiert).
Mit dem Operator -- wird der Wert einer Variable um 1 verringert (dekrementiert).

Code kopieren
      a = 100;
      b = 12.5;
      c = "4";
      
      console.log(42e3);  // 42000
      console.log(420000000000000000000000);  // 4.2e+23
      console.log(42E-3);  // 0.042
      console.log(.00000000000000000000042);  // 4.2e-22
      
      console.log(typeof a);  // number
      console.log(typeof b);  // number
      
      console.log(a * c);  // 400
      console.log(Number.parseInt(b));  // 12
      console.log(Number.parseFloat(b));  // 12.5
      
      console.log(a + b);  // 112.5 (Addition)
      console.log(a - b);  // 87.5 (Subtraktion)
      console.log(a * b);  // 1250 (Multiplikation)
      console.log(a / b);  // 8 (Division)
      console.log(a % 8);  // 4 (Modulo)
      
      console.log(b.toFixed(4));  // 12.5000
      
      hex = a.toString(16);  // hexadezimal
      dec = a.toString(10);  // dezimal
      oct = a.toString(8);   // oktal
      bin = a.toString(2);   // binär
      
      console.log(hex);  // 64
      console.log(dec);  // 100
      console.log(oct);  // 144
      console.log(bin);  // 1100100
      
      console.log(Number.parseInt(hex, 16));  // 100
      console.log(Number.parseInt(dec, 10));  // 100
      console.log(Number.parseInt(oct, 8));  // 100
      console.log(Number.parseInt(bin, 2));  // 100
      
      a += 100;  // a = a + 100;
      a -= 20;   // a = a - 20;
      a *= 10;   // a = a * 10;
      a /= 5;    // a = a / 5;
      
      console.log(a);  // 360

      a++;
      console.log(a);  // 361
      a--;
      console.log(a);  // 360

► JavaScript-Referenz: toLocaleString()

Mit der Methode toLocaleString() kann eine Zahl in ein sprachspezifisches Format umgewandelt werden. Wird kein Argument übergeben, so wird die Spracheinstellung des eigenen Systems angenommen. Ansonsten kann ein Sprachcode übergeben werden, um die Sprache für die Formatierung festzulegen (beispielsweise de-DE für Deutsch aus Deutschland oder ar-EG für ägyptisches Arabisch).

Als weiteres Argument kann ein Objekt mit unterschiedlichen Eigenschaften übergeben werden. Im Beispiel etwa style: 'currency' für die Formatierung als Betrag einer Währung oder style: 'percent' für eine Prozentzahl.

Code kopieren
      x = 445356433464.2544534;
      console.log((x).toLocaleString());  // 445.356.433.464,254
      console.log((x).toLocaleString("de-DE", { style: "currency", currency: "EUR" }));  // 445.356.433.464,25 €
      console.log((x).toLocaleString("de-DE", { style: "percent" }));  // 44.535.643.346.425 %
      console.log((x).toLocaleString("ar-EG"));  // ٤٤٥٬٣٥٦٬٤٣٣٬٤٦٤٫٢٥٤

► JavaScript-Referenz: isInteger() isSafeInteger() isFinite() isNaN()

Strings, die eine Zahl enthalten, können auch bei Bedarf sehr einfach in eine echte Zahl mit Dateityp number umgewandelt werden, indem man der zugehörigen Variable ein + voranstellt.

Mit der Methode isIntiger() kann geprüft werden, ob eine Variabel eine Ganzzahl enthält.

Mit der Methode isFinite() kann geprüft werden, ob eine Veriable eine endliche Zahl enthält.

Mit der Methode isNaN() kann geprüft werden, ob eine Variable keine Zahl enthält (Not a Number).

Code kopieren
      a = "42";
      console.log(typeof a);  // string
      a = +a;
      console.log(typeof a);  // number

      console.log(Number.isInteger(25));  // true
      console.log(Number.isInteger(25.1));  // false
      
      console.log(isFinite(25));  // true
      console.log(isFinite(1 / 0));  // false
      
      console.log(isNaN("Hallo"));  // true
      console.log(isNaN("25"));  // false
      console.log(isNaN(25));  // false

► JavaScript-Referenz: round() floor() ceil() abs() sign() trunc() max() min() random()

Weitere mathematische Methoden sind in dem globalen Math-Objekt zu finden. Hier wird nur eine Auswahl der wichtigsten Methoden dargestellt. Eine vollständige Ausgabe aller Methoden und Eigenschaften von Math erhält man mit der Anweisung console.log(Math).

Die Methode round() rundet eine Kommazahl auf den nächsten ganzzahligen Wert.

Die Methode floor() rundet eine Kommazahl auf den nächsten unteren ganzzahligen Wert.

Die Methode ceil() rundet eine Kommazahl auf den nächsten oberen ganzzahligen Wert.

Die Methode abs() entfernt ein negatives Vorzeichen.

Die Methode sign() gibt das Vorzeichen einer Zahl zurück.

Die Methode trunc() gibt eine Zahl ohne Nachkommastellen zurück.

Die Methode max() gibt den höchsten Wert einer Liste zurück.

Die Methode min() gibt den niedrigsten Wert einer Liste zurück.

Die Methode random() gibt eine pseudozufällige Zahl zwischen einschließlich 0 und ausschließlich 1 zurück.

Code kopieren
      console.log(Math.round(12.8));   // 13
      console.log(Math.round(-12.8));  // -13
      
      console.log(Math.floor(12.8));   // 12
      console.log(Math.floor(-12.8));  // -13
      
      console.log(Math.ceil(12.2));   // 13
      console.log(Math.ceil(-12.2));  // -12
      
      console.log(Math.abs(12.8));   // 12.8
      console.log(Math.abs(-12.8));  // 12.8
      
      console.log(Math.sign(12));   // 1
      console.log(Math.sign(0));    // 0
      console.log(Math.sign(-12));  // -1
      
      console.log(Math.trunc(12.8));   // 12
      console.log(Math.trunc(-12.8));  // -12
      
      console.log(Math.max(0, 3, -4));  // 3
      console.log(Math.min(0, 3, -4));  // -4
      console.log(Math.min.apply(null, [0, 3, -4]));  // -4 (bei Arrays)
      
      console.log(Math.random());  // pseudozufällige Zahl 0 <= x < 1
      console.log(Math.floor(Math.random() * 5));  // pseudozufällige Ganzzahl 0 <= x <= 4

► JavaScript-Referenz: pow() sqrt() cbrt()

Die Methode pow(x, y) gibt die Potenz von x mit dem Exponenten y zurück.

Die Methode sqrt(x) gibt die Quadratwurzel von x zurück.

Die Methode cbrt(x) gibt die Kubikwurzel von x zurück.

Code kopieren
      console.log(Math.pow(5, 2));  // 25
      console.log(Math.sqrt(25));  // 5
      
      console.log(Math.pow(4, 3));  // 64
      console.log(Math.cbrt(64));  // 4

► JavaScript-Referenz: Math.PI sin() asin() cos() acos() tan() atan() atan2() hypot()

Für Winkelangaben der trigonometrischen Methoden von JavaScript wird Radiant verwendet, wobei der Vollkreis mit 360° = 6,283185307 rad entspricht. Die Kreiszahl π kann durch die Eigenschaft Math.PI aufgerufen werden. Zur Umrechnung von Grad in Radiant und umgekehrt können die Funktionen deg2rad() bzw. rad2deg() verwendet werden (s. unten).

Die Methode sin(rad) gibt den Sinus von rad zurück.

Die Methode asin(x) gibt den Arkussinus von x in Radiant zurück.

Die Methode cos(rad) gibt den Kosinus von rad zurück.

Die Methode acos(x) gibt den Arkuskosinus von x in Radiant zurück.

Die Methode tan(rad) gibt den Tangens von rad zurück.

Die Methode atan(x) gibt den Arkustangens von x in Radiant zurück.

Die Methode atan2(y, x) gibt den Arkustangens des Quotienten von y und x in Radiant zurück.

Die Methode hypot(x, y) gibt die Hypotenuse der Katheten x und y zurück.

Code kopieren
      function deg2rad(deg) { return deg * Math.PI / 180; }
      function rad2deg(rad) { return rad * 180 / Math.PI; }

      console.log(Math.sin(Math.PI / 2));  // 1
      console.log(Math.asin(1));  // 1.5707963267948966 (= PI / 2)
      
      console.log(Math.cos(Math.PI));  // -1
      console.log(Math.acos(-1));  // 3.141592653589793 (= PI)

      console.log(Math.tan(Math.PI / 4));  // 0.9999999999999999
      console.log(Math.atan(1));  // 0.7853981633974483 (= PI / 4)
      console.log(rad2deg(Math.atan(3 / 4)) + "°");  // 36.86989764584402°
      console.log(rad2deg(Math.atan2(3, 4)) + "°");  // 36.86989764584402°

      console.log(Math.hypot(3, 4));  // 5

► JavaScript-Referenz: sinh() asinh() cosh() acosh() tanh() atanh()

Die Methode sinh(rad) gibt den Sinus hyperbolicus von rad zurück.

Die Methode asinh(x) gibt den Areasinus hyperbolicus von x in Radiant zurück.

Die Methode cosh(rad) gibt den Kosinus hyperbolicus von rad zurück.

Die Methode acosh(x) gibt den Areakosinus hyperbolicus von x in Radiant zurück.

Die Methode tanh(rad) gibt den Tangens hyperbolicus von rad zurück.

Die Methode atanh(x) gibt den Areatangens hyperbolicus von x in Radiant zurück.

Code kopieren
      console.log(Math.sinh(1));  // 1.1752011936438014
      console.log(Math.asinh(1.1752011936438014));  // 1
      
      console.log(Math.cosh(1));  // 1.5430806348152437
      console.log(Math.acosh(1.5430806348152437));  // 1

      console.log(Math.tanh(1));  // 0.7615941559557649
      console.log(Math.atanh(0.7615941559557649));  // 0.9999999999999999