DasString-Objekt wird verwendet, um eine Sequenz von Zeichen darzustellen und zu manipulieren.

Beschreibung

Strings sind nützlich, um Daten zu speichern, die in Textform dargestellt werden können. Einige der am häufigsten verwendeten Operationen mit Strings sind das Überprüfen ihrerLänge, das Erstellen und Verketten mit den+ und+= string operators, das Überprüfen auf Vorhandensein oder Position von Teilzeichenfolgen mit der MethodeindexOf() oder das Extrahieren von Teilzeichenfolgen mit der Methodesubstring().

Erstellen von Strings

Strings können als Primitive, aus String-Literalen oder als Objekte über denString()-Konstruktor 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-Primitive und String-Objekte teilen viele Verhaltensweisen, haben aber auch wichtige Unterschiede und Besonderheiten. 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 gibt einTemplate Literal an: Mit dieser Form können Sie Ausdrücke interpolieren. Weitere Informationen zur Syntax von String-Literalen finden Sie imlexikalischen Grammatik.

Zugriff auf einzelne Zeichen

Es gibt zwei Möglichkeiten, auf ein einzelnes Zeichen in einem String zuzugreifen. Die erste ist die MethodecharAt():

"cat".charAt(1); // gives value "a"

Die andere Möglichkeit besteht darin, den String als array-ähnliches Objekt zu behandeln, in dem einzelne Zeichen einem numerischen Index entsprechen:

"cat"[1]; // gives value "a"

Beim Verwenden der Klammernotation für den Zeichenzugriff wird der Versuch, diese Eigenschaften zu löschen oder ihnen einen Wert zuzuweisen, nicht erfolgreich sein. Die beteiligten Eigenschaften sind weder beschreibbar noch konfigurierbar. (Weitere Informationen finden Sie inObject.defineProperty().)

Vergleich von Strings

Verwenden Sie dieKleiner-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 fallunempfindlich vergleichen. Eine übliche Methode, um Strings fallunabhängig zu vergleichen, besteht darin, beide vor dem Vergleich in denselben Fall (groß oder klein) umzuwandeln.

function areEqualCaseInsensitive(str1, str2) {  return str1.toUpperCase() === str2.toUpperCase();}

Die Wahl, zwischentoUpperCase() odertoLowerCase() zu transformieren, ist meistens willkürlich, und keine der beiden ist vollständig robust, wenn man über das lateinische Alphabet hinausgeht. Zum Beispiel werden der deutsche Kleinbuchstabeß undss beide durchtoUpperCase() zuSS transformiert, während der türkische Buchstabeı fälschlicherweise als ungleich zuI gemeldet wird, es sei denn, man verwendet ausdrücklichtoLocaleLowerCase("tr").

const areEqualInUpperCase = (str1, str2) =>  str1.toUpperCase() === str2.toUpperCase();const areEqualInLowerCase = (str1, str2) =>  str1.toLowerCase() === str2.toLowerCase();areEqualInUpperCase("ß", "ss"); // true; should be falseareEqualInLowerCase("ı", "I"); // false; should be true

Eine lokalisierte und robuste Lösung zum Testen der fallunabhängigen Gleichheit ist die Verwendung derIntl.Collator API oder der MethodelocaleCompare() des Strings — sie teilen dasselbe Interface — mit der Optionsensitivity auf"accent" oder"base" gesetzt.

const areEqual = (str1, str2, locale = "en-US") =>  str1.localeCompare(str2, locale, { sensitivity: "accent" }) === 0;areEqual("ß", "ss", "de"); // falseareEqual("ı", "I", "tr"); // true

Die MethodelocaleCompare() ermöglicht den String-Vergleich ähnlich wiestrcmp() — sie erlaubt das Sortieren von Strings auf lokalisierte Weise.

String-Primitiven und String-Objekte

Beachten Sie, dass JavaScript zwischenString-Objekten undprimitiven String-Werten unterscheidet. (Dies gilt auch fürBoolean undNumbers.)

String-Literale (die durch doppelte oder einfache Anführungszeichen dargestellt werden) und Strings, die durchString-Aufrufe in einem Nicht-Konstruktor-Kontext (das heißt, aufgerufen ohne das Schlüsselwortnew zu verwenden) zurückgegeben werden, sind primitive Strings. In Kontexten, in denen eine Methode auf einem primitiven String aufgerufen oder ein Eigenschaftslookup durchgeführt wird, wird JavaScript den String-Primitiv automatisch umwickeln und die Methode auf dem Wrapper-Objekt aufrufen oder den Eigenschaftslookup darauf durchführen.

const strPrim = "foo"; // A literal is a string primitiveconst 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"

