9. Unterrichtsblock

JavaScript-Zahlen

JavaScript hat nur einen Zahlentyp. Zahlen können mit oder ohne Dezimalstellen geschrieben werden.

let x = 3.14;    // Eine Nummer mit Dezimalstellen (Punkt statt Komma)
let y = 3;       // Eine Nummer ohne Dezimalstellen

/*
Extra große oder extra kleine Zahlen 
können mit wissenschaftlicher (Exponenten-)Notation 
geschrieben werden:
*/

let x = 123e5;    // 12300000 Zahl erhält 5 Nullen
let y = 123e-5;   // 0.00123 Zahl endet 5 Stellen hinter dem Komma

Ganzzahlige Genauigkeit

Ganzzahlen (Zahlen ohne Punkt oder Exponentenschreibweise) sind auf bis zu 15 Stellen genau.

let x = 999999999999999;   // x wird zu 999999999999999
let y = 9999999999999999;  // y wird zu 10000000000000000

// Die maximale Anzahl von Dezimalstellen beträgt 17

Schwebende Präzision

Fließkomma-Arithmetik ist nicht immer 100% genau:

let x = 0.1 + 0.2;  // Ausgabe: x = 0.30000000000000004

/*
Um das obige Problem zu lösen, 
hilft es zu multiplizieren und zu dividieren:
*/

let x = (0.2 * 10 + 0.1 * 10) / 10;  // Ausgabe: x = 0.3

Hinzufügen von Zahlen und Zeichenfolgen

Erinnerung: JavaScript verwendet den „+“ Operator sowohl für die Addition als auch für die Verkettung. Zahlen werden hinzugefügt. Zeichenfolgen werden verkettet.

// Wenn man zwei Zahlen addiert, ist das Ergebnis eine Zahl:
let x = 10;
let y = 20;
let z = x + y;  // Ausgabe: 30

// Wenn Sie zwei Strings hinzufügen, ist das Ergebnis ein String:
let x = "10";
let y = "20";
let z = x + y;  // Ausgabe: 1020

/*  
Wenn man eine Zahl und eine Zeichenfolge hinzufügt, 
ist das Ergebnis ebenfalls ein String:
*/
let x = 10;
let y = "20";
let z = x + y;  // Ausgabe: 1020

Fehlerquellen

// FEHLERQUELLEN

// Ein häufiger Fehler ist zu erwarten, dass dieses Ergebnis 30 ist:
let x = 10;
let y = 20;
let z = "The result is: " + x + y; // Ausgabe: 1020


// Ein häufiger Fehler ist zu erwarten, dass dieses Ergebnis 102030 ist:
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z; // Ausgabe: 3030

/* BEGRÜNDUNG
Der JavaScript-Interpreter arbeitet von links nach rechts.
Zuerst wird 10 + 20 addiert, weil x und y beides Zahlen sind.
Dann wird 30 + "30" verkettet, weil z ein String ist.
*/

Numerische Zeichenfolgen

JavaScript-Strings können numerischen Inhalt haben:

let x = 100;         // x ist eine Nummer
let y = "100";       // y its ein String


/* 
JavaScript versucht bei allen numerischen Operationen, 
Strings in Zahlen umzuwandeln:
*/

// Das wird funktionieren:
let x = "100";
let y = "10";
let z = x / y; // Ausgabe: 10

// Das wird auch funktionieren:
let x = "100";
let y = "10";
let z = x * y; // Ausgabe: 1000

// Das wird auch funktionieren:
let x = "100";
let y = "10";
let z = x - y; // Ausgabe: 90

// Das wird nicht funktionieren:
let x = "100";
let y = "10";
let z = x + y; // Ausgabe: 10010

/*
Im letzten Beispiel verwendet JavaScript den +-Operator, 
um die Strings zu verketten.
*/

NaN – Keine Zahl

NaN ist ein für JavaScript reserviertes Wort, das angibt, dass eine Zahl keine gültige Zahl ist.

Der Versuch, mit einer nicht numerischen Zeichenfolge zu rechnen, führt zu NaN (Not a Number):

let x = 100 / "Apple"; // Ausgabe: NaN

