Number

Siehe auch Math Objekt für Berechnungen

Zahlen werden durch den Datentyp Number bestimmt.

x = 9;

Negativen Werten wird ein minus Zeichen vorangestellt.

x = -9;

Eine Kommazahl wird mittels Punkt dargestellt.

x = 3.5;

Zahlensysteme

Neben dem üblichen Dezimalsystem gibt es auch die Möglichkeit andere Zahlensysteme zu nutzen, beispielsweise Binär oder Hexadezimal.

Binärzahlen

Binärzahlen haben das Präfix 0b
Folgende Zahl entspricht der Dezimalzahl 12

x = 0b1100;

Hexadezimalzahlen

Hexadezimalzahlen haben das Präfix 0x
Folgende Zahl entspricht der Dezimalzahl 124

x = 0x7C;

Wertebereich

Der Wertebereich der Zahlen in Javascript ist begrenzt, da man nicht unendlich viel Speicher in einem Computer hat.
Die kleinste Zahl (5e-324) wird definiert durch:

Number.MIN_VALUE

Die größte Zahl (1.7976931348623157e+308) wird definiert durch

Number.MAX_Value

Ungültige Zahl / NaN

Wenn man eine Berechnung anstellt bei der keine gültige Zahl herauskommt, wird das durch NaN dargestellt. Es bedeutet Not a Number

isNaN()

Man kann mit der Methode isNaN() oder window.isNaN() auf eine Zahl überprüfen. Die Methode liefert true, wenn es sich um keinen Zahlenwert handelt.

Die Methode wandelt vor der Überprüfung, in den Datentyp number um. Daher wird bei Strings, die aus einem Zahlenwert bestehen genau wie bei anderen numerischen Werten false ausgegeben.

        isNaN("34") //liefert false
        isNaN(34) // liefert false
        isNaN("ab") //liefert true
      

Arithmetische Operatoren

Um mit numerischen Werten zu rechnen benutzt man Rechenoperatoren.

weitere Infos zu den Operatoren

Methoden der Klasse Number

Siehe auch W3schools

Number.parseFloat()

W3schools

Number.parseFloat Diese statische Methode analysiert einen Wert als Zeichenkette und gibt die erste Zahl zurück. Das bedeutet, wenn die ersten Zeichen numerische Werte sind, werden diese als Zahl zurück gegeben.

        Number.parseFloat(10); //10
        Number.parseFloat("10"); //10
        Number.parseFloat("10.24"); //10.24
        Number.parseFloat("10 15 24"); //10
        Number.parseFloat("20B");//20
        Number.parseFloat("H20");//NaN
      

Number.parseInt()

Number.parseInt() analysiert einen Wert als Zeichenkette und gibt die erste ganze Zahl zurück.

Der zweite Parameter „radix“ legt das zu verwendende Zahlensystem fest: 2 = Binär, 8 = Oktal, 10 = Dezimal, 16 = Hexadezimal. Wird der Parameter „radix“ weggelassen, verwendet JavaScript das Dezimalsystem (Radix 10). Beginnt der Wert mit „0x“, verwendet JavaScript das Hexadezimalsystem (Radix 16).

Besonderheit: Da parseInt() schon existierte, bevor es die Klasse Number in JavaScript gab, ist sie zusätzlich auch als globale Funktion verfügbar. parseInt() und Number.parseInt() machen also exakt das Gleiche.

        Number.parseInt("10"); //10
        Number.parseInt("10.33"); //10
        Number.parseInt("14 45 66"); //14
        Number.parseInt("14 Jahre"); //14
        Number.parseInt("010"); //10
        Number.parseInt("0x10"); //16
        Number.parseInt("10", 16); //16
        Number.parseInt("10", 8); //8
      

.toFixed()

siehe auch W3schools

Mit der Instanz-Methode .toFixed() wird ein numerischer Wert in einen String umgewandelt.
Als Argument .toFixed(3) gibt man die Anzahl Dezimalstellen an, die angezeigt werden sollen. werden sollen.

        var num = 3.456432;
        var n = num.toFixed(2); // 3.45
      

toPrecision()

Hier wird eine Zahl auf eine bestimmte Länge formatiert. Ein Dezimalpunkt und Nullen werden hinzugefügt wenn nötig.

        let num = 212.3453;
        let n = num.toPrecision(3); // 212
        n = num.toPrecision(5); // 212.34
        num = 1;
        n = num.toPrecision(5) //1.0000
      

.toString()

Jedes JavaScript-Objekt besitzt eine toString()-Methode. Diese Methode wird von JavaScript verwendet, wenn ein Objekt als Zeichenkette verwendet werden soll. Es wird ein String zurück gegeben.