String-Primitiven undString-Objekte geben auch unterschiedliche Ergebnisse bei der Verwendung voneval(). Primitive, die aneval ü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 primitiveconst s2 = new String("2 + 2"); // creates a String objectconsole.log(eval(s1)); // returns the number 4console.log(eval(s2)); // returns the string "2 + 2"

Aus diesen Gründen kann der Code fehlerhaft werden, wenn erString-Objekte gegen eine ursprüngliche String erwartet, obwohl sich Autoren im Allgemeinen nicht um den Unterschied kümmern müssen.

EinString-Objekt kann immer mit der MethodevalueOf() in sein primitives Gegenstück umgewandelt werden.

console.log(eval(s2.valueOf())); // returns the number 4

String-Konvertierung

Viele eingebaute Operationen, die Strings erwarten, konvertieren zuerst ihre Argumente in Strings (was größtenteils der Grund ist, warumString-Objekte ähnlich wie String-Primitiven funktionieren).Die Operation kann wie folgt zusammengefasst werden:

• Strings werden unverändert zurückgegeben.
• undefined wird in"undefined" umgewandelt.
• null wird in"null" umgewandelt.
• true wird in"true" umgewandelt;false wird in"false" umgewandelt.
• Zahlen werden mit demselben Algorithmus konvertiert wietoString(10).
• BigInts werden mit demselben Algorithmus konvertiert wietoString(10).
• Symbole werfen einenTypeError.
• Objekte werden zuerstin ein primitives umgewandelt, indem seine Methoden[Symbol.toPrimitive]() (mit"string" als Hinweis),toString() undvalueOf() in dieser Reihenfolge aufgerufen werden. Das resultierende Primitive wird dann in einen String umgewandelt.

Es gibt mehrere Möglichkeiten, in JavaScript fast denselben Effekt zu erzielen.

• Template Literal:`${x}` führt genau die oben erklärten String-Konvertierungsschritte für den eingebetteten Ausdruck aus.
• DieString() Funktion:String(x) verwendet denselben Algorithmus, umx zu konvertieren, mit der Ausnahme, dassSymbole keinenTypeError werfen, sondern"Symbol(description)" zurückgeben, wobeidescription dieBeschreibung des Symbols ist.
• Die Verwendung des+ Operators:"" + x erzwingt seine Operanden in einprimitives anstelle einesStrings und hat, für einige Objekte, völlig unterschiedliche Verhaltensweisen von der normalen String-Konvertierung. Weitere Details finden Sie auf derReferenzseite.

Abhängig von Ihrem Anwendungsfall möchten Sie möglicherweise`${x}` verwenden (um das eingebaute Verhalten nachzuahmen) oderString(x) (um Symbolwerte ohne Fehlerbehandlung zu verarbeiten), aber Sie sollten nicht"" + x verwenden.

UTF-16-Zeichen, Unicode-Codepunkte und Grapheme-Cluster

Strings werden grundsätzlich als Sequenzen vonUTF-16-Codeeinheiten dargestellt. Im UTF-16-Encoding beträgt jede Codeeinheit exakt 16 Bits. Dies bedeutet, dass es maximal 2¹⁶ oder 65536 mögliche Zeichen gibt, die als einzelne UTF-16-Codeeinheiten darstellbar sind. Dieses Zeichen-Set wird alsbasic 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 Hexadezimalziffern geschrieben werden.

Das gesamte Unicode-Zeichen-Set ist jedoch weitaus größer als 65536. Die zusätzlichen Zeichen werden in UTF-16 alsSurrogate-Paare gespeichert, das sind Paare von 16-Bit-Codeeinheiten, die ein einzelnes Zeichen darstellen. Um Mehrdeutigkeiten zu vermeiden, müssen die beiden Teile des Paares zwischen0xD800 und0xDFFF liegen, und diese Codeeinheiten werden nicht verwendet, um Ein-Code-Einheiten-Zeichen zu kodieren. (Genauer gesagt haben führende Surrogats, auch als High-Surrogat-Codeeinheiten bezeichnet, Werte zwischen0xD800 und0xDBFF einschließlich, während nachfolgende Surrogats, auch als Low-Surrogat-Codeeinheiten bezeichnet, Werte zwischen0xDC00 und0xDFFF einschließlich haben.) Jedes Unicode-Zeichen, bestehend aus einem oder zwei UTF-16-Codeeinheiten, wird auch alsUnicode-Codepunkt bezeichnet. Jeder Unicode-Codepunkt kann in einem String mit\u{xxxxxx} geschrieben werden, wobeixxxxxx 1–6 Hexadezimalziffern darstellt.

