String

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 ihrer length, das Erstellen und Verketten von Strings mithilfe der + und += String-Operatoren, das Überprüfen auf das Vorhandensein oder die Position von Unterstrings mit der Methode indexOf() oder das Extrahieren von Unterstrings mit der Methode substring().

Strings können als primitive Datentypen, aus Zeichenfolgenliteralen 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.

Zeichenfolgenliterale können entweder mit einfachen oder doppelten Anführungszeichen angegeben werden, die identisch behandelt werden, oder mit dem Backtick-Zeichen `. Diese letzte Form gibt ein Template Literal an: Mit dieser Form können Sie Ausdrücke interpolieren. Weitere Informationen zur Syntax von Zeichenfolgenliteralen finden Sie im lexikalischen Grammar.

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

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

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

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

Wenn Sie die Klammernotation für den Zeichenzugriff verwenden, schlägt der Versuch, einen Wert diesen Eigenschaften zu löschen oder zuzuweisen, fehl. Die betroffenen Eigenschaften sind weder schreibbar noch konfigurierbar. (Siehe Object.defineProperty() für weitere Informationen.)

Verwenden Sie die Kleiner- 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 unter Berücksichtigung der Groß- und Kleinschreibung vergleichen. Eine übliche Methode, Strings ohne Berücksichtigung der Groß- und Kleinschreibung zu vergleichen, besteht darin, beide in denselben Fall (groß oder klein) umzuwandeln, bevor sie verglichen werden.

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

Die Wahl, ob durch toUpperCase() oder toLowerCase() transformiert wird, ist weitgehend willkürlich, und keine der beiden ist vollständig robust, wenn sie über das lateinische Alphabet hinausgeht. Zum Beispiel werden der deutsche Kleinbuchstabe ß und ss beide durch toUpperCase() in SS umgewandelt, während der türkische Buchstabe ı fälschlicherweise als ungleich zu I gemeldet würde, es sei denn, man verwendet speziell 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 true

Eine lokalbewusste und robuste Lösung zum Testen von Gleichheit ohne Berücksichtigung der Groß- und Kleinschreibung ist die Verwendung der Intl.Collator API oder der localeCompare()-Methode des Strings — sie haben dieselbe Schnittstelle — mit der sensitivity-Option, die auf "accent" oder "base" gesetzt ist.

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 einen String-Vergleich in ähnlicher Weise wie strcmp() — sie ermöglicht das Sortieren von Strings in einem lokalbewussten Stil.

Beachten Sie, dass JavaScript zwischen String-Objekten und primitiven String-Werten unterscheidet. (Dasselbe gilt für Boolean und Numbers.)

Zeichenfolgenliterale (angegeben durch doppelte oder einfache Anführungszeichen) und Zeichenfolgen, die von String-Aufrufen in einem Nicht-Konstruktor-Kontext (das heißt, ohne das Schlüsselwort new verwendet) zurückgegeben werden, sind primitive Strings. In Kontexten, in denen eine Methode auf einem primitiven String aufgerufen oder ein Lesezugriff auf eine Eigenschaft erfolgt, wird JavaScript den String-Primitive automatisch umhüllen und die Methode auf dem Wrapper-Objekt aufrufen oder den Zugriff auf die Eigenschaft 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"

String-Primitiven und String-Objekte geben auch unterschiedliche Ergebnisse, wenn eval() verwendet wird. 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 er auf String-Objekte trifft, wenn er stattdessen einen primitiven String erwartet, obwohl sich Autoren im Allgemeinen nicht um die Unterscheidung kümmern müssen.

Ein String-Objekt kann immer mit der Methode valueOf() in sein primitives Gegenstück umgewandelt werden.

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

Viele eingebettete Operationen, die Strings erwarten, wandeln ihre Argumente zunächst in Strings um (was weitgehend der Grund ist, warum 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) umgewandelt.
• BigInts werden mit dem gleichen Algorithmus wie toString(10) umgewandelt.
• Symbole werfen eine TypeError.
• Objekte werden zuerst in einen primitiven Wert umgewandelt, indem ihre Methoden [Symbol.toPrimitive]() (mit "string" als Hinweis), toString() und valueOf() in dieser Reihenfolge aufgerufen werden. Der resultierende primitive Wert wird dann in einen String umgewandelt.

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

• Template Literal: `${x}` führt genau die oben beschriebenen String-Konvertierungsschritte für den eingebetteten Ausdruck durch.
• Die String()-Funktion: String(x) verwendet denselben Algorithmus, um x zu konvertieren, außer dass Symbole keine TypeError werfen, sondern "Symbol(description)" zurückgeben, wobei description die Beschreibung des Symbols ist.
• Die Verwendung des + Operators: "" + x zwingt sein Operand zu einem primitiven Wert anstelle eines Strings zu werden, und hat für einige Objekte ein völlig anderes Verhalten als normale String-Umwandlung. Siehe die Referenzseite für weitere Details.

Abhängig von Ihrem Anwendungsfall möchten Sie möglicherweise `${x}` (um das eingebettete Verhalten nachzuahmen) oder String(x) (um Symbol-Werte ohne Fehler zu behandeln) verwenden, aber Sie sollten nicht "" + x verwenden.

Strings werden grundsätzlich als Sequenzen von UTF-16-Codeeinheiten dargestellt. In der UTF-16-Kodierung ist jede Code-Einheit genau 16 Bit lang. Dies bedeutet, dass es maximal 2¹⁶, oder 65536 mögliche Zeichen gibt, die als einzelne UTF-16-Codeeinheiten darstellbar sind. Diese Zeichenmenge 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 Hexadezimalziffern geschrieben werden.

Das gesamte Unicode-Zeichenset ist jedoch weitaus größer als 65536. Die zusätzlichen Zeichen werden in UTF-16 als Surrogate-Paare gespeichert, die Paare von 16-Bit-Codeeinheiten sind, 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 verwendet, um einzelne Codeeinheiten-Zeichen zu codieren. (Genauer gesagt liegen führende Surrogate, auch Hoch-Surrogate genannt, zwischen 0xD800 und 0xDBFF inklusive, während nachfolgende Surrogate, auch Nieder-Surrogate genannt, Werte zwischen 0xDC00 und 0xDFFF inklusive haben.) Jedes Unicode-Zeichen, das aus einer oder zwei UTF-16-Codeeinheiten besteht, wird auch als Unicode-Codepunkt bezeichnet. Jeder Unicode-Codepunkt kann in einem String mit \u{xxxxxx} geschrieben werden, wobei xxxxxx 1-6 Hexadezimalziffern darstellt.

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

• Er liegt im Bereich 0xD800–0xDBFF inklusive (d.h. er ist ein führender Surrogat), aber er ist die letzte Codeeinheit im String, oder die nächste Codeeinheit ist kein nachfolgender Surrogat.
• Er liegt im Bereich 0xDC00–0xDFFF inklusive (d.h. er ist ein nachfolgender Surrogat), aber er ist die erste Codeeinheit im String, oder die vorherige Codeeinheit ist kein führender Surrogat.

Einsame Surrogate repräsentieren kein Unicode-Zeichen. Obwohl die meisten eingebauten JavaScript-Methoden sie korrekt behandeln, da sie alle auf UTF-16-Codeeinheiten basieren, sind einsame Surrogate oft keine gültigen Werte beim Interagieren mit anderen Systemen — zum Beispiel wirft encodeURI() einen URIError für einsame Surrogate, da die URI-Kodierung UTF-8 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 (wie encodeURI() oder TextEncoder) arbeiten. Sie können überprüfen, ob ein String wohlgeformt ist, mit der Methode isWellFormed() oder einsame Surrogate mit der Methode toWellFormed() bereinigen.

Neben Unicode-Zeichen gibt es bestimmte Sequenzen von Unicode-Zeichen, die als eine visuelle Einheit behandelt werden sollten, bekannt als Graphem-Cluster. Der häufigste Fall sind Emojis: Viele Emojis, die eine Vielzahl von Variationen haben, werden tatsächlich durch mehrere Emojis gebildet, normalerweise verbunden durch den <ZWJ> (U+200D) Charakter.

Sie müssen vorsichtig sein, auf welcher Ebene von Zeichen Sie iterieren. Zum Beispiel trennt split("") nach UTF-16-Codeeinheiten und wird Surrogate-Paare trennen. String-Indizes beziehen sich auch auf den Index jeder UTF-16-Codeeinheit. Andererseits iteriert [Symbol.iterator]() auf Unicode-Codepunkten. Das Iterieren von 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

String()

Erstellt String-Objekte. Wenn sie als Funktion aufgerufen wird, gibt sie primitive Werte vom Typ String zurück.

String.fromCharCode()

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

String.fromCodePoint()

Gibt einen String zurück, der durch die Verwendung der angegebenen Sequenz von Codepunkten erstellt wurde.

String.raw()

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

Diese Eigenschaften sind auf String.prototype definiert und werden von allen String-Instanzen geteilt.

String.prototype.constructor

Die Konstruktor-Funktion, die das Instanzobjekt erstellt hat. Für String-Instanzen ist der Anfangswert der String-Konstruktor.

Diese Eigenschaften sind Eigen-Eigenschaften jeder String-Instanz.

length

Entspricht der length des Strings. Nur lesen.

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 Zeichenfolge aus zählen.

String.prototype.charAt()

Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am 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 nichtnegative ganze Zahl zurück, die dem Wert des UTF-16-kodierten Codepunkts entspricht, der an der angegebenen pos beginnt.

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.

String.prototype.includes()

Bestimmt, ob der aufrufende String searchString enthält.

String.prototype.indexOf()

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

String.prototype.isWellFormed()

Gibt einen Boolean zurück, der angibt, ob dieser String keine einsamen Surrogate enthält.

String.prototype.lastIndexOf()

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

String.prototype.localeCompare()

Gibt eine Zahl zurück, die angibt, ob der Referenzstring compareString vor, nach oder gleich dem gegebenen String in der Sortierreihenfolge kommt.

String.prototype.match()

Wird verwendet, um den regulären Ausdruck regexp gegen einen String abzugleichen.

String.prototype.matchAll()

Gibt einen Iterator aller Übereinstimmungen von regexp zurück.

String.prototype.normalize()

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

String.prototype.padEnd()

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

String.prototype.padStart()

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

String.prototype.repeat()

Gibt einen String zurück, der aus den Elementen des Objekts besteht, die count-mal wiederholt werden.

String.prototype.replace()

Wird verwendet, um Vorkommen von searchFor mit replaceWith zu ersetzen. searchFor kann ein String oder ein regulärer Ausdruck sein und replaceWith kann ein String oder eine Funktion sein.

String.prototype.replaceAll()

Wird verwendet, um alle Vorkommen von searchFor mit replaceWith zu ersetzen. searchFor kann ein String oder ein regulärer Ausdruck sein und replaceWith kann ein String oder eine Funktion sein.

String.prototype.search()

Sucht nach einer Übereinstimmung zwischen einem regulären Ausdruck regexp 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 das Teilen des aufrufenden Strings an Vorkommen des Unterstrings sep gefüllt wird.

String.prototype.startsWith()

Bestimmt, ob der aufrufende String mit den Zeichen des Strings searchString beginnt.

String.prototype.substr() Veraltet

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

String.prototype.substring()

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

String.prototype.toLocaleLowerCase()

Die Zeichen in einem String werden unter Berücksichtigung der aktuellen lokalen Einstellungen in Kleinbuchstaben umgewandelt.

Für die meisten Sprachen wird das gleiche zurückgegeben wie toLowerCase().

String.prototype.toLocaleUpperCase()

Die Zeichen in einem String werden unter Berücksichtigung der aktuellen lokalen Einstellungen in Großbuchstaben umgewandelt.

Für die meisten Sprachen wird dasselbe zurückgegeben wie toUpperCase().

String.prototype.toLowerCase()

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

String.prototype.toString()

Gibt einen String zurück, der das angegebene Objekt darstellt. Überschreibt die Methode Object.prototype.toString().

String.prototype.toUpperCase()

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

String.prototype.toWellFormed()

Gibt einen String zurück, in dem alle einsamen Surrogate dieses Strings durch das Unicode-Ersatzzeichen U+FFFD ersetzt werden.

String.prototype.trim()

Schneidet Leerzeichen vom Anfang und Ende des Strings ab.

String.prototype.trimEnd()

Schneidet Leerzeichen vom Ende des Strings ab.

String.prototype.trimStart()

Schneidet Leerzeichen vom Anfang des Strings ab.

String.prototype.valueOf()

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

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.

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 überprü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 Escaping, das sie vornehmen, ist das Ersetzen von " im Attributwert (für anchor(), fontcolor(), fontsize() und link()) durch ".

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

Die Funktion String() ist eine zuverlässigere Methode zum Konvertieren von Werten in Strings als der Aufruf der toString()-Methode des Wertes, da die erstere funktioniert, wenn sie auf null und undefined angewendet wird. 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"

• Zahlen und Strings Leitfaden
• RegExp