Javascript Zahlen: Integer, Float und das Math-Objekt

Javascript Math: Aufrunden, Abrunden, Wurzel, Sinus, Min und Max

In Javascript legen wir Variablen an und weisen ihnen einen numerischen Wert zu. Wer allerdings von einer andere Programmiersprache kommt, fragt sich sofort, ob die Variable ein Integer (ganze Zahl) oder Float (Fließkommazahl) oder ein Large Integer ist.

23-02-02 SITEMAP CSS HTML JS Basis JS Web Tutorial SVG

64-Bit Floating Point

Zahlen sind einfach number in Javascript. In Javascript sind alle Zahlen als 64-Bit Floating Point-Zahlen realisiert, so dass wir uns um die Frage integer oder float nicht kümmern müssen. 12 ist in Javascript dasselbe wie 12.0.

let foo1 = 4; 
let foo2 = 12.8;
console.log (foo1 + foo2);
16.8

Aufgrund der binären Natur können einige dezimale Zahlen nicht akurat dargestellt werden. 1/3 kann nicht als Dezimalzahl mit einer endlichen Zahl von Nachkommastellen ausgedrückt werden. Über die Frage, wieviele Nachkommastellen eine Zahl in Javascript haben kann, entscheidet der Speicher des Systems.

Das Pluszeichen ist in Javascript auch eine Konkatenation: das Pluszeichen verbindet zwei Zeichenketten zu einer neuen Zeichenkette (wie der Punkt in PHP). Sobald ein Operand eine Zeichenkette ist, wird Javascript beide Operanden als Zeichenketten behandeln.

let foo1 = 4;    // numerischer Wert 4
let foo2 = "8"   // Zeichenkette 8
alert (foo1 + foo2)   // gibt die Zeichenkette 48 aus

Mehr zu Fließkommazahlen in Javascript Binary representation of the floating-point numbers

Javascript Number ()

Die Globale Number() versucht, eine Variable oder einen Wert als Zahl zu interpretieren.

  • Ein numerischer String von Zahlen wie 17.4050 wird in die Zahl 17.405 umgewandelt.
  • Ein String wie "Javascript" gibt NaN (not a number) zurück.
  • Ein leerer String "" wird on 0 umgewandelt.

Alle Eingaben in Formularfeldern input type="text" sind für Javascript zunächst einmal Strings, also Zeichenketten. Ob in einem input-Feld 10.4 oder 10 oder 10.0004 – jede Eingabe von input ist für Javascript ein String und keine Zahl. input type="date" hingegen liefert ein Datum.

Bei der Eingabe von Zahlen via input type="text" müssen wir immer mit einem Komma für die Nachkommastellen rechnen. Javascript Number() baut zwar eine Zahl, wenn ein Punkt in den Ziffern sitzt, aber nicht, wenn ein Komma zwischen den Ziffern auftritt.

console.log ("17.4050", Number ("17.4050"));
console.log ("22,99", Number("22,99"));
console.log ("Javascript", Number ("Javascript"));
console.log ("", Number (""));
console.log ("Math.PI", Number (Math.PI));


Javascript isNaN()

Javascript isNaN (is Not a Number) prüft, ob es sich beim Wert einer Variablen um ein Zahl handelt oder nicht.

if (isNaN(foo2)) {
	console.log ("Das ist keine Zahl");
}

Da die Abfrage is NOT a Number lautet, braucht man ein doppelte Verneinung für die direkte Verarbeitung.

Number.isInteger

ES6 hat die Prüfung mitgebracht, ob eine Variable ein Integer ist: Number.isInteger().

const sieben = 7;		
console.log (Number.isInteger(sieben));        // true
console.log (Number.isInteger([10, 25, 30]));  // false

Alle modernen Browser unterstützen Number.isInteger – nicht aber IE11.

Runden zu Integer

In der Welt der Pixel sind ganze Zahlen gefragt.

let x = 17.4999;

let y = Math.round(x); // Auf- oder Abgerundet auf 

Rundet auf ab .5, rundet ab bis .49999

Runden auf Nachkommastellen

Für das Runden auf 2 Nachkommastellen braucht Javascript einen Trick:

Math.round (217.4325 * 100) / 100;  // 

Einfacher geht das Runden in Javascript mit toFixed:

let num = 9.7433789;
let n = num.toFixed(2);

Noch mal zurück auf Runden mit Math. Schluss mit 97 oder 49 Cent: Aufrunden zu 5 oder 0 in der zweiten Kommastelle

let cents = 1017.721987;
let fünfcents = (Math.ceil(cents*20)/20).toFixed(2);
console.log ("fünfcents " + fünfcents)
fünfcents 1017.75

Math – Methoden

Das Javascript Math ()-Objekt muss nicht instanziert werden (muss nicht mit new erzeugt werden). Die Methoden und Eigenschaften von Math () können direkt verwendet werden.

let x = 18.9;
let y = 200;
let z = 0.2345;

let größter = Math.max(x,y,z); 		// Größter Wert 
let kleinster = Math.min(x,y,z);	// Kleiner Wert 
Math.abs(x)     // absoluter Wert von x
Math.acos(x)    // Arcuscosinus von x als Bogenmaß
Math.asin(x)    // Arcussinus von x als Bogenmaß

Math.atan(x)    // Arcustangens, numerischer Wert zwischen -PI/2 und PI/2 Grad
Math.atan2(y,x) // Arcustangens des Quotienten des Arguments
Math.ceil(x)    // Aufrunden zum nächsten Integer

Math.cos(x)     // Cosinus als Bogenmaß
Math.exp(x)     // Wert von Ex
Math.floor(x)   // Abrunden auf die nächste ganze Zahl

Math.log(x)     // nat. Logarithmus zur Basis E
Math.max(x,…,z) // Maximum aus Werten
Math.min(x,…,z) // Min aus Werten

Math.max(...array) // Maximum aus Array-Werten (drei Punkte: Spread-Operator)
Math.min(...array) // Minimum aus Array-Werten (drei Punkte: Spread-Operator)
Math.pow(x,y)   // x hoch y

Math.random()   // Zufallszahl zwischen 0 und 1
Math.round(x)   // Rundet auf oder ab zum nächsten Integer (kaufmännisches Runden)
Math.sin(x)     // Sinus von x als Bogenmaß

Math.sqrt(x)    // Quadratwurzel von x
Math.tan(x)     // Tangente an einem Winkel