Ein "einsames Surrogat" ist eine 16-Bit-Codeeinheit, die eine der folgenden Beschreibungen erfüllt:

• Sie liegt im Bereich0xD800–0xDBFF, einschließlich (d.h. ist ein führendes Surrogat), aber es ist die letzte Codeeinheit im String, oder die nächste Codeeinheit ist kein nachfolgendes Surrogat.
• Sie liegt im Bereich0xDC00–0xDFFF, einschließlich (d.h. ist ein nachfolgendes Surrogat), aber es ist die erste Codeeinheit im String, oder die vorherige Codeeinheit ist kein führendes Surrogat.

Einsame Surrogate stellen kein Unicode-Zeichen dar. 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 wirdencodeURI() einenURIError für einsame Surrogate auslösen, da die URI-Kodierung UTF-8-Kodierung verwendet, die keine Kodierung für einsame Surrogate hat. Strings, die keine einsamen Surrogate enthalten, werden alswohlgeformte Strings bezeichnet und sind sicher in Funktionen zu verwenden, die nicht mit UTF-16 arbeiten (wieencodeURI() oderTextEncoder). Sie können mit der MethodeisWellFormed() überprüfen, ob ein String wohlgeformt ist, oder einsame Surrogate mit der MethodetoWellFormed() bereinigen.

Neben Unicode-Zeichen gibt es bestimmte Sequenzen von Unicode-Zeichen, die als eine visuelle Einheit behandelt werden sollten, bekannt als einGrapheme-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 der Zeichen Sie iterieren. Zum Beispiel wirdsplit("") nach UTF-16-Codeeinheiten aufteilen und dabei Surrogate-Paare trennen. String-Indizes beziehen sich auch auf den Index jeder UTF-16-Codeeinheit. Andererseits iteriert[Symbol.iterator]() nach Unicode-Codepunkten. Durch Grapheme-Cluster zu iterieren erfordert etwas eigenen 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 letters

Konstruktor

String()

ErstelltString-Objekte. Wenn als Funktion aufgerufen, gibt es primitive Werte des Typs String zurück.

Statische Methoden

String.fromCharCode()

Gibt einen String zurück, der aus der angegebenen Sequenz von Unicode-Werten erstellt wurde.

String.fromCodePoint()

Gibt einen String zurück, der aus der angegebenen Sequenz von Codepunkten erstellt wurde.

String.raw()

Gibt einen String zurück, der aus einem rohen Template-String erstellt wurde.

Instanzeigenschaften

Diese Eigenschaften sind aufString.prototype definiert und werden von allenString-Instanzen geteilt.

String.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. FürString-Instanzen ist der Anfangswert derString-Konstruktor.

Diese Eigenschaften sind Eigenheitenschaften jederString-Instanz.

Länge

Gibt dielength des Strings wider. Nur lesbar.

Instanzmethoden

String.prototype.at()

Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenenindex zurück. Akzeptiert negative ganze Zahlen, die vom letzten String-Zeichen rückwärts zählen.

String.prototype.charAt()

Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenenindex zurück.

String.prototype.charCodeAt()

Gibt eine Zahl zurück, die den UTF-16-Codeeinheitenwert am angegebenenindex darstellt.

String.prototype.codePointAt()

Gibt eine nichtnegative Ganzzahl zurück, die den Codepunktwert des UTF-16-kodierten Codepunkts am angegebenenpos darstellt.

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 der ZeichenfolgesearchString endet.

String.prototype.includes()

Bestimmt, ob der aufrufende StringsearchString enthält.

String.prototype.indexOf()

Gibt den Index innerhalb dieses Strings der ersten Vorkommen vonsearchValue zurück oder-1, wenn nicht gefunden.

String.prototype.isWellFormed()

Gibt einen booleschen Wert zurück, der angibt, ob dieser Stringeinsame Surrogates enthält.

String.prototype.lastIndexOf()

Gibt den Index innerhalb dieses Strings der letzten Vorkommen vonsearchValue zurück oder-1, wenn nicht gefunden.

String.prototype.localeCompare()

Gibt eine Zahl zurück, die angibt, ob die ReferenzzeichenkettecompareString vor, nach oder gleich der gegebenen Zeichenfolge in Sortierreihenfolge kommt.

String.prototype.match()

Wird verwendet, um regulären Ausdruckregexp mit einem String zu vergleichen.

String.prototype.matchAll()

Gibt einen Iterator allerregexp-Übereinstimmungen zurück.

String.prototype.normalize()

Gibt die Unicode-Normalisierungsform des aufrufenden String-Werts zurück.

String.prototype.padEnd()

Füllt den aktuellen String von Ende mit einem gegebenen String auf und gibt einen neuen String der LängetargetLength zurück.

