JavaScript-Nummern

Inhaltsverzeichnis

    Inhaltsverzeichnis anzeigen

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

Beispiel

let x = 3.14;    // A number with decimals
let y = 3;       // A number without decimals

Versuch es Selbst "

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

Beispiel

let x = 123e5;    // 12300000
let y = 123e-5;   // 0.00123

Versuch es Selbst "

JavaScript-Zahlen sind immer 64-Bit-Gleitkommazahlen

Im Gegensatz zu vielen anderen Programmiersprachen JavaScript definiert keine unterschiedlichen Zahlentypen wie Ganzzahlen, kurze Zahlen, lange Zahlen usw. Gleitkomma usw.

JavaScript-Zahlen werden immer als Gleitkommazahl mit doppelter Genauigkeit gespeichert Nummern gemäß dem internationalen Standard IEEE 754.

Dieses Format speichert Zahlen in 64 Bits, wobei die Zahl (der Bruch) in den Bits 0 gespeichert wird bis 51, der Exponent in den Bits 52 bis 62 und das Vorzeichen in Bit 63:

Value (aka Fraction/Mantissa) Exponent Sign
52 bits (0 - 51)  11 bits (52 - 62) 1 bit (63)

Ganzzahlige Präzision

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

Beispiel

let x = 999999999999999;   // x will be 999999999999999
let y = 9999999999999999;  // y will be 10000000000000000

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Numbers</h1>
<h2>Integer Precision</h2>

<p>Integers (numbers without a period or exponent notation) are accurate up to 15 digits:</p>

<p id="demo"></p>

<script>
let x = 999999999999999;
let y = 9999999999999999;
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>

</body>
</html>

Die maximale Anzahl an Dezimalstellen beträgt 17.

Schwebende Präzision

Gleitkomma-Arithmetik ist nicht immer 100 % genau:

let x = 0.2 + 0.1;

Versuch es Selbst "

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

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

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Floating point arithmetic is not always 100% accurate:</p>
<p id="demo1"></p>

<p>But it helps to multiply and divide:</p>

<p id="demo2"></p>

<script>
let x = 0.2 + 0.1;
document.getElementById("demo1").innerHTML = "0.2 + 0.1 = " + x;
let y = (0.2*10 + 0.1*10) / 10;
document.getElementById("demo2").innerHTML = "0.2 + 0.1 = " + y;
</script>

</body>
</html>

Zahlen und Zeichenfolgen hinzufügen

WARNUNG !!

JavaScript verwendet den +-Operator sowohl für die Addition als auch für die Verkettung.

Zahlen werden hinzugefügt. Zeichenfolgen werden verkettet.

Wenn Sie zwei Zahlen addieren, ist das Ergebnis eine Zahl:

Beispiel

let x = 10;
let y = 20;
let z = x + y;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you add two numbers, the result will be a number:</p>

<p id="demo"></p>

<script>
let x = 10;
let y = 20;
let z = x + y;
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Wenn Sie zwei Zeichenfolgen hinzufügen, ist das Ergebnis eine Zeichenfolgenverkettung:

Beispiel

let x = "10";
let y = "20";
let z = x + y;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you add two numeric strings, the result will be a concatenated string:</p>

<p id="demo"></p>

<script>
let x = "10";
let y = "20";
let z = x + y;
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Wenn Sie eine Zahl und eine Zeichenfolge hinzufügen, ist das Ergebnis eine Zeichenfolgenverkettung:

Beispiel

let x = 10;
let y = "20";
let z = x + y;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you add a number and a numeric string, the result will be a concatenated string:</p>

<p id="demo"></p>

<script>
let x = 10;
let y = "20";
let z = x + y;
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Wenn Sie eine Zeichenfolge und eine Zahl hinzufügen, ist das Ergebnis eine Zeichenfolgenverkettung:

Beispiel

let x = "10";
let y = 20;
let z = x + y;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you add a numeric string and a number, the result will be a concatenated string:</p>

<p id="demo"></p>

<script>
let x = "10";
let y = 20;
document.getElementById("demo").innerHTML = "The result is: " + x + y;
</script>

</body>
</html>

Ein häufiger Fehler besteht darin, dieses Ergebnis mit 30 zu erwarten:

Beispiel

let x = 10;
let y = 20;
let z = "The result is: " + x + y;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>A common mistake is to expect this result to be 30:</p>

<p id="demo"></p>

