Zahlen und Strings

In JavaScript werden Zahlen im Doppelpräzisions-64-Bit-Binärformat IEEE 754 implementiert (d.h. eine Zahl zwischen ±2^−1022 und ±2^+1023, oder etwa ±10^−308 bis ±10^+308, mit einer numerischen Präzision von 53 Bits). Ganzzahlen bis zu ±2^53 − 1 können exakt dargestellt werden.

Zusätzlich zur Darstellung von Fließkommazahlen hat der Zahlentyp drei symbolische Werte: Infinity, -Infinity und NaN (not-a-number).

Siehe auch JavaScript-Datenstrukturen für den Kontext mit anderen primitiven Typen in JavaScript.

Sie können vier Arten von Zahl-Literalen verwenden: dezimal, binär, oktal und hexadezimal.

1234567890
42

Dezimal-Literale können mit einer Null (0) gefolgt von einer anderen Dezimalziffer beginnen, aber wenn alle Ziffern nach der führenden 0 kleiner als 8 sind, wird die Zahl als Oktalzahl interpretiert. Dies wird als veraltete Syntax betrachtet, und Zahl-Literale mit Präfix 0, egal ob als Oktal oder Dezimal interpretiert, verursachen einen Syntaxfehler im strikten Modus — verwenden Sie stattdessen das Präfix 0o.

0888 // 888 parsed as decimal
0777 // parsed as octal, 511 in decimal

Die Binärzahl-Syntax verwendet eine führende Null gefolgt von einem kleinen oder großen lateinischen Buchstaben "B" (0b oder 0B). Wenn die Ziffern nach dem 0b nicht 0 oder 1 sind, wird der folgende SyntaxError ausgelöst: "Fehlende binäre Ziffern nach 0b".

0b10000000000000000000000000000000 // 2147483648
0b01111111100000000000000000000000 // 2139095040
0B00000000011111111111111111111111 // 8388607

Die Standard-Syntax für Oktalzahlen ist, sie mit 0o zu präfixieren. Zum Beispiel:

0O755 // 493
0o644 // 420

Es gibt auch eine veraltete Syntax für Oktalzahlen — indem die Oktalzahl mit einer Null präfixiert wird: 0644 === 420 und "\045" === "%". Wenn die Ziffern nach der 0 außerhalb des Bereichs 0 bis 7 liegen, wird die Zahl als Dezimalzahl interpretiert.

const n = 0755; // 493
const m = 0644; // 420

Strikter Modus verbietet diese Oktal-Syntax.

Hexadezimalzahl-Syntax verwendet eine führende Null gefolgt von einem kleinen oder großen lateinischen Buchstaben "X" (0x oder 0X). Wenn die Ziffern nach 0x außerhalb des Bereichs (0123456789ABCDEF) liegen, wird der folgende SyntaxError ausgelöst: "Bezeichner beginnt sofort nach Zahlenliteral".

0xFFFFFFFFFFFFF // 4503599627370495
0xabcdef123456  // 188900967593046
0XA             // 10

Das eingebaute Number-Objekt hat Eigenschaften für numerische Konstanten, wie den Maximalwert, "not-a-number" und Unendlichkeit. Sie können die Werte dieser Eigenschaften nicht ändern, und Sie verwenden sie wie folgt:

const biggestNum = Number.MAX_VALUE;
const smallestNum = Number.MIN_VALUE;
const infiniteNum = Number.POSITIVE_INFINITY;
const negInfiniteNum = Number.NEGATIVE_INFINITY;
const notANum = Number.NaN;

Sie beziehen sich immer auf eine Eigenschaft des vordefinierten Number-Objekts wie oben gezeigt und nicht auf eine Eigenschaft eines Number-Objekts, das Sie selbst erstellen.

Die folgende Tabelle fasst die Eigenschaften des Number-Objekts zusammen.

Das Number-Prototyp stellt Methoden bereit, um Informationen aus Number-Objekten in verschiedenen Formaten abzurufen. Die folgende Tabelle fasst die Methoden von Number.prototype zusammen.

Das eingebaute Math-Objekt hat Eigenschaften und Methoden für mathematische Konstanten und Funktionen. Beispielsweise hat die PI-Eigenschaft des Math-Objekts den Wert von Pi (3,141…), den Sie in einer Anwendung folgendermaßen verwenden würden:

Math.PI;

Ähnlich sind Standard-Mathematik-Funktionen Methoden von Math. Diese umfassen trigonometrische, logarithmische, exponentielle und andere Funktionen. Wenn Sie beispielsweise die trigonometrische Funktion Sinus verwenden möchten, würden Sie schreiben:

Math.sin(1.56);

Beachten Sie, dass alle trigonometrischen Methoden von Math Argumente in Radiant annehmen.

Die folgende Tabelle fasst die Methoden des Math-Objekts zusammen.

Im Gegensatz zu vielen anderen Objekten erstellen Sie niemals ein eigenes Math-Objekt. Sie verwenden immer das eingebaute Math-Objekt.

Ein Mangel von Zahlenwerten ist, dass sie nur 64 Bits haben. In der Praxis, aufgrund der Verwendung von IEEE 754-Codierung, können sie keine Ganzzahl größer als Number.MAX_SAFE_INTEGER (das ist 2⁵³ - 1) präzise darstellen. Um das Bedürfnis nach der Codierung von Binärdaten zu erfüllen und um mit anderen Sprachen, die breite Ganzzahlen wie i64 (64-Bit-Ganzzahlen) und i128 (128-Bit-Ganzzahlen) anbieten, zusammenzuarbeiten, bietet JavaScript auch einen anderen Datentyp an, um beliebig große Ganzzahlen darzustellen: BigInt.

Ein BigInt kann als Ganzzahlenliteral definiert werden, das mit n endet:

const b1 = 123n;
// Can be arbitrarily large.
const b2 = -1234567890987654321n;

BigInts können auch aus Zahlenwerten oder Stringwerten mithilfe des BigInt-Konstruktors erstellt werden.

const b1 = BigInt(123);
// Using a string prevents loss of precision, since long number
// literals don't represent what they seem like.
const b2 = BigInt("-1234567890987654321");

Konzeptionell ist ein BigInt einfach eine beliebig lange Sequenz von Bits, die eine Ganzzahl kodiert. Sie können sicher alle arithmetischen Operationen durchführen, ohne an Präzision zu verlieren oder ein Über- bzw. Unterlauf zu verursachen.

const integer = 12 ** 34; // 4.9222352429520264e+36; only has limited precision
const bigint = 12n ** 34n; // 4922235242952026704037113243122008064n

Im Vergleich zu Zahlen bieten BigInt-Werte eine höhere Präzision beim Darstellen großer Ganzzahlen; sie können jedoch keine Fließkommazahlen darstellen. Zum Beispiel würde eine Division auf null runden:

const bigintDiv = 5n / 2n; // 2n, because there's no 2.5 in BigInt

Math-Funktionen können nicht auf BigInt-Werte angewendet werden; sie funktionieren nur mit Zahlen.

Die Wahl zwischen BigInt und Zahl hängt von Ihrem Anwendungsfall und dem Bereich Ihrer Eingaben ab. Die Präzision von Zahlen sollte in der Lage sein, die meisten alltäglichen Aufgaben bereits zu bewältigen, und BigInts sind am besten geeignet für den Umgang mit Binärdaten.

Lesen Sie mehr darüber, was Sie mit BigInt-Werten machen können, im Abschnitt Ausdrücke und Operatoren oder im BigInt-Referenz.

Der String-Typ von JavaScript wird zur Darstellung von Textdaten verwendet. Es handelt sich um eine Menge von "Elementen" von 16-Bit-unsigned Integer-Werten (UTF-16-Codeeinheiten). Jedes Element in dem String nimmt eine Position im String ein. Das erste Element befindet sich am Index 0, das nächste an Index 1 und so weiter. Die Länge eines Strings ist die Anzahl der Elemente in ihm. Sie können Strings mithilfe von String-Literalen oder String-Objekten erstellen.

Sie können Strings im Quellcode mit einfachen oder doppelten Anführungszeichen deklarieren:

'foo'
"bar"

In einem String-Literal können die meisten Zeichen wörtlich eingegeben werden. Die einzigen Ausnahmen sind der Backslash (\, der eine Escape-Sequenz einleitet), das Anführungszeichen, das zum Einschließen des Strings verwendet wird, das den String beendet, und das Zeilenumbruchzeichen, das einen Syntaxfehler verursacht, wenn ihm nicht ein Backslash vorangeht.