String.prototype.padStart()

Füllt den aktuellen String von Anfang an mit einem gegebenen String auf und gibt einen neuen String der LängetargetLength zurück.

String.prototype.repeat()

Gibt einen String zurück, der aus den Elementen des Objekts besteht, dascount-mal wiederholt wird.

String.prototype.replace()

Wird verwendet, um Vorkommen vonsearchFor durchreplaceWith zu ersetzen.searchFor kann ein String oder regulärer Ausdruck sein, undreplaceWith kann ein String oder eine Funktion sein.

String.prototype.replaceAll()

Wird verwendet, um alle Vorkommen vonsearchFor durchreplaceWith zu ersetzen.searchFor kann ein String oder regulärer Ausdruck sein, undreplaceWith kann ein String oder eine Funktion sein.

String.prototype.search()

Sucht nach einem Übereinstimmung zwischen einem regulären Ausdruckregexp und dem aufrufenden String.

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 durch Aufteilen des aufrufenden Strings bei Vorkommen des Trennzeichenssep gefüllt wird.

String.prototype.startsWith()

Bestimmt, ob der aufrufende String mit den Zeichen der ZeichenfolgesearchString beginnt.

String.prototype.substr()Veraltet

Gibt einen Teil des Strings zurück, beginnend am angegebenen Index und erstreckt sich über eine gegebene Anzahl von Zeichen danach.

String.prototype.substring()

Gibt einen neuen String zurück, der die Zeichen des aufrufenden Strings von (oder zwischen) dem angegebenen Index (oder Indizes) enthält.

String.prototype.toLocaleLowerCase()

Die Zeichen innerhalb eines Strings werden unter Berücksichtigung der aktuellen Gebietsschemata in Kleinbuchstaben konvertiert.

Für die meisten Sprachen gibt dies dasselbe wietoLowerCase() zurück.

String.prototype.toLocaleUpperCase()

Die Zeichen innerhalb eines Strings werden unter Berücksichtigung der aktuellen Gebietsschemata in Großbuchstaben konvertiert.

Für die meisten Sprachen gibt dies dasselbe wietoUpperCase() zurück.

String.prototype.toLowerCase()

Gibt den aufrufenden String-Wert in Kleinbuchstaben konvertiert zurück.

String.prototype.toString()

Gibt eine Zeichenfolge zurück, die das spezifizierte Objekt darstellt. Überschreibt die MethodeObject.prototype.toString().

String.prototype.toUpperCase()

Gibt den aufrufenden String-Wert in Großbuchstaben konvertiert zurück.

String.prototype.toWellFormed()

Gibt einen String zurück, bei dem alleeinsamen Surrogates dieses Strings durch das Unicode-Ersatzzeichen U+FFFD ersetzt sind.

String.prototype.trim()

Entfernt Leerzeichen vom Anfang und Ende des Strings.

String.prototype.trimEnd()

Entfernt Leerzeichen vom Ende des Strings.

String.prototype.trimStart()

Entfernt Leerzeichen vom Anfang des Strings.

String.prototype.valueOf()

Gibt den primitiven Wert des angegebenen Objekts zurück. Überschreibt die MethodeObject.prototype.valueOf().

String.prototype[Symbol.iterator]()

Gibt ein neues Iterator-Objekt zurück, das über die Codepunkte eines String-Werts iteriert und bei jedem Codepunkt einen String-Wert zurückgibt.

HTML-Wrapper-Methoden

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()Veraltet

<font color="color">

String.prototype.fontsize()Veraltet

<font size="size">

String.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 prüfen, ob der String selbst HTML-Tags enthält, sodass es möglich ist, ungültiges HTML zu erstellen:

"</b>".bold(); // <b></b></b>

Das einzige Escape-Verfahren, das sie durchführen, besteht darin," im Attributwert (füranchor(),fontcolor(),fontsize() undlink()) durch" zu ersetzen.

"foo".anchor('"Hello"'); // <a name="&quot;Hello&quot;">foo</a>

Beispiele

String-Konvertierung

DieString()-Funktion ist eine zuverlässigere Methode zur Konvertierung von Werten in Strings als der Aufruf dertoString()-Methode des Werts, da die erstgenannte Methode auch funktioniert, wenn sie aufnull undundefined angewendet wird. Zum Beispiel:

// You cannot access properties on null or undefinedconst nullVar = null;nullVar.toString(); // TypeError: Cannot read properties of nullString(nullVar); // "null"const undefinedVar = undefined;undefinedVar.toString(); // TypeError: Cannot read properties of undefinedString(undefinedVar); // "undefined"

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Numbers and strings Leitfaden
• RegExp