Zahlen und Zeichenfolgen

In JavaScript werden Zahlen im doppelter Genauigkeit 64-Bit-Binärformat IEEE 754 (d.h. eine Zahl zwischen ±2^−1022 und ±2^+1023, oder etwa ±10^−308 bis ±10^+308, mit einer numerischen Genauigkeit von 53 Bits) implementiert. Ganzzahlwerte bis ±2^53 − 1 können genau 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.

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

1234567890
42

Dezimalliterale können mit einer Null (0) beginnen, gefolgt von einer weiteren Dezimalziffer, aber 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 Zahl-Literale, die mit 0 beginnen, ob als Oktal oder Dezimal interpretiert, 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 Binärzahlsyntax 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ärziffern nach 0b".

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

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

0O755 // 493
0o644 // 420

Es gibt auch eine ältere Syntax für Oktalzahlen — durch Voranstellen der Oktalzahl mit einer Null: 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

Strict Mode verbietet diese Oktalsyntax.

Die Hexadezimalzahlsyntax 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 unmittelbar nach numerischem Literal".

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

Das eingebaute Number-Objekt verfügt über Eigenschaften für numerische Konstanten, wie den maximalen Wert, nicht-eine-Zahl 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 als Eigenschaft eines eigens erstellten Number-Objekts.

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 verfügt über 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 können:

Math.PI;

Ebenso sind Standardmathematikfunktionen Methoden von Math. Dazu gehören trigonometrische, logarithmische, exponentielle und andere Funktionen. Zum Beispiel, wenn Sie 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 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-Codierung keine größere Ganzzahl als Number.MAX_SAFE_INTEGER (was 2⁵³ - 1 ist) genau darstellen. Um das Bedürfnis nach der Codierung binärer Daten zu erfüllen und mit anderen Sprachen zu interagieren, die breite Ganzzahlen wie i64 (64-Bit-Ganzzahlen) und i128 (128-Bit-Ganzzahlen) anbieten, bietet JavaScript einen weiteren Datentyp zur Darstellung beliebig großer Ganzzahlen: BigInt.

Ein BigInt kann als Ganzzahlliteral definiert werden, das mit n angehängt 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 Folge von Bits, die eine Ganzzahl kodiert. Sie können sicher arithmetische Operationen durchführen, ohne Präzision zu verlieren oder Über-/Unterläufe zu verursachen.

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 Ganzzahlen; sie können jedoch keine Gleitkommazahlen darstellen. Beispielsweise würde die Division auf null runden:

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

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

Die Wahl zwischen BigInt und Zahl hängt von Ihrem Anwendungsfall und dem Bereich Ihrer Eingabewerte ab. Die Präzision von Zahlen sollte bereits für die meisten alltäglichen Aufgaben ausreichend sein, und BigInts sind am besten geeignet, um mit binären Daten umzugehen.

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 verwendet, um Textdaten darzustellen. Er ist eine Menge von "Elementen" 16-Bit-Unterschriftswerten (UTF-16-Codeeinheiten). Jedes Element in der Zeichenfolge nimmt eine Position in der Zeichenfolge ein. Das erste Element befindet sich bei Index 0, das nächste bei Index 1 und so weiter. Die Länge einer Zeichenfolge ist die Anzahl der Elemente darin. Sie können Zeichenfolgen mit Zeichenfolgenliteralen oder Zeichenfolgenobjekten erstellen.

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

'foo'
"bar"

Innerhalb eines Zeichenfolgenliterals können die meisten Zeichen buchstäblich eingegeben werden. Die einzigen Ausnahmen sind der Rückschrägstrich (\, der eine Escape-Sequenz startet), das Zeichen des Anführungszeichens, das für die Umrahmung der Zeichenfolge verwendet wird, was die Zeichenfolge beendet, und das Zeilenumbruchzeichen, das einen Syntaxfehler verursacht, wenn es nicht von einem Rückschrägstrich gefolgt wird.

Fortgeschrittenere Zeichenfolgen können unter Verwendung von 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 Hexadezimalziffern nach \u.

"\u00A9" // "©"

Unicode-Codepunkt-Escape-Sequenzen

Mit Unicode-Codepunkt-Escape-Sequenzen kann jedes Zeichen unter Verwendung von Hexadezimalzahlen ausgetauscht werden, sodass es möglich ist, Unicode-Codepoints bis zu 0x10FFFF zu verwenden. Mit den vierstelligen Unicode-Escapes ist es oft erforderlich, die Surrogate-Hälften separat 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, die einem Muster entspricht, oder testen Sie, ob eine bestimmte Teilzeichenfolge existiert. Methoden umfassen indexOf(), lastIndexOf(), startsWith(), endsWith(), includes(), match(), matchAll() und search()
• Zusammensetzung: Verbinden 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: Erhalten Sie eine neue Zeichenfolge basierend auf dem Inhalt der aktuellen Zeichenfolge. Methoden umfassen toLowerCase(), toUpperCase(), toLocaleLowerCase(), toLocaleUpperCase(), normalize() und toWellFormed().

Beim Arbeiten mit Zeichenfolgen gibt es zwei andere Objekte, die wichtige Funktionalität zur Zeichenfolgenmanipulation bieten: RegExp und Intl. Sie werden in reguläre Ausdrücke und Internationalisierung eingeführt.

Template Literale sind Zeichenfolgenliterale, die eingebettete Ausdrücke ermöglichen. Sie können mehrzeilige Zeichenfolgen und Zeichenfolgeninterpolations-Funktionen mit ihnen verwenden.

Template Literale werden von Backtick-Zeichen (Gravis) (`) 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 in die Quelle eingefügten Zeilenumbrüche sind Teil des Template Literals. Bei der Verwendung normaler Zeichenfolgen müssten Sie 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"

Um Ausdrücke in normale Zeichenfolgen einzubetten, würden Sie 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 Zuckermethode nutzen, um solche Ersetzungen 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 im JavaScript-Referenz.

• Zurück
• Weiter