Fortgeschrittenere Strings können mit Escape-Sequenzen erstellt werden:

Hexadezimale Escape-Sequenzen

Die Zahl nach \x wird als Hexadezimalzahl interpretiert.

"\xA9" // "©"

Unicode-Escape-Sequenzen

Die Unicode-Escape-Sequenzen erfordern mindestens vier hexadezimale Ziffern nach \u.

"\u00A9" // "©"

Unicode-Codepunkt-Escapes

Mit Unicode-Codepunkt-Escapes kann jedes Zeichen mit Hexadezimalzahlen maskiert werden, sodass es möglich ist, Unicode-Codepunkte bis zu 0x10FFFF zu verwenden. Mit den vierstelligen Unicode-Escapes ist es oft notwendig, die Surrogat-Hälften separat zu schreiben, um dasselbe Ergebnis zu erzielen.

Siehe auch String.fromCodePoint() oder String.prototype.codePointAt().

"\u{2F804}"

// the same with simple Unicode escapes
"\uD87E\uDC04"

Sie können Methoden direkt auf einem String-Wert aufrufen:

console.log("hello".toUpperCase()); // HELLO

Die folgenden Methoden sind auf String-Werten verfügbar:

• Abfrage: das Zeichen oder den Zeichencode an einem bestimmten String-Index abrufen. Methoden umfassen at(), charAt(), charCodeAt(), und codePointAt().
• Suche: Informationen zu einem Teilstring, der einem Muster entspricht, abrufen oder testen, ob ein bestimmter Teilstring existiert. Methoden umfassen indexOf(), lastIndexOf(), startsWith(), endsWith(), includes(), match(), matchAll(), und search()
• Zusammensetzung: Strings in einen längeren String kombinieren. Methoden umfassen padStart(), padEnd(), concat(), und repeat().
• Zerlegung: Einen String in kleinere Strings aufteilen. Methoden umfassen split(), slice(), substring(), substr(), trim(), trimStart(), und trimEnd().
• Transformation: Einen neuen String basierend auf dem Inhalt des aktuellen Strings zurückgeben. Methoden umfassen toLowerCase(), toUpperCase(), toLocaleLowerCase(), toLocaleUpperCase(), normalize(), und toWellFormed().

Beim Arbeiten mit Strings gibt es zwei weitere Objekte, die wichtige Funktionalität für die String-Manipulation bieten: RegExp und Intl. Sie werden in regulären Ausdrücken und Internationalisierung eingeführt.

Template-Literale sind String-Literale, die eingebettete Ausdrücke erlauben. Sie können mehrzeilige Strings und String-Interpolationsfunktionen mit ihnen verwenden.

Template-Literale werden von Backtick-Zeichen (Gravis) (`) anstelle von doppelten oder einfachen Anführungszeichen umschlossen. Template-Literale können Platzhalter enthalten. Diese werden durch das Dollarzeichen und geschweifte Klammern (${expression}) angezeigt.

Alle in den Quellcode eingefügten Zeilenumbruchzeichen sind Teil des Template-Literals. Mit normalen Strings müssten Sie die folgende Syntax verwenden, um mehrzeilige Strings zu erhalten:

console.log(
  "string text line 1\n\
string text line 2",
);
// "string text line 1
// string text line 2"

Um denselben Effekt mit mehrzeiligen Strings zu erzielen, können Sie nun schreiben:

console.log(`string text line 1
string text line 2`);
// "string text line 1
// string text line 2"

Um Ausdrücke innerhalb normaler Strings einzubetten, würden Sie die folgende Syntax verwenden:

const five = 5;
const ten = 10;
console.log(
  "Fifteen is " + (five + ten) + " and not " + (2 * five + ten) + ".",
);
// "Fifteen is 15 and not 20."

Jetzt, mit Template-Literalen, können Sie die syntaktische Vereinfachung verwenden, um solche Substitutionen lesbarer zu machen:

const five = 5;
const ten = 10;
console.log(`Fifteen is ${five + ten} and not ${2 * five + ten}.`);
// "Fifteen is 15 and not 20."

Für weitere Informationen, lesen Sie über Template-Literale in der JavaScript-Referenz.

• Zurück
• Weiter