Zahlen und Zeichenketten

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 Genauigkeit von 53 Bits). Ganzzahlen 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.

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 eine veraltete Syntax betrachtet, und Zahlenliterale, die mit 0 beginnen, ob nun als oktal oder dezimal interpretiert, verursachen in Strict Mode einen Syntaxfehler — daher 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 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, ihnen das Präfix 0o voranzustellen. Zum Beispiel:

0O755 // 493
0o644 // 420

Es gibt auch eine veraltete 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 von 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: "Identifier beginnt unmittelbar nach numerischem Literal".

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

Das eingebaute Number-Objekt hat Eigenschaften für numerische Konstanten, wie maximaler Wert, 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 als eine Eigenschaft eines Number-Objekts, das Sie selbst erstellen.

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

Das Number-Prototyp bietet Methoden zum Abrufen von Informationen aus Number-Objekten in verschiedenen Formaten. 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. 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 Standardmathematische 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 Bogenmaß nehmen.

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 ganze Zahl, die größer ist als Number.MAX_SAFE_INTEGER (was 2⁵³ - 1 ist), genau darstellen. Um das Bedürfnis nach der Codierung von Binärdaten zu erfüllen und mit anderen Sprachen zu interagieren, die breite Ganzzahlen wie i64 (64-Bit-Ganzzahlen) und i128 (128-Bit-Ganzzahlen) bieten, bietet JavaScript auch einen anderen Datentyp zur Darstellung beliebig großer Ganzzahlen: BigInt.

Ein BigInt kann als Ganzzahlliteral mit einem nachgestellten n definiert werden:

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

BigInts können auch aus Zahlenwerten oder Zeichenkettenwerten 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 nur eine beliebig lange Sequenz von Bits, die eine Ganzzahl codiert. Sie können beliebige arithmetische Operationen sicher ohne Präzisionsverlust oder Über-/Unterlauf durchführen.

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, wenn es um die Darstellung großer Ganzzahlen geht; 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, um bestimmte Math-Funktionen wie Math.max() zu überladen, um BigInt-Werte zuzulassen.

Die Wahl zwischen BigInt und Zahl hängt von Ihrem Anwendungsfall und dem Bereich Ihrer Eingaben ab. Die Präzision der Zahlen sollte in der Lage sein, die meisten alltäglichen Aufgaben bereits zu bewältigen, und BigInts eignen sich am besten zur Handhabung binärer Daten.

Lesen Sie mehr darüber, was Sie mit BigInt-Werten tun können, in dem 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" von 16-Bit-unsigned-Integer-Werten (UTF-16 Code-Einheiten). Jedes Element in der String hat eine Position in der String. Das erste Element befindet sich an Index 0, das nächste an Index 1 und so weiter. Die Länge einer String ist die Anzahl der Elemente in ihr. Sie können Strings unter Verwendung von String-Literalen oder String-Objekten erstellen.

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

'foo'
"bar"

Innerhalb eines String-Literals können die meisten Zeichen im wahrsten Sinne eingegeben werden. Die einzigen Ausnahmen sind der Backslash (\, der eine Escape-Sequenz beginnt), das Anführungszeichen, das zur Umschließung der String verwendet wird und die String beendet, und das Newline-Zeichen, das einen Syntaxfehler verursacht, wenn es nicht von einem Backslash gefolgt wird.

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

Hexadezimale Escape-Sequenzen

Die Zahl nach \x wird als hexadezimale Zahl interpretiert.

"\xA9" // "©"

Unicode-Escape-Sequenzen

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

"\u00A9" // "©"

Unicode-Codepoint-Escapes

Mit Unicode-Codepoint-Escapes kann jedes Zeichen unter Verwendung hexadezimaler Zahlenmaskierung so entkommen werden, dass die Verwendung von Unicode-Codepoints bis zu 0x10FFFF möglich ist. 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 Abrufen des Buchstabens oder Buchstabencodes an einem bestimmten String-Index. Methoden umfassen at(), charAt(), charCodeAt(), und codePointAt().
• Suche: Holen Sie Informationen über ein Teilstring, das einem Muster entspricht, oder testen Sie, ob ein bestimmtes Teilstring existiert. Methoden umfassen indexOf(), lastIndexOf(), startsWith(), endsWith(), includes(), match(), matchAll(), und search().
• Komposition: Kombinieren Sie Strings zu einem längeren String. Methoden umfassen padStart(), padEnd(), concat(), und repeat().
• Dekomposition: Teilen Sie eine String in kleinere Strings auf. Methoden umfassen split(), slice(), substring(), substr(), trim(), trimStart(), und trimEnd().
• Transformation: Gibt eine neue String zurück, basierend auf dem Inhalt des aktuellen Strings. Methoden umfassen toLowerCase(), toUpperCase(), toLocaleLowerCase(), toLocaleUpperCase(), normalize(), und toWellFormed().

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

Template-Literale sind String-Literale, die eingebettete Ausdrücke zulassen. Sie können mehrzeilige Strings und String-Interpolation mit ihnen nutzen.

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

Jede in der Quelle eingefügte neue Zeilenzeichen 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 jetzt 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 können Sie mit Template-Literalen syntaktischen Zucker wie diesen verwenden, um 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 mehr Informationen, lesen Sie über Template-Literale im JavaScript-Referenz.

• Zurück
• Weiter