Zahlen und Zeichenfolgen

In JavaScript werden Zahlen im Double-Precision 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 Genauigkeit von 53 Bits). Ganze Zahlen bis zu ±2^53 − 1 können exakt dargestellt werden.

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

Siehe auch JavaScript-Datentypen und -Strukturen für den Kontext mit anderen primitiven Typen in JavaScript.

Es können vier Arten von Zahlenliteralen verwendet werden: dezimal, binär, oktal und hexadezimal.

1234567890
42

Dezimalliterale können mit einer Null (0) beginnen, gefolgt von einer weiteren Dezimalziffer. Wenn alle Ziffern nach der führenden 0 kleiner als 8 sind, wird die Zahl als Oktalzahl interpretiert. Dies wird als veraltete Syntax angesehen, und Zahlenliterale mit einer führenden 0 verursachen einen Syntaxfehler im Strict Mode — verwenden Sie stattdessen das Präfix 0o.

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

Die Syntax für Binärzahlen verwendet eine führende Null, gefolgt von einem kleinen oder großen lateinischen Buchstaben "B" (0b oder 0B). Wenn die Ziffern nach der 0b keine 0 oder 1 sind, wird der folgende SyntaxError ausgelöst: "Missing binary digits after 0b".

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

Die Standardsyntax für Oktalzahlen besteht darin, sie mit 0o zu präfixieren. Zum Beispiel:

0O755 // 493
0o644 // 420

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

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

Der Strict Mode verbietet diese Oktalsyntax.

Die Hexadezimalsyntax 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: "Identifier starts immediately after numeric literal".

0xFFFFFFFFFFFFFFFFF // 295147905179352830000
0x123456789ABCDEF   // 81985529216486900
0XA                 // 10

Das eingebaute Number-Objekt hat Eigenschaften für numerische Konstanten, wie zum Beispiel den Maximalwert, "not-a-number" und Unendlichkeit. Sie können die Werte dieser Eigenschaften nicht ändern und 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 selbst erstellten Number-Objekts.

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

Der Number-Prototyp bietet Methoden für die Informationsabfrage von Number-Objekten in verschiedenen Formaten. Die folgende Tabelle fasst die Methoden von Number.prototype zusammen.

Das eingebaute Math-Objekt bietet Eigenschaften und Methoden für mathematische Konstanten und Funktionen. Zum Beispiel hat die PI-Eigenschaft des Math-Objekts den Wert von Pi (3.141…), den Sie in einer Anwendung wie folgt verwenden würden:

Math.PI;

Ähnlich sind Standard-Mathematikfunktionen Methoden von Math. Dazu gehören trigonometrische, logarithmische, exponentielle und andere Funktionen. Wenn Sie zum Beispiel die trigonometrische Funktion Sinus verwenden möchten, würden Sie schreiben:

Math.sin(1.56);

Beachten Sie, dass alle trigonometrischen Methoden von Math Argumente im Bogenmaß erfordern.

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

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

Ein Nachteil von Zahlenwerten ist, dass sie nur 64 Bits haben. In der Praxis können sie aufgrund der Verwendung der IEEE 754-Kodierung keine ganze Zahl größer als Number.MAX_SAFE_INTEGER (was 2⁵³ - 1 ist) genau darstellen. Um das Bedürfnis nach der Kodierung von Binärdaten zu lösen und um mit anderen Sprachen zusammenzuarbeiten, die breite Ganzzahlen wie i64 (64-Bit-Ganzzahlen) und i128 (128-Bit-Ganzzahlen) anbieten, bietet JavaScript auch einen anderen Datentyp zur Darstellung von beliebig großen ganzen Zahlen: BigInt.

Ein BigInt kann als Ganzzahlliteral definiert werden, das mit n versehen ist:

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

BigInts können auch aus Zahlenwerten oder Zeichenfolgenwerten unter Verwendung 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 Bitfolge, die eine ganze Zahl kodiert. Sie können sicher alle arithmetischen Operationen durchführen, ohne Präzision zu verlieren oder Über-/Unterlauf zu haben.

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

Im Vergleich zu Zahlen liefern BigInt-Werte eine höhere Präzision bei der Darstellung großer ganzer Zahlen; sie können jedoch keine Gleitkommazahlen 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. Es gibt einen offenen Vorschlag, bestimmte Math-Funktionen wie Math.max() zu überladen, um BigInt-Werte zuzulassen.

Die Entscheidung zwischen BigInt und Zahl hängt von Ihrem Anwendungsfall und dem Bereich Ihrer Eingaben ab. Die Präzision von Zahlen sollte bereits die meisten alltäglichen Aufgaben bewältigen können, und BigInts sind am besten geeignet für die Handhabung von Binärdaten.

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