Der Parameter radix erwartet einen Integer (Ganzzahl) von 2 bis 36. Damit wird das Zahlensystem definiert. Wenn man ihn nicht angibt ist es das Dezimalsystem.
2 binary
8 oktal
16 hexdezimal

        let num = 15;
        let dez = num.toString(); //15
        let bin = num.toString(2); //1111
        let bin = num.toString(8); //17
        let bin = num.toString(16); //f
      

toLocaleString()

Hiermit wird eine Zahl gemäß der Schreibweise der eingestellten Sprache des Computers formatiert. In deutsch gibt es als Dezimaltrennzeichen das Komma und als Tausendertrennzeichen den Punkt.

Man kann optional weitere benannte Parameter eingeben. Die Liste findet man bei W3schools

Es ist möglich ein Währungszeichen zu definieren oder die Anzahl der Stellen vor und nach dem Komma zu bestimmen. Auch vorangestellte Nullen sind möglich.

        let num = 10000.00;
        let n = num.toLocaleString(); //10.000
        n = num.toLocaleString("en"); //10,000
        num = 10000.40;
        n = num.toLocaleString(); // 10.000,4
        n= num.toLocaleString("fr") // 10 000,4
        n = num.toLocaleString("en-us"); // 10,000.4
        n= num.toLocaleString("en-us", {style:"currency", currency:"USD"}); //$10,000.40
        n= num.toLocaleString("de", {style:"currency", currency:"EUR"}); //10.000,40 €
        let num = 10000.423423;
        n= num.toLocaleString("de", {maximumFractionDigits:"3"}); // 10.000,423
        (1.4).toLocaleString("de", { minimumIntegerDigits:"2" }) // 01.4
        (1.4).toLocaleString("de", { minimumFractionDigits:"2" }) //1.40
        (1.4234).toLocaleString("de", {maximumFractionDigits:"2" })//1.42

      

valueOff()

Mit valueOff() wird etwas in eine primitive Zahl umgewandelt. Das ist ein Thema, das tief in die "Maschinenraum-Logik" von JavaScript führt. Um zu verstehen, was eine primitive Zahl ist, müssen wir uns anschauen, wie JavaScript Daten speichert.

1. Primitiv vs. Objekt

In JavaScript gibt es zwei Hauptkategorien von Datentypen:

• Primitive Typen: (Zahlen, Strings, Booleans, null, undefined). Sie sind "einfach". Sie sind keine Objekte, haben keine eigenen Methoden und werden direkt im Speicher abgelegt.

• Objekte: (Arrays, Funktionen, oder mit new Number() erstellte Zahlen). Sie sind "komplexer", belegen mehr Speicher und haben eine Struktur.

2. Was macht valueOf()? (mit "f", kleiner Tipp: valueOf())

Normalerweise arbeitest du in JavaScript mit primitiven Zahlen: let x = 42; (Das ist einfach nur der Wert 42 im Speicher).

Manchmal (wenn auch selten im modernen JS) werden Zahlen als Objekte verpackt. Die Methode valueOf() schält die "Verpackung" ab und gibt den nackten, einfachen Wert zurück.

let objektZahl = new Number(42); // Ein "Zahlen-Objekt" (komplex)
              let primitiveZahl = objektZahl.valueOf(); // Der einfache Wert 42 (primitiv)

              console.log(typeof objektZahl); // "object"
              console.log(typeof primitiveZahl); // "number" 

Manchmal rechnest du mit Werten wie r = 0.78. Das sind primitive Zahlen.

Das Faszinierende (und Verwirrende) an JavaScript ist: Obwohl eine Zahl primitiv ist, erlaubt JS dir, Methoden wie .toFixed() darauf aufzurufen.

• Der Trick: In dem Moment, in dem du 0.78.toFixed() tippst, nimmt JavaScript die primitive Zahl, wickelt sie für eine Millisekunde in ein Objekt ein (Autoboxing), führt die Methode aus und wirft die Verpackung danach sofort wieder weg.

Zusammenfassung für das Verständnis:

• Eine primitive Zahl ist der reine, nackte Datenwert ohne Schnickschnack.

• Sie ist unveränderlich (immutable). Du kannst die Zahl 5 nicht ändern; du kannst einer Variable nur eine neue Zahl zuweisen.

• valueOf() ist quasi der Befehl: "Gib mir den puren Wert ohne die Objekt-Hülle zurück."

Ein kleiner Merksatz:

Die primitive Zahl ist der Rohstoff (die Zahl selbst). Das Number-Objekt ist der Container, in dem der Rohstoff geliefert werden kann. valueOf() öffnet den Container und holt den Rohstoff heraus.

In 99 % der Fälle nutzt du in JavaScript primitive Zahlen, ohne es zu merken, weil JavaScript den Wechsel zwischen "Rohstoff" und "Container" im Hintergrund vollautomatisch erledigt!

Javascript Tipps