String
Baseline Widely available *
This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.
* Some parts of this feature may have varying levels of support.
Das String
-Objekt wird verwendet, um eine Zeichenkette darzustellen und zu manipulieren.
Beschreibung
Strings sind nützlich, um Daten zu halten, die in Textform dargestellt werden können. Einige der am häufigsten verwendeten Operationen an Strings sind das Überprüfen ihrer Länge
, das Erstellen und Konkatenieren von ihnen mithilfe der +
und +=
String-Operatoren, das Überprüfen auf das Vorhandensein oder den Standort von Teilstrings mit der indexOf()
-Methode oder das Extrahieren von Teilstrings mit der substring()
-Methode.
Erstellen von Strings
Strings können als Primitiven, aus String-Literalen oder als Objekte mithilfe des String()
Konstruktors erstellt werden:
const string1 = "A string primitive";
const string2 = 'Also a string primitive';
const string3 = `Yet another string primitive`;
const string4 = new String("A String object");
String-Primitiven und String-Objekte teilen viele Verhaltensweisen, haben jedoch andere wichtige Unterschiede und Vorbehalte. Siehe "String-Primitiven und String-Objekte" unten.
String-Literale können mit einfachen oder doppelten Anführungszeichen angegeben werden, die identisch behandelt werden, oder mit dem Backtick-Zeichen `. Diese letzte Form spezifiziert ein Template Literal: Mit dieser Form können Sie Ausdrücke interpolieren. Weitere Informationen zur Syntax von String-Literalen finden Sie in der lexikalischen Grammatik.
Zeichenzugriff
Es gibt zwei Möglichkeiten, auf ein einzelnes Zeichen in einem String zuzugreifen. Die erste ist die charAt()
-Methode:
"cat".charAt(1); // gives value "a"
Die andere Möglichkeit besteht darin, den String als array-ähnliches Objekt zu behandeln, wobei einzelne Zeichen einem numerischen Index entsprechen:
"cat"[1]; // gives value "a"
Beim Verwenden von Klammernotation für den Zeichenzugriff wird der Versuch, diesen Eigenschaften einen Wert zu löschen oder zuzuweisen, nicht erfolgreich sein. Die beteiligten Eigenschaften sind weder beschreibbar noch konfigurierbar. (Siehe Object.defineProperty()
für weitere Informationen.)
Vergleichen von Strings
Verwenden Sie die kleiner-als und größer-als Operatoren, um Strings zu vergleichen:
const a = "a";
const b = "b";
if (a < b) {
// true
console.log(`${a} is less than ${b}`);
} else if (a > b) {
console.log(`${a} is greater than ${b}`);
} else {
console.log(`${a} and ${b} are equal.`);
}
Beachten Sie, dass alle Vergleichsoperatoren, einschließlich ===
und ==
, Strings streng fallsensitiv vergleichen. Eine übliche Methode, um Strings ohne Berücksichtigung der Groß- und Kleinschreibung zu vergleichen, besteht darin, beide vorher in den gleichen Fall (Groß- oder Kleinschreibung) zu konvertieren.
function areEqualCaseInsensitive(str1, str2) {
return str1.toUpperCase() === str2.toUpperCase();
}
Die Entscheidung, ob mit toUpperCase()
oder toLowerCase()
transformiert wird, ist meist willkürlich, und keine der beiden ist vollständig robust, wenn sie über das lateinische Alphabet hinaus erweitert wird. Zum Beispiel werden der deutsche Kleinbuchstabe ß
und ss
beide zu SS
durch toUpperCase()
transformiert, während der türkische Buchstabe ı
fälschlicherweise als ungleich zu I
durch toLowerCase()
berichtet würde, es sei denn, er wird speziell mit toLocaleLowerCase("tr")
verwendet.
const areEqualInUpperCase = (str1, str2) =>
str1.toUpperCase() === str2.toUpperCase();
const areEqualInLowerCase = (str1, str2) =>
str1.toLowerCase() === str2.toLowerCase();
areEqualInUpperCase("ß", "ss"); // true; should be false
areEqualInLowerCase("ı", "I"); // false; should be true
Eine lokalsensible und robuste Lösung für den test auf Fallinsensitive Gleichheit bietet die Intl.Collator
API oder die localeCompare()
Methode des Strings – beide teilen das gleiche Interface – mit der sensitivity
Option auf "accent"
oder "base"
gesetzt.
const areEqual = (str1, str2, locale = "en-US") =>
str1.localeCompare(str2, locale, { sensitivity: "accent" }) === 0;
areEqual("ß", "ss", "de"); // false
areEqual("ı", "I", "tr"); // true
Die localeCompare()
-Methode ermöglicht den Stringvergleich ähnlich wie strcmp()
– sie erlaubt das Sortieren von Strings in einer lokalsensiblen Art und Weise.
String-Primitiven und String-Objekte
Beachten Sie, dass JavaScript zwischen String
-Objekten und primitiven Strings unterscheidet. (Dasselbe gilt für Boolean
und Numbers
.)
String-Literale (gekennzeichnet durch doppelte oder einfache Anführungszeichen) und Strings, die von String
-Aufrufen in einem Nicht-Konstruktor-Kontext zurückgegeben werden (also aufgerufen, ohne das new
Schlüsselwort zu verwenden), sind primitive Strings. In Kontexten, in denen eine Methode aufgerufen oder eine Eigenschaftsabfrage für einen primitiven String durchgeführt werden soll, wird JavaScript automatisch das String-Primitiv umwickeln und die Methode aufrufen oder die Eigenschaftsabfrage am Wrapper-Objekt durchführen.
const strPrim = "foo"; // A literal is a string primitive
const strPrim2 = String(1); // Coerced into the string primitive "1"
const strPrim3 = String(true); // Coerced into the string primitive "true"
const strObj = new String(strPrim); // String with new returns a string wrapper object.
console.log(typeof strPrim); // "string"
console.log(typeof strPrim2); // "string"
console.log(typeof strPrim3); // "string"
console.log(typeof strObj); // "object"
Warnung:
Sie sollten selten String
als Konstruktor verwenden.
String-Primitiven und String
-Objekte liefern auch unterschiedliche Ergebnisse bei der Verwendung von eval()
. Primitive, die an eval()
übergeben werden, werden als Quellcode behandelt; String
-Objekte werden wie alle anderen Objekte behandelt, indem das Objekt zurückgegeben wird. Zum Beispiel:
const s1 = "2 + 2"; // creates a string primitive
const s2 = new String("2 + 2"); // creates a String object
console.log(eval(s1)); // returns the number 4
console.log(eval(s2)); // returns the string "2 + 2"
Aus diesen Gründen kann der Code brechen, wenn String
-Objekte auf {primitive} Strings treffen sollen, auch wenn Autoren im Allgemeinen nicht auf die Unterscheidung achten müssen.
Ein String
-Objekt kann immer mit der valueOf()
-Methode in sein primitives Gegenstück konvertiert werden.
console.log(eval(s2.valueOf())); // returns the number 4
String Coercion
Viele eingebaute Operationen, die Strings erwarten, zwingen ihre Argumente zunächst zu Strings (was weitgehend der Grund dafür ist, dass String
-Objekte ähnlich wie String-Primitiven funktionieren). Die Operation kann wie folgt zusammengefasst werden:
- Strings werden unverändert zurückgegeben.
undefined
wird zu"undefined"
.null
wird zu"null"
.true
wird zu"true"
;false
wird zu"false"
.- Zahlen werden mit dem gleichen Algorithmus wie
toString(10)
konvertiert. - BigInts werden mit dem gleichen Algorithmus wie
toString(10)
konvertiert. - Symbole werfen einen
TypeError
. - Objekte werden zunächst in ein Primärwert konvertiert, indem ihre
[Symbol.toPrimitive]()
(mit"string"
als Hinweis),toString()
undvalueOf()
Methoden in dieser Reihenfolge aufgerufen werden. Das resultierende Primärwert wird dann in einen String konvertiert.
Es gibt mehrere Möglichkeiten, fast den gleichen Effekt in JavaScript zu erzielen.
- Template Literal:
`${x}`
macht genau die oben erklärten String-Coercion-Schritte für den eingebetteten Ausdruck. - Die
String()
-Funktion:String(x)
verwendet den gleichen Algorithmus zur Konvertierung vonx
, außer dass Symbole keinenTypeError
werfen, sondern"Symbol(description)"
zurückgeben, wobeidescription
die Beschreibung des Symbols ist. - Verwendung des
+
Operators:"" + x
zwingt seine Operanden auf ein Primärwert anstatt auf einen String, und hat für einige Objekte ein völlig anderes Verhalten als die normale String-Coercion. Siehe die Referenzseite für weitere Details.
Abhängig von Ihrem Anwendungsfall möchten Sie vielleicht `${x}`
(um das eingebaute Verhalten nachzuahmen) oder String(x)
verwenden (um Symbolwerte ohne Fehlerbehandlung zu verarbeiten), sollten aber nicht "" + x
verwenden.
UTF-16-Zeichen, Unicode-Codepunkte und Graphem-Cluster
Strings werden im Wesentlichen als Sequenzen von UTF-16-Codeeinheiten dargestellt. In der UTF-16-Codierung ist jede Codeeinheit genau 16 Bit lang. Dies bedeutet, dass es maximal 216, oder 65536 mögliche Zeichen gibt, die als einzelne UTF-16-Codeeinheiten darstellbar sind. Dieses Zeichensatz wird als Basic Multilingual Plane (BMP) bezeichnet und umfasst die häufigsten Zeichen wie die lateinischen, griechischen und kyrillischen Alphabete sowie viele ostasiatische Zeichen. Jede Codeeinheit kann in einem String mit \u
gefolgt von genau vier Hexadezimalen angegeben werden.
Das gesamte Unicode-Zeichensatz ist jedoch viel, viel größer als 65536. Die zusätzlichen Zeichen werden in UTF-16 als Surrogat-Paare gespeichert, bei denen es sich um Paare von 16-Bit-Codeeinheiten handelt, die ein einzelnes Zeichen darstellen. Um Mehrdeutigkeiten zu vermeiden, müssen die beiden Teile des Paares zwischen 0xD800
und 0xDFFF
liegen, und diese Codeeinheiten werden nicht zur Kodierung einzelner Codeeinheiten verwendet. (Genauer gesagt haben führende Surrogate, auch Hochsurrogate genannt, Werte zwischen 0xD800
und 0xDBFF
, einschließlich, während nachfolgende Surrogate, auch Niedrigsurrogate genannt, Werte zwischen 0xDC00
und 0xDFFF
, einschließlich, haben.) Jedes Unicode-Zeichen, das aus ein oder zwei UTF-16-Codeeinheiten besteht, wird auch als Unicode-Codepunkt bezeichnet. Jeder Unicode-Codepunkt kann in einem String mit \u{xxxxxx}
angegeben werden, wobei xxxxxx
1–6 Hexadezimalwerte darstellt.
Ein "einsames Surrogat" ist eine 16-Bit-Codeeinheit, die eine der folgenden Voraussetzungen erfüllt:
- Sie liegt im Bereich
0xD800
–0xDBFF
, einschließlich (d. h. ist ein führendes Surrogat), aber sie ist die letzte Codeeinheit im String, oder die nächste Codeeinheit ist kein nachfolgendes Surrogat. - Sie liegt im Bereich
0xDC00
–0xDFFF
, einschließlich (d. h. ist ein nachfolgendes Surrogat), aber sie ist die erste Codeeinheit im String, oder die vorherige Codeeinheit ist kein führendes Surrogat.
Einsame Surrogate repräsentieren kein Unicode-Zeichen. Obwohl die meisten eingebauten JavaScript-Methoden sie korrekt handhaben, da sie alle auf UTF-16-Codeeinheiten basieren, sind einsame Surrogate oft keine gültigen Werte beim Interagieren mit anderen Systemen – zum Beispiel wird encodeURI()
einen URIError
für einsame Surrogate auslösen, da die URI-Kodierung die UTF-8-Codierung verwendet, die keine Kodierung für einsame Surrogate hat. Strings, die keine einsamen Surrogate enthalten, werden als wohlgeformte Strings bezeichnet und können sicher mit Funktionen verwendet werden, die nicht mit UTF-16 umgehen (wie encodeURI()
oder TextEncoder
). Sie können überprüfen, ob ein String wohlgeformt ist, mit der isWellFormed()
-Methode oder einsame Surrogate mit der toWellFormed()
-Methode bereinigen.
Zusätzlich zu Unicode-Zeichen gibt es bestimmte Sequenzen von Unicode-Zeichen, die als eine visuelle Einheit betrachtet werden sollten, bekannt als Graphem-Cluster. Der häufigste Fall sind Emojis: Viele Emojis, die eine Reihe von Variationen haben, werden tatsächlich durch mehrere Emojis gebildet, die normalerweise durch das <ZWJ> (U+200D
) Zeichen verbunden sind.
Sie müssen vorsichtig sein, auf welcher Ebene Sie Zeichen iterieren. Zum Beispiel wird [split("")](/de/docs/Web/JavaScript/Reference/Global_Objects/String/split
) nach UTF-16-Codeeinheiten splitten und Surrogat-Paare trennen. String-Indizes beziehen sich auch auf den Index jeder UTF-16-Codeeinheit. Andererseits iteriert [Symbol.iterator]()
nach Unicode-Codepunkten. Das Iterieren durch Graphem-Cluster erfordert einige benutzerdefinierte Codes.
"😄".split(""); // ['\ud83d', '\ude04']; splits into two lone surrogates
// "Backhand Index Pointing Right: Dark Skin Tone"
[..."👉🏿"]; // ['👉', '🏿']
// splits into the basic "Backhand Index Pointing Right" emoji and
// the "Dark skin tone" emoji
// "Family: Man, Boy"
[..."👨👦"]; // [ '👨', '', '👦' ]
// splits into the "Man" and "Boy" emoji, joined by a ZWJ
// The United Nations flag
[..."🇺🇳"]; // [ '🇺', '🇳' ]
// splits into two "region indicator" letters "U" and "N".
// All flag emojis are formed by joining two region indicator letters
Konstruktor
String()
-
Erstellt
String
-Objekte. Wird es als Funktion aufgerufen, gibt es primitive Werte des Typs String zurück.
Statische Methoden
String.fromCharCode()
-
Gibt einen String zurück, der mit der angegebenen Sequenz von Unicode-Werten erstellt wurde.
String.fromCodePoint()
-
Gibt einen String zurück, der mit der angegebenen Sequenz von Code-Punkten erstellt wurde.
String.raw()
-
Gibt einen String zurück, der aus einer rohen Template-Zeichenkette erstellt wurde.
Instanzeigenschaften
Diese Eigenschaften sind auf String.prototype
definiert und werden von allen String
-Instanzen geteilt.
String.prototype.constructor
-
Die Konstrukturfunktion, die das Instanzobjekt erstellt hat. Für
String
-Instanzen ist der Anfangswert derString
-Konstruktor.
Diese Eigenschaften sind eigene Eigenschaften jeder String
-Instanz.
length
-
Gibt die
Länge
des Strings wieder. Nur lesbar.
Instanzmethoden
String.prototype.at()
- : Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen
index
zurück. Akzeptiert negative ganze Zahlen, die vom letzten Zeichen des Strings zurück zählen.
- : Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen
String.prototype.charAt()
- : Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen
index
zurück.
- : Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen
String.prototype.charCodeAt()
- : Gibt eine Zahl zurück, die den Wert der UTF-16-Codeeinheit am angegebenen
index
darstellt.
- : Gibt eine Zahl zurück, die den Wert der UTF-16-Codeeinheit am angegebenen
String.prototype.codePointAt()
- : Gibt eine Nicht-negativ-Ganzzahl zurück, die den Codepunktwert des UTF-16-kodierten Codepunkts darstellt, der an der angegebenen
pos
beginnt.
- : Gibt eine Nicht-negativ-Ganzzahl zurück, die den Codepunktwert des UTF-16-kodierten Codepunkts darstellt, der an der angegebenen
String.prototype.concat()
- : Kombiniert den Text von zwei (oder mehr) Strings und gibt einen neuen String zurück.
String.prototype.endsWith()
- : Bestimmt, ob ein String mit den Zeichen des Strings
searchString
endet.
- : Bestimmt, ob ein String mit den Zeichen des Strings
String.prototype.includes()
- : Bestimmt, ob der aufrufende String
searchString
enthält.
- : Bestimmt, ob der aufrufende String
String.prototype.indexOf()
- : Gibt den Index des ersten Vorkommens von
searchValue
innerhalb dieses Strings zurück oder-1
, wenn nicht gefunden.
- : Gibt den Index des ersten Vorkommens von
String.prototype.isWellFormed()
- : Gibt einen Boolean zurück, der anzeigt, ob dieser String einsame Surrogate enthält.
String.prototype.lastIndexOf()
- : Gibt den Index des letzten Vorkommens von
searchValue
innerhalb dieses Strings zurück oder-1
, wenn nicht gefunden.
- : Gibt den Index des letzten Vorkommens von
String.prototype.localeCompare()
- : Gibt eine Zahl zurück, die anzeigt, ob der Vergleichsstring
compareString
in der Sortierreihenfolge vor, nach oder gleich dem gegebenen String kommt.
- : Gibt eine Zahl zurück, die anzeigt, ob der Vergleichsstring
String.prototype.match()
- : Wird verwendet, um regulären Ausdruck
regexp
gegen einen String zu vergleichen.
- : Wird verwendet, um regulären Ausdruck
String.prototype.matchAll()
- : Gibt einen Iterator aller Übereinstimmungen von
regexp
zurück.
- : Gibt einen Iterator aller Übereinstimmungen von
String.prototype.normalize()
- : Gibt die Unicode-Normalform des aufrufenden String-Werts zurück.
String.prototype.padEnd()
- : Füllt den aktuellen String von Ende mit einem gegebenen String und gibt einen neuen String von der Länge
targetLength
zurück.
- : Füllt den aktuellen String von Ende mit einem gegebenen String und gibt einen neuen String von der Länge
String.prototype.padStart()
- : Füllt den aktuellen String von Anfang mit einem gegebenen String und gibt einen neuen String von der Länge
targetLength
zurück.
- : Füllt den aktuellen String von Anfang mit einem gegebenen String und gibt einen neuen String von der Länge
String.prototype.repeat()
- : Gibt einen String zurück, der aus den Elementen des Objekts besteht, die
count
-mal wiederholt wurden.
- : Gibt einen String zurück, der aus den Elementen des Objekts besteht, die
String.prototype.replace()
- : Wird verwendet, um Vorkommen von
searchFor
mitreplaceWith
zu ersetzen.searchFor
kann ein String oder ein regulärer Ausdruck sein, undreplaceWith
kann ein String oder eine Funktion sein.
- : Wird verwendet, um Vorkommen von
String.prototype.replaceAll()
- : Wird verwendet, um alle Vorkommen von
searchFor
mitreplaceWith
zu ersetzen.searchFor
kann ein String oder ein regulärer Ausdruck sein, undreplaceWith
kann ein String oder eine Funktion sein.
- : Wird verwendet, um alle Vorkommen von
String.prototype.search()
- : Sucht nach einer Übereinstimmung zwischen einem regulären Ausdruck
regexp
und dem aufrufenden String.
- : Sucht nach einer Übereinstimmung zwischen einem regulären Ausdruck
String.prototype.slice()
- : Extrahiert einen Abschnitt eines Strings und gibt einen neuen String zurück.
String.prototype.split()
- : Gibt ein Array von Strings zurück, das entsteht, indem der aufrufende String an den Vorkommen des Substrings
sep
aufgeteilt wird.
- : Gibt ein Array von Strings zurück, das entsteht, indem der aufrufende String an den Vorkommen des Substrings
String.prototype.startsWith()
- : Bestimmt, ob der aufrufende String mit den Zeichen des Strings
searchString
beginnt.
- : Bestimmt, ob der aufrufende String mit den Zeichen des Strings
-
String.prototype.substr()
Veraltet- : Gibt einen Teil des Strings zurück, der am angegebenen Index beginnt und eine gegebene Anzahl von Zeichen danach umfasst.
String.prototype.substring()
- : Gibt einen neuen String zurück, der Zeichen des aufrufenden Strings von (oder zwischen) angegebenen Index (oder Indizes) enthält.
String.prototype.toLocaleLowerCase()
- : Die Zeichen innerhalb eines Strings werden unter Berücksichtigung des aktuellen Gebietsschemas in Kleinbuchstaben konvertiert.
Für die meisten Sprachen wird dies dasselbe zurückgeben wie
toLowerCase()
.String.prototype.toLocaleUpperCase()
- : Die Zeichen innerhalb eines Strings werden unter Berücksichtigung des aktuellen Gebietsschemas in Großbuchstaben konvertiert.
Für die meisten Sprachen wird dies dasselbe zurückgeben wie
toUpperCase()
.String.prototype.toLowerCase()
- : Gibt den aufrufenden String-Wert, umgewandelt in Kleinbuchstaben, zurück.
String.prototype.toString()
- : Gibt einen String zurück, der das angegebene Objekt darstellt. Überschreibt die Methode
Object.prototype.toString()
.
- : Gibt einen String zurück, der das angegebene Objekt darstellt. Überschreibt die Methode
String.prototype.toUpperCase()
- : Gibt den aufrufenden String-Wert, umgewandelt in Großbuchstaben, zurück.
String.prototype.toWellFormed()
- : Gibt einen String zurück, bei dem alle einsamen Surrogate dieses Strings mit dem Unicode-Ersatzzeichen U+FFFD ersetzt wurden.
String.prototype.trim()
- : Schneidet Leerzeichen vom Beginn und Ende des Strings ab.
String.prototype.trimEnd()
- : Schneidet Leerzeichen vom Ende des Strings ab.
String.prototype.trimStart()
- : Schneidet Leerzeichen vom Beginn des Strings ab.
String.prototype.valueOf()
- : Gibt den primären Wert des angegebenen Objekts zurück. Überschreibt die Methode
Object.prototype.valueOf()
.
- : Gibt den primären Wert des angegebenen Objekts zurück. Überschreibt die Methode
-
String.prototype[Symbol.iterator]()
- : Gibt ein neues Iterator-Objekt zurück, das über die Codepunkte eines String-Wertes iteriert und jeden Codepunkt als String-Wert zurückgibt.
HTML-Wrapper-Methoden
Warnung: Veraltet. Vermeiden Sie diese Methoden.
Sie sind von begrenztem Nutzen, da sie auf einem sehr alten HTML-Standard basieren und nur einen Teil der derzeit verfügbaren HTML-Tags und -Attribute bieten. Viele von ihnen erzeugen heute veraltetes oder nicht standardisiertes Markup. Darüber hinaus führen sie String-Konkatenationen ohne jegliche Validierung oder Sanitär durch, was sie zu einer potenziellen Sicherheitsbedrohung macht, wenn sie direkt mit innerHTML
eingefügt werden. Verwenden Sie DOM-APIs wie document.createElement()
stattdessen.
String.prototype.anchor()
Veraltet-
<a name="name">
(Hypertext-Ziel) String.prototype.big()
Veraltet<big>
String.prototype.blink()
Veraltet-
<blink>
String.prototype.bold()
Veraltet<b>
String.prototype.fixed()
Veraltet<tt>
String.prototype.fontcolor()
VeraltetString.prototype.fontsize()
VeraltetString.prototype.italics()
Veraltet<i>
String.prototype.link()
Veraltet-
<a href="url">
(Link zu URL) String.prototype.small()
Veraltet<small>
String.prototype.strike()
Veraltet<strike>
String.prototype.sub()
Veraltet<sub>
String.prototype.sup()
Veraltet<sup>
Beachten Sie, dass diese Methoden nicht überprüfen, ob der String selbst HTML-Tags enthält, sodass es möglich ist, ungültiges HTML zu erzeugen:
"</b>".bold(); // <b></b></b>
Das einzige Escaping, was sie durchführen, ist das Ersetzen von "
im Attributwert (für anchor()
, fontcolor()
, fontsize()
, und link()
) mit "
.
"foo".anchor('"Hello"'); // <a name=""Hello"">foo</a>
Beispiele
String-Konvertierung
Die String()
-Funktion ist eine zuverlässigere Methode, um Werte in Strings zu konvertieren, als die toString()
-Methode des Wertes zu verwenden, da erstere auch für null
und undefined
funktioniert. Zum Beispiel:
// You cannot access properties on null or undefined
const nullVar = null;
nullVar.toString(); // TypeError: Cannot read properties of null
String(nullVar); // "null"
const undefinedVar = undefined;
undefinedVar.toString(); // TypeError: Cannot read properties of undefined
String(undefinedVar); // "undefined"
Spezifikationen
Specification |
---|
ECMAScript® 2025 Language Specification # sec-string-objects |
Browser-Kompatibilität
BCD tables only load in the browser
Siehe auch
- Zahlen und Zeichenketten Leitfaden
RegExp