Der JavaScript-String-Typ wird verwendet, um Textdaten darzustellen. Es ist eine Menge von "Elementen" von 16-Bit-Unsigned-Integer-Werten (UTF-16-Codeeinheiten). Jedes Element in der Zeichenfolge nimmt eine Position in der Zeichenfolge ein. Das erste Element befindet sich an Index 0, das nächste an Index 1 und so weiter. Die Länge einer Zeichenfolge ist die Anzahl der Elemente in ihr. Sie können Zeichenfolgen mit Zeichenfolgenliteralen oder Zeichenfolgenobjekten erstellen.

Sie können in Quellcodezeichenfolgen entweder mit einfachen oder doppelten Anführungszeichen deklarieren:

'foo'
"bar"

In einem Zeichenfolgenliteral können die meisten Zeichen direkt eingegeben werden. Die einzigen Ausnahmen bilden der Rückschrägstrich (\, der eine Escape-Sequenz beginnt), das Anführungszeichen, das verwendet wird, um die Zeichenfolge einzuschließen, welches die Zeichenfolge beendet, und das Zeilenumbruchzeichen, das einen Syntaxfehler verursacht, wenn es nicht durch einen Rückschrägstrich vorangestellt ist.

Komplexere Zeichenfolgen können mit Escape-Sequenzen erstellt werden:

Hexadezimale Escape-Sequenzen

Die Zahl nach \x wird als Hexadezimal-Zahl interpretiert.

"\xA9" // "©"

Unicode-Escape-Sequenzen

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

"\u00A9" // "©"

Unicode-Codpunkte-Escapes

Mit Unicode-Codpunkt-Escapes kann jedes Zeichen unter Verwendung von Hexadezimalzahlen maskiert werden, sodass es möglich ist, Unicode-Codpunkte bis zu 0x10FFFF zu verwenden. Mit den vierstelligen Unicode-Escapes ist es oft notwendig, getrennte Surrogat-Hälften zu schreiben, um das gleiche 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 Zeichenfolgenwert aufrufen:

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

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

• Abfrage: Erhalten Sie das Zeichen oder den Zeichencode an einem bestimmten Zeichenfolgenindex. Methoden umfassen at(), charAt(), charCodeAt(), und codePointAt().
• Suche: Erhalten Sie Informationen über ein Teilzeichenfolge, das einem Muster entspricht, oder prüfen Sie, ob eine bestimmte Teilzeichenfolge existiert. Methoden umfassen indexOf(), lastIndexOf(), startsWith(), endsWith(), includes(), match(), matchAll(), und search().
• Zusammensetzung: Kombinieren Sie Zeichenfolgen zu einer längeren Zeichenfolge. Methoden umfassen padStart(), padEnd(), concat(), und repeat().
• Zerlegung: Zerlegen Sie eine Zeichenfolge in kleinere Zeichenfolgen. Methoden umfassen split(), slice(), substring(), substr(), trim(), trimStart(), und trimEnd().
• Transformation: Geben Sie eine neue Zeichenfolge basierend auf dem Inhalt der aktuellen Zeichenfolge zurück. Methoden umfassen toLowerCase(), toUpperCase(), toLocaleLowerCase(), toLocaleUpperCase(), normalize(), und toWellFormed().

Beim Arbeiten mit Zeichenfolgen gibt es zwei weitere Objekte, die wichtige Funktionalitäten für die Zeichenfolgenmanipulation bieten: RegExp und Intl. Sie werden in Reguläre Ausdrücke und Internationalisierung eingeführt.

Template-Literale sind Zeichenfolgenliterale mit eingebetteten Ausdrücken. Sie können mehrzeilige Zeichenfolgen und Funktionen zur Zeichenfolgeninterpolation mit ihnen verwenden.

Template-Literale werden durch Backticks (Gravis-Akzent) (`) anstelle von doppelten oder einfachen Anführungszeichen eingeschlossen. Template-Literale können Platzhalter enthalten, die durch das Dollarzeichen und geschweifte Klammern (${expression}) angezeigt werden.

Alle im Quelltext eingefügten Zeilenumbrüche sind Bestandteil des Template-Literals. Bei normalen Zeichenfolgen müssten Sie die folgende Syntax verwenden, um mehrzeilige Zeichenfolgen zu erhalten:

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

Um den gleichen Effekt mit mehrzeiligen Zeichenfolgen zu erzielen, können Sie jetzt schreiben:

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

Zum Einbetten von Ausdrücken in normalen Zeichenfolgen 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 können Sie mit Template-Literalen die syntaktische Vereinfachung nutzen, 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 Template-Literale in der JavaScript-Referenz.

• Zurück
• Weiter