HTML: Markup language
CSS: Styling language
JavaScript: Scripting language
Web APIs: Programming interfaces
All web technology
Learn web development
Discover our tools
Get to know MDN better
Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.
View in English Always switch to English
In diesem Kapitel werden die beiden grundlegendsten Datentypen in JavaScript vorgestellt: Zahlen und Zeichenfolgen. Wir erläutern ihre zugrunde liegenden Darstellungen und die Funktionen, die verwendet werden, um mit ihnen zu arbeiten und Berechnungen durchzuführen.
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 Bit). Ganze Zahlen bis zu ±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).
Infinity
-Infinity
NaN
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
Dezimale Literale können mit einer Null (0) beginnen, gefolgt von einer anderen 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 Zahlenliterale, die mit 0 beginnen, ob als Oktal oder Dezimal interpretiert, verursachen in Strict Mode einen Syntaxfehler — verwenden Sie stattdessen das Präfix 0o.
0
0o
0888 // 888 parsed as decimal 0777 // parsed as octal, 511 in decimal
Die Binärzahlensyntax verwendet eine führende Null, gefolgt von einem Klein- oder Groß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".
0b
0B
SyntaxError
0b10000000000000000000000000000000 // 2147483648 0b01111111100000000000000000000000 // 2139095040 0B00000000011111111111111111111111 // 8388607
Die Standardsyntax für Oktalzahlen besteht darin, sie mit 0o zu prefixen. Zum Beispiel:
0O755 // 493 0o644 // 420
Es gibt auch eine veraltete Syntax für Oktalzahlen — indem man die Oktalzahl mit einer Null prefixed: 0644 === 420 und "\045" === "%". Wenn die Ziffern nach dem 0 außerhalb des Bereichs 0 bis 7 liegen, wird die Zahl als Dezimalzahl interpretiert.
0644 === 420
"\045" === "%"
const n = 0755; // 493 const m = 0644; // 420
Strict Mode verbietet diese Oktalsyntax.
Hexadezimalzahlensyntax verwendet eine führende Null, gefolgt von einem Klein- oder Großbuchstaben "X" (0x oder 0X). Wenn die Ziffern nach 0x außerhalb des Bereichs (0123456789ABCDEF) liegen, wird der folgende SyntaxError ausgelöst: "Kennung beginnt direkt nach dem numerischen Literal".
0x
0X
0xFFFFFFFFFFFFF // 4503599627370495 0xabcdef123456 // 188900967593046 0XA // 10
0e-5 // 0 0e+5 // 0 5e1 // 50 175e-2 // 1.75 1e3 // 1000 1e-3 // 0.001 1E3 // 1000
Für alle oben gezeigten Literal-Syntaxen kann ein Unterstrich (_) zwischen Ziffern eingefügt werden, um die Lesbarkeit zu verbessern.
_
1_000_000_000_000 1_050.95 0b1010_0001_1000_0101 0o2_2_5_6 0xA0_B0_C0 1_000_000_000_000_000_000_000n
Siehe die Referenz Lexikalische Grammatik für weitere Details zu Zahlenliteralen.
Das eingebaute Number-Objekt hat Eigenschaften für numerische Konstanten, wie z.B. maximaler Wert, Not-a-Number und Unendlichkeit. Sie können die Werte dieser Eigenschaften nicht ändern und verwenden sie folgendermaßen:
Number
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.
Number.MAX_VALUE
1.7976931348623157e+308
Number.MIN_VALUE
5e-324
Number.NaN
Number.NEGATIVE_INFINITY
Number.POSITIVE_INFINITY
Number.EPSILON
1
2.220446049250313e-16
Number.MIN_SAFE_INTEGER
−9007199254740991
Number.MAX_SAFE_INTEGER
+9007199254740991
Number.parseFloat()
parseFloat()
Number.parseInt()
parseInt()
Number.isFinite()
Number.isInteger()
Number.isNaN()
isNaN()
Number.isSafeInteger()
Das Number-Prototyp stellt Methoden zum Abrufen von Informationen von Number-Objekten in verschiedenen Formaten bereit. Die folgende Tabelle fasst die Methoden von Number.prototype zusammen.
Number.prototype
toExponential()
toFixed()
toPrecision()
Das eingebaute Math-Objekt verfügt über Eigenschaften und Methoden für mathematische Konstanten und Funktionen. Zum Beispiel hat die Math-Eigenschaft PI den Wert von Pi (3.141…), den Sie in einer Anwendung folgendermaßen verwenden würden:
Math
PI
Math.PI;
Ebenso sind Standardmathematische Funktionen Methoden von Math. Dazu gehören 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ß verwenden.
Die folgende Tabelle fasst die Methoden des Math-Objekts zusammen.
abs()
sin()
cos()
tan()
asin()
acos()
atan()
atan2()
sinh()
cosh()
tanh()
asinh()
acosh()
atanh()
pow(), exp(), expm1(), log(), log10(), log1p(), log2()
pow()
exp()
expm1()
log()
log10()
log1p()
log2()
floor()
ceil()
min()
max()
random()
round()
fround()
trunc()
sqrt()
cbrt()
hypot()
sign()
clz32()
imul()
Im Gegensatz zu vielen anderen Objekten erstellen Sie niemals ein eigenes Math-Objekt. Sie verwenden immer das eingebaute Math-Objekt.
Ein Manko von Zahlenwerten ist, dass sie nur 64 Bit umfassen. In der Praxis können sie aufgrund der Verwendung des IEEE 754-Codings keine ganze Zahl genau darstellen, die größer als Number.MAX_SAFE_INTEGER (was 253 - 1 ist) ist. Um das Bedürfnis nach der Codierung von Binärdaten zu lösen und mit anderen Sprachen, die große Ganzzahlen wie i64 (64-Bit-Ganzzahlen) und i128 (128-Bit-Ganzzahlen) bieten, zu interagieren, bietet JavaScript einen weiteren Datentyp zur Darstellung von beliebig großen Ganzzahlen: BigInt.
i64
i128
BigInt
Ein BigInt kann als Ganzzahlenliteral definiert werden, das mit n postfixiert wird:
n
const b1 = 123n; // Can be arbitrarily large. const b2 = -1234567890987654321n;
BigInts können auch aus Zahlenwerten oder Zeichenfolgenwerten konstruiert werden, indem der BigInt Konstruktor verwendet wird.
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 ganze Zahl kodiert. Sie können sicher alle arithmetischen 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 ganzer Zahlen; sie können jedoch keine Gleitkommazahlen darstellen. Zum Beispiel würde eine Division auf null gerundet:
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 Auswahl zwischen BigInt und Number hängt von Ihrem Anwendungsfall und dem Bereich Ihrer Eingabe 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 zum Umgang mit Binärdaten geeignet.
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. Er ist eine Menge von "Elementen" von 16-Bit vorzeichenlosen Integer-Werten (UTF-16-Codeeinheiten). Jedes Element im String nimmt eine Position im String ein. Das erste Element befindet sich an Index 0, das nächste an Index 1, und so weiter. Die Länge eines Strings ist die Anzahl der Elemente darin. Sie können Zeichenfolgen mithilfe von Zeichenfolgenliteralen oder Zeichenfolgenobjekten erstellen.
Sie können Zeichenfolgen im Quellcode unter Verwendung von einfachen oder doppelten Anführungszeichen deklarieren:
'foo' "bar"
Innerhalb eines Zeichenfolgenliterals können die meisten Zeichen wörtlich eingegeben werden. Die einzigen Ausnahmen sind der Rückwärtsschrägstrich (\, der eine Escape-Sequenz startet), das Anführungszeichen, das zur Umfassung des Strings verwendet wird und ihn beendet, und das Zeilenumbruchzeichen, das einen Syntaxfehler verursacht, wenn es nicht von einem Rückwärtsschrägstrich gefolgt wird.
\
Komplexere Zeichenfolgen können mithilfe von Escape-Sequenzen erstellt werden:
Die Zahl nach \x wird als hexadezimale Zahl interpretiert.
"\xA9" // "©"
Die Unicode-Escape-Sequenzen erfordern mindestens vier hexadezimale Ziffern nach \u.
\u
"\u00A9" // "©"
Mit Unicode-Codepoint-Escapes kann jedes Zeichen unter Verwendung hexadezimaler Zahlen so maskiert werden, dass es möglich ist, Unicode-Codepunkte bis zu 0x10FFFF zu verwenden. Mit den vierstelligen Unicode-Escapes ist es oft notwendig, die Surrogathälften separat zu schreiben, um das gleiche Ergebnis zu erzielen.
0x10FFFF
Siehe auch String.fromCodePoint() oder String.prototype.codePointAt().
String.fromCodePoint()
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:
String
at()
charAt()
charCodeAt()
codePointAt()
indexOf()
lastIndexOf()
startsWith()
endsWith()
includes()
match()
matchAll()
search()
padStart()
padEnd()
concat()
repeat()
split()
slice()
substring()
substr()
trim()
trimStart()
trimEnd()
toLowerCase()
toUpperCase()
toLocaleLowerCase()
toLocaleUpperCase()
normalize()
toWellFormed()
Beim Arbeiten mit Zeichenfolgen gibt es zwei weitere Objekte, die wichtige Funktionen zur Zeichenfolgenmanipulation bereitstellen: RegExp und Intl. Sie werden in Regulären Ausdrücken und Internationalisierung vorgestellt.
RegExp
Intl
Template-Literale sind Zeichenfolgenliterale, die eingebettete Ausdrücke ermöglichen. Sie können sie für mehrzeilige Zeichenfolgen und Stringinterpolation verwenden.
Template-Literale werden durch Backticks (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.
${expression}
Alle in den Quellcode eingefügten Zeilenumbrüche sind Teil 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 denselben 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 innerhalb normaler Zeichenfolgen 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."
Mit Template-Literalen können Sie nun das syntaktische Zucker 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."
Weitere Informationen finden Sie unter Template-Literale im JavaScript-Referenz.