<script>
var x = 10;
var y = 20;
document.getElementById("demo").innerHTML =
"The result is: " + x + y;
</script>

</body>
</html>

Ein häufiger Fehler besteht darin, dieses Ergebnis mit 102030 zu erwarten:

Beispiel

let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>A common mistake is to expect this result to be 102030:</p>

<p id="demo"></p>

<script>
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;
document.getElementById("demo").innerHTML = result;
</script>

</body>
</html>

Der JavaScript-Interpreter arbeitet von links nach rechts.

Zuerst wird 10 + 20 addiert, da x und y beide Zahlen sind.

Dann wird 30 + „30“ verkettet, da z eine Zeichenfolge ist.

Numerische Zeichenfolgen

JavaScript-Strings können numerischen Inhalt haben:

let x = 100;         // x is a number

let y = "100";       // y is a 
string

JavaScript versucht, bei allen numerischen Operationen Zeichenfolgen in Zahlen umzuwandeln:

Das wird funktionieren:

let x = "100";
let y = "10";
let z = x / y;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript will try to convert strings to numbers when dividing:</p>

<p id="demo"></p>

<script>
let x = "100";
let y = "10";
let z = x / y;   
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Das wird auch funktionieren:

let x = "100";
let y = "10";
let z = x * y;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript will try to convert strings to numbers when multiplying:</p>

<p id="demo"></p>

<script>
let x = "100";
let y = "10";
let z = x * y;   
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Und das wird funktionieren:

let x = "100";
let y = "10";
let z = x - y;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript will try to convert strings to numbers when subtracting:</p>

<p id="demo"></p>

<script>
let x = "100";
let y = "10";
let z = x - y;   
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Aber das wird nicht funktionieren:

let x = "100";
let y = "10";
let z = x + y;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript will NOT convert strings to numbers when adding:</p>

<p id="demo"></p>

<script>
let x = "100";
let y = "10";
let z = x + y;   
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Im letzten Beispiel verwendet JavaScript den Operator „+“, um die Zeichenfolgen 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 (kein Nummer):

Beispiel

let x = 100 / "Apple";

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>A number divided by a non-numeric string becomes NaN (Not a Number):</p>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML = 100 / "Apple";
</script>

</body>
</html>

Wenn die Zeichenfolge jedoch numerisch ist, lautet das Ergebnis a Nummer:

Beispiel

let x = 100 / "10";

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>A number divided by a numeric string becomes a number:</p>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML = 100 / "10";
</script>

</body>
</html>

Sie können die globale JavaScript-Funktion isNaN() verwenden Um herauszufinden, ob ein Wert keine Zahl ist:

Beispiel

let x = 100 / "Apple";
isNaN(x);

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>You can use the global JavaScript function isNaN() to find out if a value is not a number:</p>

<p id="demo"></p>

<script>
let x = 100 / "Apple";
document.getElementById("demo").innerHTML = isNaN(x);
</script>

</body>
</html>

Achten Sie auf NaN. Wenn Sie NaN in einer mathematischen Operation verwenden, ist das Ergebnis ebenfalls NaN:

Beispiel

let x = NaN;
let y = 5;
let z = x + y;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you use NaN in a mathematical operation, the result will also be NaN:</p>

<p id="demo"></p>

<script>
let x = NaN;
let y = 5;
document.getElementById("demo").innerHTML = x + y;
</script>

</body>
</html>

Oder das Ergebnis könnte eine Verkettung wie NaN5 sein:

Beispiel

let x = NaN;
let y = "5";
let z = x + y;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you use NaN in a mathematical operation, the result can be a concatenation:</p>

<p id="demo"></p>

<script>
let x = NaN;
let y = "5";
document.getElementById("demo").innerHTML = x + y;
</script>

</body>
</html>

NaN ist eine Zahl: typeof NaN gibt Zahl:

Beispiel

typeof NaN;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>The typeof NaN is number:</p>

<p id="demo"></p>

<script>
let x = NaN;
document.getElementById("demo").innerHTML = typeof x;
</script>

</body>
</html>

Unendlichkeit

Infinity (oder -Infinity) ist der Wert, den JavaScript zurückgibt, wenn Sie eine Zahl außerhalb der größten berechnen mögliche Anzahl.

Beispiel

let myNumber = 2;
// Execute until Infinity
while (myNumber != Infinity) {
    myNumber = myNumber * myNumber;
}

Division durch 0 (Null) erzeugt auch Unendlichkeit:

Beispiel

let x =  2 / 0;
let y = -2 / 0;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Division by zero generates Infinity;</p>

<p id="demo"></p>

<script>
let x = 2/0;
let y = -2/0;
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>

</body>
</html>

Infinity ist eine Zahl: typeof Infinity gibt number.

Beispiel

typeof Infinity;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Infinity is a number:</p>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML = typeof Infinity;
</script>

</body>
</html>

Hexadezimal

JavaScript interpretiert numerische Konstanten als hexadezimal, wenn ihnen ein vorangestellt ist 0x.

Beispiel

let x = 0xFF;

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Numeric constants, preceded by 0x, are interpreted as hexadecimal:</p>

<p id="demo"></p>

<script>
let x = 0xFF;
document.getElementById("demo").innerHTML = "0xFF = " + x;
</script>

</body>
</html>

Schreiben Sie niemals eine Zahl mit einer führenden Null (wie 07).
Einige JavaScript-Versionen interpretieren Zahlen als Oktalzahl, wenn sie mit einer führenden Null geschrieben werden.

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

Sie können jedoch die Methode toString() verwenden, um Zahlen aus Basis 2 auszugeben zur Basis 36.

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

Beispiel

let myNumber = 32;
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(12);
myNumber.toString(10);
myNumber.toString(8);
myNumber.toString(2);

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>The toString() method can output numbers from base 2 to 36:</p>

<p id="demo"></p>

<script>
let myNumber = 32;
document.getElementById("demo").innerHTML =
"Decimal 32 = " + "<br><br>" + 

"Hexatrigesimal (base 36): " + myNumber.toString(36) + "<br>" +
"Duotrigesimal (base 32): " + myNumber.toString(32) + "<br>" +
"Hexadecimal (base 16): " + myNumber.toString(16) + "<br>" +
"Duodecimal (base 12): " + myNumber.toString(12) + "<br>" +
"Decimal (base 10): " + myNumber.toString(10) + "<br>" +
"Octal (base 8): " + myNumber.toString(8) + "<br>" +
"Binary (base 2): " + myNumber.toString(2);
</script>

</body>
</html>

JavaScript-Zahlen als Objekte

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

let x = 123;

Zahlen können aber auch mit dem Schlüsselwort new als Objekte definiert werden:

let y = new Number(123);

Beispiel

let x = 123;
let y = new Number(123);

Erstellen Sie keine Number-Objekte.

Das Schlüsselwort new verkompliziert den Code und verlangsamt die Ausführungsgeschwindigkeit.

Zahlenobjekte können zu unerwarteten Ergebnissen führen:

Bei Verwendung des Operators == sind x und y gleich:

let x = 500;
let y = new Number(500);

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Numbers and Number objects cannot be safely compared:</p>

<p id="demo"></p>

<script>
// x is a number
let x = 500;

// y is an object
let y = new Number(500);
document.getElementById("demo").innerHTML = (x==y);
</script>

</body>
</html>

Bei Verwendung des Operators === sind x und y nicht gleich.

let x = 500;
let y = new Number(500);

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Numbers and Number objects cannot be safely compared:</p>

<p id="demo"></p>

<script>
// x is a number
let x = 500;

// y is an object
let y = new Number(500);

document.getElementById("demo").innerHTML = (x===y);
</script>

</body>
</html>

Beachten Sie den Unterschied zwischen (x==y) und (x===y).

(x == y) wahr oder falsch?

let x = new Number(500);
let y = new Number(500);

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript objects cannot be compared:</p>

<p id="demo"></p>

<script>
// x is an object
let x = new Number(500);

// y is an object
let y = new Number(500);

document.getElementById("demo").innerHTML = (x==y);
</script>

</body>
</html>

(x === y) wahr oder falsch?

let x = new Number(500);
let y = new Number(500);

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript objects cannot be compared:</p>

<p id="demo"></p>

<script>
// x is an object
let x = new Number(500);

// y is an object
let y = new Number(500);

document.getElementById("demo").innerHTML = (x===y);
</script>

</body>
</html>

Der Vergleich zweier JavaScript-Objekte gibt immer false zurück.

Vollständige JavaScript-Nummernreferenz

Eine vollständige Nummernreferenz finden Sie auf unserer:

Vollständige JavaScript-Nummernreferenz.

Die Referenz enthält Beschreibungen und Beispiele aller Number-Eigenschaften und -Methoden.