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).
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.
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).
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.
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.
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° 2π = 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.
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.
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