/*
Wenn die Zeichenfolge jedoch einen numerischen Wert enthält, 
ist das Ergebnis eine Zahl:
*/
let x = 100 / "10"; // Ausgabe: 10


/*
Man kann die globale JavaScript-Funktion verwenden "isNaN()", 
um herauszufinden, ob ein Wert keine Zahl ist:
*/
let x = 100 / "Apple";
isNaN(x); // Ausgabe: true


/*
Wenn NaN eine mathematische Operation verwendet, 
lautet das Ergebnis ebenfalls NaN:
*/
let x = NaN;
let y = 5;
let z = x + y; // Ausgabe: NaN


// Oder das Ergebnis könnte eine Verkettung wie NaN5 sein:
let x = NaN;
let y = "5";
let z = x + y; // Ausgabe: NaN5


/* 
Paradoxerweise ist NaN eine Zahl: 
typeof NaN gibt "number" aus:
*/
typeof NaN; // Ausgabe: number

Unendlichkeit

Infinity (oder -Infinity) ist der Wert, den JavaScript zurückgibt, wenn man eine Zahl außerhalb der größtmöglichen Zahl berechnet.

// BEISPIEL 1
let meineNummer = 2;
let ergebnis = "";
// Unendliche Ausführung
while (meineNummer != Infinity) {
  meineNummer = meineNummer * meineNummer;
  ergebnis = ergebnis + meineNummer + "<br>";
}
document.getElementById("demo").innerHTML = ergebnis;

// Eine Division durch 0 (Null) erzeugt auch Infinity:
let x =  2 / 0; // Ausgabe: Infinity
let y = -2 / 0; // Ausgabe: -Infinity

Infinity ist eine Zahl: typeof Infinity gibt zurück number.

typeof Infinity; // Ausgabe: number

Hexadezimal

JavaScript interpretiert numerische Konstanten als hexadezimal, wenn ihnen 0x vorangestellt ist.
Erklärung Hexadezimalsystem: https://de.wikipedia.org/wiki/Hexadezimalsystem

let x = 0xFF; // Ausgabe: 255

Hinweis: Zahlen sollten nie mit einer führenden Null (wie 07) geschrieben werden. Einige JavaScript-Versionen interpretieren Zahlen als oktal, wenn sie mit führender Null geschrieben werden.

Standardmäßig zeigt JavaScript Zahlen als Dezimalstellen zur Basis 10 an .

Man kann auch die toString() Methode verwenden, um Zahlen von der Basis 2 bis zur Basis 36 ausgeben zu lassen.

• Hexadezimal hat die Basis 16
• Dezimal die Basis 10
• Oktal die Basis 8
• Binär hat die Basis 2 .

// BEISPIEL toString() Methode

let meineNummer = 32;
document.getElementById("demo").innerHTML =
"Meine Nummer = " + meineNummer + "<br><br>" + 

"Hexatrigesimal (Basis 36): " + meineNummer.toString(36) + "<br>" +
"Duotrigesimal (Basis 32): " + meineNummer.toString(32) + "<br>" +
"Hexadezimal (Basis 16): " + meineNummer.toString(16) + "<br>" +
"Duodezimal (Basis 12): " + meineNummer.toString(12) + "<br>" +
"Dezimal (Basis 10): " + meineNummer.toString(10) + "<br>" +
"Oktal (Basis 8): " + meineNummer.toString(8) + "<br>" +
"Binär (Basis 2): " + meineNummer.toString(2);

JavaScript-Zahlen als Objekte

Normalerweise sind JavaScript-Zahlen primitive Werte, die aus Literalen erstellt wurden:

let x = 123;

// Zahlen können aber auch mit dem Schlüsselwort "new" als Objekte definiert werden:
let y = new Number(123);

WICHTIG: Zahlen-Objekte sollten NICHT erstellt werden. Objekte dürfen zwar Zahlen und Nummern enthalten, jedoch sollten keine Nummer-Objekte erstellt werden.

• Das new-Schlüsselwort verkompliziert den Code und verlangsamt die Ausführungsgeschwindigkeit.
• Zahlenobjekte können zu unerwarteten Ergebnissen führen – es folgen zwei Beispiele:

// Bei Verwendung des "=="-Operators sind x und y gleich:
let x = 500;
let y = new Number(500);
document.getElementById("demo").innerHTML = (x==y); // Ausgabe: true


// Bei Verwendung des "==="-Operators sind x und y ungleich:
let x = 500;
let y = new Number(500);
document.getElementById("demo").innerHTML = (x===y); // Ausgabe: false

JavaScript BigInt

JavaScript BigInt-Variablen werden verwendet, um große Integer-Werte zu speichern, die zu groß sind, um von einer normalen JavaScript-Number dargestellt zu werden.

Integer = Ganzzahl

JavaScript-Integer-Genauigkeit

JavaScript-Ganzzahlen sind nur bis zu 15 Stellen genau:

let x = 999999999999999;   // Genau
let y = 9999999999999999;  // Ungenau

• In JavaScript werden alle Zahlen in einem 64-Bit-Gleitkommaformat (IEEE 754-Standard) gespeichert.
  • Erkläruung Gleitkommazahl: https://de.wikipedia.org/wiki/Gleitkommazahl
• Mit diesem Standard können große ganze Zahlen nicht exakt dargestellt werden und werden gerundet.
• Aus diesem Grund kann JavaScript nur Ganzzahlen sicher darstellen:

Bis zu 9007199254740991 +(2 ⁵³ -1)

und

Bis zu -9007199254740991 -(2 ⁵³ -1).

Ganzzahlwerte außerhalb dieses Bereichs verlieren an Genauigkeit.

So erstellt man eine BigInt

Um eine BigInt zu erstellen, hängt man n an das Ende einer Ganzzahl an oder ruft BigInt() im Code auf:

// BEISPIEL
let x = 9999999999999999;
let y = 9999999999999999n;

// Oder
let x = 1234567890123456789012345n;
let y = BigInt(1234567890123456789012345)

BigInt: Ein neuer JavaScript-Datentyp

Das JavaScript typeof einer BigInt ist „bigint“:

let y = 999999999999999n;
let typ = typeof y;  // Ausgabe: bigint

let x = BigInt(999999999999999);
let typ = typeof x;  // Ausgabe: bigint

BigInt ist der zweite numerische Datentyp in JavaScript (nach Number).

Zusammen mit BigInt gibt es in JavaScript insgesamt 8 unterstützten Datentypen:

• BigInt
• Boolean
• Null
• Number
• Object
• String
• Symbol
• Undefined

BigInt-Operatoren

Operatoren, die in einer JavaScript-Number verwendet werden können, können auch in einer BigInt verwendet werden.

BigInt-Multiplikationsbeispiel

let x = 9007199254740995n;
let y = 9007199254740995n;
let z = x * y;

Hinweis:

Arithmetik zwischen einer BigInt und einer Number ist nicht erlaubt (Typkonvertierung verliert Informationen).

// erlaubt
let x = 9007199254740995n;
let y = 9007199254740995n;
let z = x * y;


// nicht erlaubt
let x = 9007199254740995n;
let y = 9007199;
let z = x * y;

BigInt Dezimalstellen

Eine BigInt kann keine Dezimalzahlen haben.

BigInt-Divisionsbeispiel

let x = 5n;
let y = x / 2; // Falsch

/* 
Oben gezeigtes Beispiel führt zu einem Fehler.
BigInt und andere Typen können nicht gemischt werden.
Es muss zuvor eine explizite Konvertierung stattfinden.
*/

let x = 5n;
let y = Number(x) / 2; // Korrekt

BigInt Hex, Oktal und Binär

BigInt kann auch in hexadezimaler, oktaler oder binärer Notation geschrieben werden:

BigInt Hex-Beispiel

let hex = 0x20000000000003n;
let okt = 0o400000000000000003n;
let bin = 0b100000000000000000000000000000000000000000000000000011n;

document.getElementById("demo").innerHTML = hex + "<br>" + okt + "<br>" + bin; 

Präzisions-Kuriosität

Rundungen können die Programmsicherheit beeinträchtigen:

MAX_SAFE_INTEGER Beispiel

