Einführung
Zeichenketten eignen sich gut zum Speichern von Daten, die als Text dargestellt werden können. Zu den häufigsten Operationen mit Zeichenketten gehören das Prüfen ihrer Länge, das Erstellen und Verketten von Zeichenketten mithilfe der Operatoren + und +=, das Prüfen auf das Vorhandensein oder die Position von Teilzeichenketten mit der Methode indexOf() sowie das Extrahieren von Teilzeichenketten mit der Methode substring().
Zeichenketten erstellen
Zeichenketten können auf primitive Weise, aus dem Zeichenkettenliteral, 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");
Primitive Zeichenketten und Zeichenkettenobjekte weisen viele Gemeinsamkeiten auf, unterscheiden sich aber auch in anderen wichtigen Punkten und unterliegen besonderen Einschränkungen. Siehe dazu den Abschnitt “Primitive Zeichenketten und Zeichenkettenobjekte” weiter unten.
Zeichenkettenliterale können mit einfachen oder doppelten Anführungszeichen (die gleich behandelt werden) oder mit dem Backtick-Zeichen ` angegeben werden. Die Backtick-Zeichenfolge definiert ein konkretes Muster: Ausdrücke lassen sich damit interpolieren. Weitere Informationen zur Syntax von Zeichenkettenliteralen finden Sie unter Lexikalische Syntax.
Charakterzugriff
Es gibt zwei Möglichkeiten, auf ein Zeichen in einer Zeichenkette zuzugreifen. Die erste ist die Methode charAt():
"cat".charAt(1); // gives value "a"
Eine andere Möglichkeit besteht darin, sich die Zeichenkette als ein arrayähnliches Objekt vorzustellen, bei dem einzelne Zeichen einem numerischen Index entsprechen:
"cat"[1]; // gives value "a"
Bei Verwendung der Klammernotation zum Zugriff auf das Zeichen schlagen Versuche, diese Eigenschaften zu löschen oder ihnen einen Wert zuzuweisen, fehl. Die betreffenden Eigenschaften sind weder beschreibbar noch veränderbar. (Weitere Informationen finden Sie unter Object.defineProperty().)
Zeichenketten vergleichen
Verwenden Sie die Operatoren „kleiner als“ und „größer als“, um Zeichenketten 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 ==, Zeichenketten unter Berücksichtigung der Groß- und Kleinschreibung vergleichen. Eine gängige Methode, Zeichenketten unter Berücksichtigung der Groß- und Kleinschreibung zu vergleichen, besteht darin, beide Zeichenketten vor dem Vergleich in denselben Buchstaben (Groß- oder Kleinbuchstabe) umzuwandeln.
function areEqualCaseInsensitive(str1, str2) {
return str1.toUpperCase() === str2.toUpperCase();
}Die Wahl zwischen der Umwandlung mit `toUpperCase()` und `toLowerCase()` ist weitgehend willkürlich, und keine der beiden Methoden ist bei der Erweiterung des Alphabets über das lateinische Alphabet hinaus völlig zuverlässig. Beispielsweise werden die deutschen Kleinbuchstaben ß und ss von `toUpperCase()` beide in SS umgewandelt, während der türkische Buchstabe ı von `toLowerCase()` fälschlicherweise als nicht gleich I gemeldet wird, es sei denn, man verwendet explizit `toLocaleLowerCase("tr")`.
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 trueEine logische und robuste Lösung zum Testen der Groß-/Kleinschreibung-unabhängigen Gleichheit ist die Verwendung der Intl.Collator-API oder der string localeCompare()-Methode – sie haben die gleiche Schnittstelle – mit der Sensitivitätsoption 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"); // trueDie Methode localeCompare() ermöglicht den Vergleich von Zeichenketten auf ähnliche Weise wie strcmp() – dies ermöglicht das Sortieren von Zeichenketten unter Berücksichtigung des jeweiligen Gebietsschemas.
Primitive Zeichenketten und Zeichenkettenobjekte
Beachten Sie, dass JavaScript zwischen String-Objekten und primitiven String-Werten unterscheidet. (Dies gilt auch für Booleans und Numbers.)
Zeichenkettenliterale (in einfachen oder doppelten Anführungszeichen) und Zeichenketten, die von Zeichenkettenaufrufen in einem nicht-konstruktiven Kontext (d. h. ohne Verwendung des Schlüsselworts `new`) zurückgegeben werden, sind primitive Zeichenketten. Wenn eine Methode auf eine primitive Zeichenkette angewendet oder eine Eigenschaftssuche durchgeführt wird, umschließt JavaScript die primitive Zeichenkette automatisch und ruft die Methode bzw. die Eigenschaftssuche stattdessen auf dem Wrapper-Objekt auf.
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); // "objectPrimitive Zeichenketten und Zeichenkettenobjekte liefern bei der Verwendung von `eval()` unterschiedliche Ergebnisse. Die an `eval()` übergebene primitive Zeichenkette wird als Quellcode behandelt. Durch die Rückgabe eines Objekts werden Zeichenkettenobjekte wie andere Objekte behandelt. 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 es vorkommen, dass der Code fehlschlägt, wenn er auf String-Objekte stößt, obwohl er einen primitiven String erwartet. Im Allgemeinen müssen sich Autoren jedoch keine Gedanken über diese Unterscheidung machen.
Ein String-Objekt kann immer mit der Methode valueOf() in sein ursprüngliches Gegenstück umgewandelt werden.
console.log(eval(s2.valueOf())); // returns the number 4
String-Umwandlung
Viele integrierte Operationen, die Zeichenketten erwarten, wandeln ihre Argumente zunächst in Zeichenketten um (weshalb sich String-Objekte wie primitive Zeichenketten verhalten). Die Operationen lassen sich wie folgt zusammenfassen:
- Zeichenketten werden unverändert zurückgegeben.
- Undefiniert wird zu "undefiniert".
- null wird zu "leer".
- Wahr wird zu “wahr”. Falsch wird zu “falsch”.
- Die Umwandlung der Zahlen erfolgt mit dem gleichen Algorithmus wie bei toString(10).
- BigInts werden mit dem gleichen Algorithmus wie toString(10) konvertiert.
- Symbole lösen einen TypeError aus.
- Objekte werden zunächst in einen primitiven Datentyp umgewandelt, indem die Methoden [Symbol.toPrimitive]() (mit “string” als Hinweis), toString() bzw. valueOf() aufgerufen werden. Der resultierende primitive Datentyp wird dann in einen String umgewandelt.
Es gibt verschiedene Möglichkeiten, in JavaScript einen annähernd gleichen Effekt zu erzielen.
- Wörtlich: `${x}` führt genau die oben beschriebenen String-Bindungsschritte für den eingebetteten Ausdruck aus.
- Die Funktion String(): String(x) verwendet denselben Algorithmus zur Konvertierung von x, mit der Ausnahme, dass Symbols keinen TypeError auslöst, sondern “Symbol(description)” zurückgibt, wobei description die Beschreibung des Symbols ist.
- Die Verwendung des Operators +: "" + x wandelt seinen Operanden in einen primitiven Datentyp anstatt in eine Zeichenkette um. Bei manchen Objekten verhält er sich völlig anders als die reguläre Zeichenkettenumwandlung. Weitere Details finden Sie in der zugehörigen Referenz.
Je nach Anwendungsfall möchten Sie möglicherweise `${x}` (um das integrierte Verhalten nachzuahmen) oder String(x) (um Symbolwerte ohne Fehler zu verarbeiten) verwenden, aber Sie sollten nicht "" + x verwenden. .
UTF-16-Zeichen, Unicode-Codepunkte und Graphemcluster
Zeichenketten werden im Wesentlichen als Folge von UTF-16-Codeeinheiten dargestellt. In der UTF-16-Kodierung ist jede Codeeinheit genau 16 Bit lang. Das bedeutet, dass maximal 2<sup>16</sup> oder 65.536 Zeichen als einzelne UTF-16-Codeeinheit möglich sind. Dieser Zeichensatz wird als Basic Multilingual Page (BMP) bezeichnet und umfasst die gebräuchlichsten Zeichen wie lateinische, griechische, kyrillische und viele ostasiatische Zeichen. Jede Codeeinheit kann in einer Zeichenkette mit einem \u gefolgt von genau vier Hexadezimalziffern geschrieben werden.
Der gesamte Unicode-Zeichensatz ist jedoch deutlich größer als 65536 Zeichen. Die zusätzlichen Zeichen in UTF-16 werden als Surrogate-Paare gespeichert. Diese bestehen aus jeweils zwei 16-Bit-Codeeinheiten, die ein einzelnes Zeichen repräsentieren. Um Mehrdeutigkeiten zu vermeiden, müssen die beiden Teile des Paares Werte zwischen 0xD800 und 0xDFFF haben. Diese Codeeinheiten werden nicht zur Codierung von Einzelcode-Zeichen verwendet. (Genauer gesagt: Führende Surrogate, auch obere Surrogate-Codeeinheiten genannt, haben Werte zwischen 0xD800 und 0xDBFF, während nachfolgende Surrogate, auch untere Surrogate-Codeeinheiten genannt, Werte zwischen 0xDC00 und 0xDFFF haben, einschließlich des Unicode-Zeichens.) Ein Zeichen, das aus einer oder zwei UTF-16-Codeeinheiten besteht, wird auch als Unicode-Codepunkt bezeichnet. Jeder Unicode-Codepunkt kann in einer Zeichenkette mit \u{xxxxxx} geschrieben werden, wobei xxxxxx für 1 bis 6 Hexadezimalziffern steht.
Ein “einzelner Surrogatcode” ist eine 16-Bit-Codeeinheit, die eine der folgenden Beschreibungen erfüllt:
- Im Bereich 0xD800–0xDBFF, einschließlich (d.h. ist ein führendes Surrogate), aber ist die letzte Codeeinheit in der Zeichenkette, oder die nächste Codeeinheit ist kein letztes Surrogate.
- Im Bereich 0xDC00–0xDFFF, einschließlich (d.h. ein letzter Ersatzcode), aber die erste Codeeinheit in der Zeichenkette oder die vorhergehende Codeeinheit ist nicht der ursprüngliche Ersatzcode.
Einzelne Surrogate repräsentieren keine Unicode-Zeichen. Obwohl die meisten internen JavaScript-Methoden sie korrekt verarbeiten, da sie alle mit UTF-16-Codeeinheiten arbeiten, sind einzelne Surrogate bei der Interaktion mit anderen Systemen in der Regel keine gültigen Werte. Beispielsweise löst `encodeURI()` bei einzelnen Surrogaten einen URIE-Fehler aus, da die URI-Kodierung UTF-8 verwendet, welches keine Kodierung für einzelne Surrogate besitzt. Zeichenketten, die keine einzelnen Surrogate enthalten, werden als wohlgeformte Zeichenketten bezeichnet und können sicher mit Funktionen verwendet werden, die nicht mit UTF-16 arbeiten (wie z. B. `encodeURI()` oder `TextEncoder`). Sie können mit der Methode `isWellFormed()` prüfen, ob eine Zeichenkette wohlgeformt ist, und einzelne Surrogate mit der Methode `toWellFormed()` entfernen.
Über den Unicode-Zeichen befindet sich eine bestimmte Sequenz von Unicode-Zeichen, die als visuelle Einheit, ein sogenannter grafischer Cluster, betrachtet werden muss. Das häufigste Beispiel hierfür sind Emoticons: Viele Emoticons, die in zahlreichen Variationen vorkommen, bestehen aus mehreren Emojis, üblicherweise mit dem Zeichen (U+200D) zusammenfügen.
Sie müssen darauf achten, auf welcher Zeichenebene Sie iterieren. Beispielsweise teilt `split("")` Zeichenketten anhand von UTF-16-Codeeinheiten und trennt die alternierenden Paare. Zeichenkettenindizes beziehen sich ebenfalls auf den Index jeder UTF-16-Codeeinheit. `[Symbol.iterator]()` hingegen iteriert anhand von Unicode-Codepunkten. Die Iteration über Graphemcluster erfordert benutzerdefinierten Code.
"😄".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 lettersKonstruktor
String()
Erzeugt String-Objekte. Bei Aufruf als Funktion gibt sie Anfangswerte vom Typ String zurück.
Statische Methoden
String.fromCharCode()
Gibt eine Zeichenkette zurück, die mithilfe der angegebenen Sequenz von Unicode-Werten erstellt wurde.
String.fromCodePoint()
Gibt eine Zeichenkette zurück, die mithilfe der angegebenen Sequenz von Codepunkten erstellt wurde.
String.raw()
Gibt eine Zeichenkette zurück, die aus einer Rohmusterzeichenkette erstellt wurde.
Beispieleigenschaften
Diese Eigenschaften sind in String.prototype definiert und werden von allen String-Instanzen gemeinsam genutzt.
String.prototype.constructor
Die Konstruktorfunktion, die das Instanzobjekt erzeugt. Bei String-Instanzen ist der Anfangswert der String-Konstruktor.
Diese Merkmale sind spezifisch für jede einzelne Zeichenketteninstanz.
Länge
Gibt die Länge der Zeichenkette an. Schreibgeschützt.
Probenmethoden
String.prototype.at()
Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen Index zurück. Akzeptiert negative ganze Zahlen, die vom letzten Zeichen der Zeichenkette rückwärts zählen.
String.prototype.charAt()
Gibt das Zeichen (genau eine UTF-16-Codeeinheit) im angegebenen Index zurück.
String.prototype.charCodeAt()
Gibt eine Zahl zurück, die dem Wert der UTF-16-Codeeinheit am angegebenen Index entspricht.
String.prototype.codePointAt()
Gibt eine nicht-negative ganze Zahl zurück, die dem Codepunktwert des UTF-16-codierten Codepunkts ab der angegebenen Position entspricht.
String.prototype.concat()
Der Text kombiniert zwei (oder mehr) Zeichenketten und gibt eine neue Zeichenkette zurück.
String.prototype.endsWith()
Prüft, ob eine Zeichenkette mit den Zeichen der Zeichenkette searchString endet.
String.prototype.includes()
Ermittelt, ob die aufrufende Zeichenkette eine Suchzeichenkette enthält.
String.prototype.indexOf()
Gibt den Index des ersten Vorkommens von searchValue in dieser Zeichenkette zurück, oder -1, falls es nicht gefunden wird.
String.prototype.isWellFormed()
Gibt einen booleschen Wert zurück, der angibt, ob diese Zeichenkette einzelne Ersetzungen enthält.
String.prototype.lastIndexOf()
Gibt den Index des letzten Vorkommens von searchValue in dieser Zeichenkette zurück, oder -1, falls es nicht gefunden wird.
String.prototype.localeCompare()
Gibt eine Zahl zurück, die angibt, ob die durch compareString referenzierte Zeichenkette in der Sortierreihenfolge vor, nach oder gleich der angegebenen Zeichenkette steht.
String.prototype.match()
Es dient dazu, einen regulären Ausdruck (regexp) mit einer Zeichenkette abzugleichen.
String.prototype.matchAll()
Gibt einen Iterator aller regulären Ausdrücke zurück.
String.prototype.normalize()
Die Unicode-normalisierte Form gibt den Wert der aufrufenden Zeichenkette zurück.
String.prototype.padEnd()
Verkettet die aktuelle Zeichenkette vom Ende her mit einer Zeichenkette und gibt eine neue Zeichenkette der Länge targetLength zurück.
String.prototype.padStart()
Füllt die aktuelle Zeichenkette von Anfang an mit einer gegebenen Zeichenkette auf und gibt eine neue Zeichenkette der Länge targetLength zurück.
String.prototype.repeat()
Gibt eine Zeichenkette zurück, die aus den Elementen des Objekts besteht, und zwar gezählt.
String.prototype.replace()
SearchFor wird verwendet, um Elemente mithilfe von replaceWith zu ersetzen. searchFor kann eine Zeichenkette oder ein regulärer Ausdruck sein, und replaceWith kann eine Zeichenkette oder eine Funktion sein.
String.prototype.replaceAll()
SearchFor dient dazu, alle Vorkommen von replaceWith zu ersetzen. SearchFor kann eine Zeichenkette oder ein regulärer Ausdruck sein, und replaceWith kann eine Zeichenkette oder eine Funktion sein.
String.prototype.search()
Suche nach einer Übereinstimmung zwischen einem regulären Ausdruck (regexp) und der aufrufenden Zeichenkette.
String.prototype.slice()
Extrahiert einen Teil einer Zeichenkette und gibt eine neue Zeichenkette zurück.
String.prototype.split()
Gibt ein Array von Zeichenketten zurück, das durch Aufteilen der aufrufenden Zeichenkette in die Teilzeichenkette sep gefüllt wird.
String.prototype.startsWith()
Ermittelt, ob die aufrufende Zeichenkette mit den Zeichen in der Suchzeichenkette beginnt.
String.prototype.substr() ist veraltet.
Gibt einen Teil einer Zeichenkette zurück, der an der angegebenen Position beginnt und sich über eine angegebene Anzahl von Zeichen erstreckt.
String.prototype.substring()
Gibt eine neue Zeichenkette zurück, die die Zeichen der aufrufenden Zeichenkette ab dem (oder zwischen den) angegebenen Index (oder Indizes) enthält.
String.prototype.toLocaleLowerCase()
Zeichen innerhalb einer Zeichenkette werden unter Berücksichtigung des aktuellen Gebietsschemas in Kleinbuchstaben umgewandelt.
Für die meisten Sprachen liefert diese Funktion das gleiche Ergebnis wie toLowerCase().
String.prototype.toLocaleUpperCase()
Zeichen innerhalb einer Zeichenkette werden unter Berücksichtigung des aktuellen Gebietsschemas in Großbuchstaben umgewandelt.
Für die meisten Sprachen liefert diese Funktion das gleiche Ergebnis wie toUpperCase().
String.prototype.toLowerCase()
Gibt den in Kleinbuchstaben umgewandelten Wert der aufrufenden Zeichenkette zurück.
String.prototype.toString()
Gibt eine Zeichenkette zurück, die das angegebene Objekt repräsentiert. Überschreibt die Methode Object.prototype.toString().
String.prototype.toUpperCase()
Gibt den Wert der aufrufenden Zeichenkette in Großbuchstaben zurück.
String.prototype.toWellFormed()
Gibt eine Zeichenkette zurück, in der alle einzelnen Vorkommen dieser Zeichenkette durch das Unicode-Ersatzzeichen U+FFFD ersetzt werden.
String.prototype.trim()
Entfernt Leerzeichen am Anfang und Ende der Zeichenkette.
String.prototype.trimEnd()
Schneidet das Ende der Zeichenkette mit einem Leerzeichen ab.
String.prototype.trimStart()
Entfernt Leerzeichen am Anfang der Zeichenkette.
String.prototype.valueOf()
Gibt den Anfangswert des angegebenen Objekts zurück. Überschreibt die Methode Object.prototype.valueOf().
String.prototype[Symbol.iterator]()
Gibt ein neues Iteratorobjekt zurück, das über die Codepunkte eines Zeichenkettenwerts iteriert und jeden Codepunkt als Zeichenkettenwert zurückgibt.
