Javascript Zahlen: Integer, Float und das Math-Objekt

Javascript Integer, Float, Math: Aufrunden, Abrunden, Ein kleiner Rechner mit Operatoren

Javascript Math liefert die Methoden für das Auf- und Abrunden von Zahlen und das Runden von Fließkommazahlen, für die Berechnung von Winkeln und das Erzeugen von Zufallszahlen.

In Math liegen Wurzeln, Funktionen wie Sinus und Tangens, hier sind Javascript pi und Logarithmen zuhause und Math liefert das Minimum und Maximum einer Zahlenreihe, mit ES6 auch den max. bzw. min. Wert aus einem Array.

In Javascript können wir Variablen anlegen und ihnen einen numerischen Wert zuweisen. 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.

In Javascript werden alle Zahlen als 64-Bit Floating Point-Zahlen realisiert, so dass wir uns um diese Frage nicht kümmern müssen.

let foo1 = 4; 
let foo2 = 8;
alert (foo1 + foo2) // gibt 12 aus

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

Javascript Number ()

versucht, den Wert einer Variablen als Zahl zu interpretieren.

Alle Eingaben in Formularfeldern 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.

Die Funktionen Number () und isNaN() setzen Strings in Zahlen um.

Bei der Eingabe von Zahlen via INPUT müssen wir allerdings 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.

String Methoden und Eigenschaften

let foo1 = "20,12";		// Zeichenkette mit Komma
let foo2 = "20.12";		// Zeichenkette mit Punkt
let zahl = Number(foo1)	// liefert 
let zahl = Number(foo2)	// liefert 

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.

Javascript Math – Methoden

Das 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 = 17.4;

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

Rundet auf ab .5, rundet ab bis .49999 …

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

Beispiel Javascript Wurzel

Wurzel aus Wert eines Eingabefelds ziehen und ausgeben.

Wurzel aus ist
document.getElementById("sqrt").oninput = function () {
   let num = Number(this.value.replace(",", ".")); // *1
   
   if (isNaN(num)) {                               // *2
      document.getElementById("sqrtresult").innerHTML = "Keine Zahl";
   } else {
      document.getElementById("sqrtresult").innerHTML = Math.sqrt(num);
   }
}
  1. Bei Werten aus Eingabefeldern immer daran denken, dass Dezimalstellen mit einem Punkt "." anstelle des Kommas verarbeitet werden
  2. und prüfen, ob es sich um eine Zahl handelt (isNaN)

Beispiel Math.sin () – Sinus

Sinus und Cosinus sind Begriffe der Trigonometrie und beschreiben das Verhältnisse der Seiten in einem rechtwinkligen Dreieck im Verhältnis zum eingeschlossenen Winkel.

Für sich betrachtet, sind Sinus (Sinus kommt aus dem arabischen und heißt soviel wie Bogen) und Cosinus nichts weiter als einfache Zahlenwerte.

Math.sin(x) liefert für jede Eingabe eine Zahl zwischen -1 und +1. Gern für die Animation einer Schwingung mit Javascript genommen.

1
Math.sin() für die Animation von Schwingungen
function SineWave(c) {
    let s = Math.sin(c);
    let x = 500 - c * 700; // Bewegung auf der x-Achse
    let y = s * 90 + 250;  // Bewegung auf der y-Achse
    return [x, y];
};

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);

"Pi, Logarithmus, Euler

Math.PI		// Zahl PI
Math.E		// Eulersche Konstante
Math.LN2 	// nat. Logarithmus zur Basis 2
Math.LN10	// nat. Logarithmus zur Basis 10
Math.LOG2E	// konstanter Logarithmus von 2
Math.Log10E	// konstanter Logarithmus von 10
Javascript Integer, Float, Math