9007199254740992 === 9007199254740993; // Ausgabe: true !!!

Minimale und maximale sichere Ganzzahlen

In ES6 wurde dem Number-Objekt die Eigenschaften max und min hinzugefügt:

• MAX_SAFE_INTEGER
• MIN_SAFE_INTEGER

let x = Number.MAX_SAFE_INTEGER;
let y = Number.MIN_SAFE_INTEGER;

Neue Zahlenmethoden

ES6 hat dem Number-Objekt außerdem zwei neue Methoden hinzugefügt:

• Number.isInteger()
• Number.isSafeInteger()

Die Methode Number.isInteger()

Die Number.isInteger()Methode gibt true zurück, wenn das Argument eine Ganzzahl ist.

Number.isInteger(10);     // Ausgabe: true
Number.isInteger(10.5);   // Ausgabe: false

Die Methode Number.isSafeInteger()

Eine sichere Ganzzahl ist eine ganze Zahl, die exakt mit doppelter Genauigkeit als Zahl dargestellt werden kann.

Die Number.isSafeInteger() Methode gibt true zurück, wenn das Argument eine sichere Ganzzahl ist.

Number.isSafeInteger(10);
Number.isSafeInteger(12345678901234567890);

Merke

„Sichere Ganzzahlen“ sind alle ganzen Zahlen von -(2 ⁵³ – 1) bis + (2 ⁵³ – 1).
Dies ist ein sicherer Wert: 9007199254740991. Dies ist kein sicherer Wert: 9007199254740992.

Eigenschaften von JavaScript-Zahlen

JavaScript EPSILON

Number.EPSILONstellt die Differenz zwischen 1 und der kleinsten Gleitkommazahl dar.

let x = Number.EPSILON;

Notiz

Number.EPSILONist eine ES6 – Funktion.

Im Internet Explorer funktioniert es nicht.

JavaScript-MAX_VALUE

Number.MAX_VALUE ist eine Konstante, die die größtmögliche Zahl in JavaScript darstellt.

let x = Number.MAX_VALUE;

Zahleneigenschaften können nicht für Variablen verwendet werden

Number-Eigenschaften gehören zum JavaScript -Number-Objekt .

Auf diese Eigenschaften kann nur als Number.MAX_VALUE.

Die Verwendung von x.MAX_VALUE, wobei x eine Variable oder ein Wert ist, gibt Folgendes zurück undefined:

let x = 6;
x.MAX_VALUE

JavaScript MIN_VALUE

Number.MIN_VALUE ist eine Konstante, die die kleinstmögliche Zahl in JavaScript darstellt.

let x = Number.MIN_VALUE;

JavaScript MAX_SAFE_INTEGER

Number.MAX_SAFE_INTEGER stellt die maximale sichere Ganzzahl in JavaScript dar.

Number.MAX_SAFE_INTEGER ist (2 ⁵³ – 1).

let x = Number.MAX_SAFE_INTEGER;

JavaScript MIN_SAFE_INTEGER

Number.MIN_SAFE_INTEGERstellt die minimale sichere Ganzzahl in JavaScript dar.

Number.MIN_SAFE_INTEGERist -(2 ⁵³ – 1).

let x = Number.MIN_SAFE_INTEGER;

Notiz

MAX_SAFE_INTEGERund MIN_SAFE_INTEGERsind ES6- Features.

Sie funktionieren nicht im Internet Explorer.

JavaScript POSITIVE_INFINITY

let x = Number.POSITIVE_INFINITY;

POSITIVE_INFINITY wird bei Überlauf zurückgegeben:

let x = 1 / 0;

JavaScript NEGATIVE_INFINITY

let x = Number.NEGATIVE_INFINITY;

NEGATIVE_INFINITY wird bei Überlauf zurückgegeben:

let x = -1 / 0;

JavaScript NaN – Keine Zahl

NaN ist ein in JavaScript reserviertes Wort für eine Zahl, die keine legale Zahl ist.

let x = Number.NaN;

Der Versuch, mit einer nicht numerischen Zeichenfolge zu rechnen, führt zu NaN (Not a Number):

let x = 100 / "Apple";